Mercurial > hg > xemacs-beta
annotate src/glyphs-msw.c @ 5090:0ca81354c4c7
Further frame-geometry cleanups
-------------------- ChangeLog entries follow: --------------------
man/ChangeLog addition:
2010-03-03 Ben Wing <ben@xemacs.org>
* internals/internals.texi (Intro to Window and Frame Geometry):
* internals/internals.texi (The Paned Area):
* internals/internals.texi (The Displayable Area):
Update to make note of e.g. the fact that the bottom gutter is
actually above the minibuffer.
src/ChangeLog addition:
2010-03-03 Ben Wing <ben@xemacs.org>
* emacs.c:
* emacs.c (assert_equal_failed):
* lisp.h:
* lisp.h (assert_equal):
New fun assert_equal, asserting that two values == each other, and
printing out both values upon failure.
* frame-gtk.c (gtk_initialize_frame_size):
* frame-impl.h:
* frame-impl.h (FRAME_TOP_INTERNAL_BORDER_START):
* frame-impl.h (FRAME_BOTTOM_INTERNAL_BORDER_START):
* frame-impl.h (FRAME_LEFT_INTERNAL_BORDER_START):
* frame-impl.h (FRAME_PANED_TOP_EDGE):
* frame-impl.h (FRAME_NONPANED_SIZE):
* frame-x.c (x_initialize_frame_size):
* frame.c:
* gutter.c (get_gutter_coords):
* gutter.c (calculate_gutter_size):
* gutter.h:
* gutter.h (WINDOW_REAL_TOP_GUTTER_BOUNDS):
* gutter.h (FRAME_TOP_GUTTER_BOUNDS):
* input-method-xlib.c:
* input-method-xlib.c (XIM_SetGeometry):
* redisplay-output.c (clear_left_border):
* redisplay-output.c (clear_right_border):
* redisplay-output.c (redisplay_output_pixmap):
* redisplay-output.c (redisplay_clear_region):
* redisplay-output.c (redisplay_clear_top_of_window):
* redisplay-output.c (redisplay_clear_to_window_end):
* redisplay-xlike-inc.c (XLIKE_clear_frame):
* redisplay.c:
* redisplay.c (UPDATE_CACHE_RETURN):
* redisplay.c (pixel_to_glyph_translation):
* toolbar.c (update_frame_toolbars_geometry):
* window.c (Fwindow_pixel_edges):
Get rid of some redundant macros. Consistently use the
FRAME_TOP_*_START, FRAME_RIGHT_*_END, etc. format. Rename
FRAME_*_BORDER_* to FRAME_*_INTERNAL_BORDER_*. Comment out
FRAME_BOTTOM_* for gutters and the paned area due to the
uncertainty over where the paned area actually begins. (Eventually
we should probably move the gutters outside the minibuffer so that
the paned area is contiguous.) Use FRAME_PANED_* more often in the
code to make things clearer.
Update the diagram to show that the bottom gutter is inside the
minibuffer (!) and that there are "junk boxes" when you have left
and/or right gutters (dead boxes that are mistakenly left uncleared,
unlike the corresponding scrollbar dead boxes). Update the text
appropriately to cover the bottom gutter position, etc.
Rewrite gutter-geometry code to use the FRAME_*_GUTTER_* in place of
equivalent expressions referencing other frame elements, to make the
code more portable in case we move around the gutter location.
Cleanup FRAME_*_GUTTER_BOUNDS() in gutter.h.
Add some #### GEOM! comments where I think code is incorrect --
typically, it wasn't fixed up properly when the gutter was added.
Some cosmetic changes.
| author | Ben Wing <ben@xemacs.org> |
|---|---|
| date | Wed, 03 Mar 2010 05:07:47 -0600 |
| parents | 07dcc7000bbf |
| children | 8b2f75cecb89 |
| rev | line source |
|---|---|
| 428 | 1 /* mswindows-specific glyph objects. |
| 438 | 2 Copyright (C) 1998, 1999, 2000 Andy Piper. |
| 2959 | 3 Copyright (C) 2001, 2002, 2003, 2004, 2005 Ben Wing. |
| 434 | 4 |
| 428 | 5 This file is part of XEmacs. |
| 6 | |
| 7 XEmacs is free software; you can redistribute it and/or modify it | |
| 8 under the terms of the GNU General Public License as published by the | |
| 9 Free Software Foundation; either version 2, or (at your option) any | |
| 10 later version. | |
| 11 | |
| 12 XEmacs is distributed in the hope that it will be useful, but WITHOUT | |
| 13 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
| 14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
| 15 for more details. | |
| 16 | |
| 17 You should have received a copy of the GNU General Public License | |
| 18 along with XEmacs; see the file COPYING. If not, write to | |
| 19 the Free Software Foundation, Inc., 59 Temple Place - Suite 330, | |
| 20 Boston, MA 02111-1307, USA. */ | |
| 21 | |
| 22 /* Synched up with: Not in FSF. */ | |
| 23 | |
| 771 | 24 /* This file apparently Mule-ized, 8-7-2000, but could stand review. */ |
| 25 | |
| 442 | 26 /* written by Andy Piper <andy@xemacs.org> plagiarising bits from |
| 428 | 27 glyphs-x.c */ |
| 28 | |
| 771 | 29 #define NEED_MSWINDOWS_COMMCTRL |
| 30 | |
| 428 | 31 #include <config.h> |
| 32 #include "lisp.h" | |
| 800 | 33 |
| 872 | 34 #include "device-impl.h" |
| 800 | 35 #include "elhash.h" |
| 36 #include "faces.h" | |
| 37 #include "file-coding.h" | |
| 872 | 38 #include "frame-impl.h" |
| 800 | 39 #include "gui.h" |
| 40 #include "imgproc.h" | |
| 41 #include "insdel.h" | |
| 428 | 42 #include "lstream.h" |
| 800 | 43 #include "opaque.h" |
| 44 #include "sysdep.h" | |
| 45 #include "sysfile.h" | |
| 46 #include "window.h" | |
| 428 | 47 |
| 872 | 48 #include "console-msw-impl.h" |
| 428 | 49 #include "glyphs-msw.h" |
| 872 | 50 #include "objects-msw-impl.h" |
| 428 | 51 |
| 52 #define WIDGET_GLYPH_SLOT 0 | |
| 53 | |
| 54 DECLARE_IMAGE_INSTANTIATOR_FORMAT (nothing); | |
| 55 DECLARE_IMAGE_INSTANTIATOR_FORMAT (string); | |
| 56 DECLARE_IMAGE_INSTANTIATOR_FORMAT (formatted_string); | |
| 57 DECLARE_IMAGE_INSTANTIATOR_FORMAT (inherit); | |
| 58 #ifdef HAVE_JPEG | |
| 59 DECLARE_IMAGE_INSTANTIATOR_FORMAT (jpeg); | |
| 60 #endif | |
| 61 #ifdef HAVE_TIFF | |
| 62 DECLARE_IMAGE_INSTANTIATOR_FORMAT (tiff); | |
| 434 | 63 #endif |
| 428 | 64 #ifdef HAVE_PNG |
| 65 DECLARE_IMAGE_INSTANTIATOR_FORMAT (png); | |
| 434 | 66 #endif |
| 428 | 67 #ifdef HAVE_GIF |
| 68 DECLARE_IMAGE_INSTANTIATOR_FORMAT (gif); | |
| 434 | 69 #endif |
| 428 | 70 #ifdef HAVE_XPM |
| 71 DEFINE_DEVICE_IIFORMAT (mswindows, xpm); | |
| 442 | 72 DEFINE_DEVICE_IIFORMAT (msprinter, xpm); |
| 428 | 73 #endif |
| 74 DEFINE_DEVICE_IIFORMAT (mswindows, xbm); | |
| 442 | 75 DEFINE_DEVICE_IIFORMAT (msprinter, xbm); |
| 428 | 76 #ifdef HAVE_XFACE |
| 77 DEFINE_DEVICE_IIFORMAT (mswindows, xface); | |
| 442 | 78 DEFINE_DEVICE_IIFORMAT (msprinter, xface); |
| 428 | 79 #endif |
| 442 | 80 DECLARE_IMAGE_INSTANTIATOR_FORMAT (layout); |
| 81 DEFINE_DEVICE_IIFORMAT (mswindows, native_layout); | |
| 428 | 82 DEFINE_DEVICE_IIFORMAT (mswindows, button); |
| 83 DEFINE_DEVICE_IIFORMAT (mswindows, edit_field); | |
| 84 DEFINE_DEVICE_IIFORMAT (mswindows, subwindow); | |
| 85 DEFINE_DEVICE_IIFORMAT (mswindows, widget); | |
| 86 DEFINE_DEVICE_IIFORMAT (mswindows, label); | |
| 87 DEFINE_DEVICE_IIFORMAT (mswindows, scrollbar); | |
| 88 DEFINE_DEVICE_IIFORMAT (mswindows, combo_box); | |
| 89 DEFINE_DEVICE_IIFORMAT (mswindows, progress_gauge); | |
| 90 DEFINE_DEVICE_IIFORMAT (mswindows, tree_view); | |
| 91 DEFINE_DEVICE_IIFORMAT (mswindows, tab_control); | |
| 92 | |
| 93 DEFINE_IMAGE_INSTANTIATOR_FORMAT (bmp); | |
| 94 Lisp_Object Qbmp; | |
| 95 Lisp_Object Vmswindows_bitmap_file_path; | |
| 96 static COLORREF transparent_color = RGB (1,1,1); | |
| 97 | |
| 98 DEFINE_IMAGE_INSTANTIATOR_FORMAT (mswindows_resource); | |
| 99 Lisp_Object Qmswindows_resource; | |
| 100 | |
| 101 static void | |
| 440 | 102 mswindows_initialize_dibitmap_image_instance (Lisp_Image_Instance *ii, |
| 428 | 103 int slices, |
| 104 enum image_instance_type type); | |
| 105 static void | |
| 771 | 106 mswindows_initialize_image_instance_mask (Lisp_Image_Instance *image, |
| 442 | 107 HDC hcdc); |
| 108 | |
| 109 /* | |
| 110 * Given device D, retrieve compatible device context. D can be either | |
| 111 * mswindows or an msprinter device. | |
| 112 */ | |
| 113 inline static HDC | |
| 114 get_device_compdc (struct device *d) | |
| 115 { | |
| 116 if (DEVICE_MSWINDOWS_P (d)) | |
| 117 return DEVICE_MSWINDOWS_HCDC (d); | |
| 118 else | |
| 119 return DEVICE_MSPRINTER_HCDC (d); | |
| 120 } | |
| 121 | |
| 122 /* | |
| 123 * Initialize image instance pixel sizes in II. For a display bitmap, | |
| 124 * these will be same as real bitmap sizes. For a printer bitmap, | |
| 125 * these will be scaled up so that the bitmap is proportionally enlarged | |
| 126 * when output to printer. Redisplay code takes care of scaling, to | |
| 127 * conserve memory we do not really scale bitmaps. Set the watermark | |
| 128 * only here. | |
| 129 * #### Add support for unscalable bitmaps. | |
| 130 */ | |
| 131 static void init_image_instance_geometry (Lisp_Image_Instance *ii) | |
| 132 { | |
| 133 struct device *d = DOMAIN_XDEVICE (ii->domain); | |
| 134 | |
| 135 if (/* #### Scaleable && */ DEVICE_MSPRINTER_P (d)) | |
| 136 { | |
| 137 HDC printer_dc = DEVICE_MSPRINTER_HCDC (d); | |
| 138 HDC display_dc = CreateCompatibleDC (NULL); | |
| 139 IMAGE_INSTANCE_PIXMAP_WIDTH (ii) = | |
| 140 MulDiv (IMAGE_INSTANCE_MSWINDOWS_BITMAP_REAL_WIDTH (ii), | |
| 141 GetDeviceCaps (printer_dc, LOGPIXELSX), | |
| 142 GetDeviceCaps (display_dc, LOGPIXELSX)); | |
| 143 IMAGE_INSTANCE_PIXMAP_HEIGHT (ii) = | |
| 144 MulDiv (IMAGE_INSTANCE_MSWINDOWS_BITMAP_REAL_HEIGHT (ii), | |
| 145 GetDeviceCaps (printer_dc, LOGPIXELSY), | |
| 146 GetDeviceCaps (display_dc, LOGPIXELSY)); | |
| 147 } | |
| 148 else | |
| 149 { | |
| 150 IMAGE_INSTANCE_PIXMAP_WIDTH (ii) = | |
| 151 IMAGE_INSTANCE_MSWINDOWS_BITMAP_REAL_WIDTH (ii); | |
| 152 IMAGE_INSTANCE_PIXMAP_HEIGHT (ii) = | |
| 153 IMAGE_INSTANCE_MSWINDOWS_BITMAP_REAL_HEIGHT (ii); | |
| 154 } | |
| 155 } | |
| 428 | 156 |
| 157 #define BPLINE(width) ((int)(~3UL & (unsigned long)((width) +3))) | |
| 158 | |
| 159 /************************************************************************/ | |
| 160 /* convert from a series of RGB triples to a BITMAPINFO formated for the*/ | |
| 161 /* proper display */ | |
| 162 /************************************************************************/ | |
| 771 | 163 static BITMAPINFO *convert_EImage_to_DIBitmap (Lisp_Object device, |
| 428 | 164 int width, int height, |
| 2367 | 165 Binbyte *pic, |
| 428 | 166 int *bit_count, |
| 2367 | 167 Binbyte **bmp_data) |
| 428 | 168 { |
| 169 struct device *d = XDEVICE (device); | |
| 771 | 170 int i, j; |
| 171 RGBQUAD *colortbl; | |
| 172 int ncolors; | |
| 173 BITMAPINFO *bmp_info; | |
| 2367 | 174 Binbyte *ip, *dp; |
| 428 | 175 |
| 442 | 176 if (GetDeviceCaps (get_device_compdc (d), BITSPIXEL) > 0) |
| 428 | 177 { |
| 178 int bpline = BPLINE(width * 3); | |
| 179 /* FIXME: we can do this because 24bpp implies no color table, once | |
| 180 * we start palettizing this is no longer true. The X versions of | |
| 181 * this function quantises to 256 colors or bit masks down to a | |
| 182 * long. Windows can actually handle rgb triples in the raw so I | |
| 183 * don't see much point trying to optimize down to the best | |
| 184 * structure - unless it has memory / color allocation implications | |
| 185 * .... */ | |
| 771 | 186 bmp_info = xnew_and_zero (BITMAPINFO); |
| 434 | 187 |
| 428 | 188 if (!bmp_info) |
| 189 { | |
| 190 return NULL; | |
| 191 } | |
| 192 | |
| 771 | 193 bmp_info->bmiHeader.biBitCount = 24; /* just RGB triples for now */ |
| 194 bmp_info->bmiHeader.biCompression = BI_RGB; /* just RGB triples | |
| 195 for now */ | |
| 196 bmp_info->bmiHeader.biSizeImage = width * height * 3; | |
| 428 | 197 |
| 198 /* bitmap data needs to be in blue, green, red triples - in that | |
| 199 order, eimage is in RGB format so we need to convert */ | |
| 2367 | 200 *bmp_data = xnew_array_and_zero (Binbyte, bpline * height); |
| 428 | 201 *bit_count = bpline * height; |
| 202 | |
| 203 if (!bmp_data) | |
| 204 { | |
|
4976
16112448d484
Rename xfree(FOO, TYPE) -> xfree(FOO)
Ben Wing <ben@xemacs.org>
parents:
4952
diff
changeset
|
205 xfree (bmp_info); |
| 428 | 206 return NULL; |
| 207 } | |
| 208 | |
| 209 ip = pic; | |
| 210 for (i = height-1; i >= 0; i--) { | |
| 211 dp = (*bmp_data) + (i * bpline); | |
| 212 for (j = 0; j < width; j++) { | |
| 771 | 213 dp[2] = *ip++; |
| 214 dp[1] = *ip++; | |
| 215 *dp = *ip++; | |
| 428 | 216 dp += 3; |
| 217 } | |
| 218 } | |
| 219 } | |
| 220 else /* scale to 256 colors */ | |
| 221 { | |
| 222 int rd,gr,bl; | |
| 223 quant_table *qtable; | |
| 224 int bpline = BPLINE (width * 3); | |
| 225 /* Quantize the image and get a histogram while we're at it. | |
| 226 Do this first to save memory */ | |
| 227 qtable = build_EImage_quantable(pic, width, height, 256); | |
| 228 if (qtable == NULL) return NULL; | |
| 229 | |
| 230 /* use our quantize table to allocate the colors */ | |
| 231 ncolors = qtable->num_active_colors; | |
| 771 | 232 bmp_info = (BITMAPINFO *)xmalloc_and_zero (sizeof(BITMAPINFOHEADER) + |
| 428 | 233 sizeof(RGBQUAD) * ncolors); |
| 234 if (!bmp_info) | |
| 235 { | |
|
4976
16112448d484
Rename xfree(FOO, TYPE) -> xfree(FOO)
Ben Wing <ben@xemacs.org>
parents:
4952
diff
changeset
|
236 xfree (qtable); |
| 428 | 237 return NULL; |
| 238 } | |
| 239 | |
| 2367 | 240 colortbl = (RGBQUAD *) (((Binbyte *) bmp_info) + |
| 771 | 241 sizeof (BITMAPINFOHEADER)); |
| 242 | |
| 243 bmp_info->bmiHeader.biBitCount = 8; | |
| 244 bmp_info->bmiHeader.biCompression = BI_RGB; | |
| 245 bmp_info->bmiHeader.biSizeImage = bpline * height; | |
| 246 bmp_info->bmiHeader.biClrUsed = ncolors; | |
| 247 bmp_info->bmiHeader.biClrImportant = ncolors; | |
| 434 | 248 |
| 2367 | 249 *bmp_data = xnew_array_and_zero (Binbyte, bpline * height); |
| 428 | 250 *bit_count = bpline * height; |
| 251 | |
| 252 if (!*bmp_data) | |
| 253 { | |
|
4976
16112448d484
Rename xfree(FOO, TYPE) -> xfree(FOO)
Ben Wing <ben@xemacs.org>
parents:
4952
diff
changeset
|
254 xfree (qtable); |
|
16112448d484
Rename xfree(FOO, TYPE) -> xfree(FOO)
Ben Wing <ben@xemacs.org>
parents:
4952
diff
changeset
|
255 xfree (bmp_info); |
| 428 | 256 return NULL; |
| 257 } | |
| 434 | 258 |
| 428 | 259 /* build up an RGBQUAD colortable */ |
| 442 | 260 for (i = 0; i < qtable->num_active_colors; i++) |
| 261 { | |
| 262 colortbl[i].rgbRed = (BYTE) qtable->rm[i]; | |
| 263 colortbl[i].rgbGreen = (BYTE) qtable->gm[i]; | |
| 264 colortbl[i].rgbBlue = (BYTE) qtable->bm[i]; | |
| 265 colortbl[i].rgbReserved = 0; | |
| 266 } | |
| 428 | 267 |
| 268 /* now build up the data. picture has to be upside-down and | |
| 269 back-to-front for msw bitmaps */ | |
| 270 ip = pic; | |
| 442 | 271 for (i = height-1; i >= 0; i--) |
| 272 { | |
| 273 dp = (*bmp_data) + (i * bpline); | |
| 274 for (j = 0; j < width; j++) | |
| 275 { | |
| 276 rd = *ip++; | |
| 277 gr = *ip++; | |
| 278 bl = *ip++; | |
| 279 *dp++ = QUANT_GET_COLOR (qtable,rd,gr,bl); | |
| 280 } | |
| 428 | 281 } |
|
4976
16112448d484
Rename xfree(FOO, TYPE) -> xfree(FOO)
Ben Wing <ben@xemacs.org>
parents:
4952
diff
changeset
|
282 xfree (qtable); |
| 434 | 283 } |
| 428 | 284 /* fix up the standard stuff */ |
| 771 | 285 bmp_info->bmiHeader.biWidth = width; |
| 286 bmp_info->bmiHeader.biHeight = height; | |
| 287 bmp_info->bmiHeader.biPlanes = 1; | |
| 288 bmp_info->bmiHeader.biSize = sizeof(BITMAPINFOHEADER); | |
| 289 bmp_info->bmiHeader.biXPelsPerMeter = 0; /* unless you know better */ | |
| 290 bmp_info->bmiHeader.biYPelsPerMeter = 0; | |
| 428 | 291 |
| 292 return bmp_info; | |
| 293 } | |
| 294 | |
| 295 /* Given a pixmap filename, look through all of the "standard" places | |
| 296 where the file might be located. Return a full pathname if found; | |
| 297 otherwise, return Qnil. */ | |
| 298 | |
| 299 static Lisp_Object | |
| 300 mswindows_locate_pixmap_file (Lisp_Object name) | |
| 301 { | |
| 302 /* This function can GC if IN_REDISPLAY is false */ | |
| 303 Lisp_Object found; | |
| 304 | |
| 305 /* Check non-absolute pathnames with a directory component relative to | |
| 306 the search path; that's the way Xt does it. */ | |
| 826 | 307 if (IS_DIRECTORY_SEP(string_byte (name, 0)) || |
| 308 (string_byte (name, 0) == '.' && | |
| 309 (IS_DIRECTORY_SEP(string_byte (name, 1)) || | |
| 310 (string_byte (name, 1) == '.' && | |
| 311 (IS_DIRECTORY_SEP(string_byte (name, 2))))))) | |
| 428 | 312 { |
| 313 if (!NILP (Ffile_readable_p (name))) | |
| 440 | 314 return Fexpand_file_name (name, Qnil); |
| 428 | 315 else |
| 316 return Qnil; | |
| 317 } | |
| 318 | |
| 319 if (locate_file (Vmswindows_bitmap_file_path, name, Qnil, &found, R_OK) < 0) | |
| 320 { | |
| 321 Lisp_Object temp = list1 (Vdata_directory); | |
| 322 struct gcpro gcpro1; | |
| 323 | |
| 324 GCPRO1 (temp); | |
| 325 locate_file (temp, name, Qnil, &found, R_OK); | |
| 326 UNGCPRO; | |
| 327 } | |
| 434 | 328 |
| 428 | 329 return found; |
| 330 } | |
| 331 | |
| 332 | |
| 333 /* Initialize an image instance from a bitmap | |
| 334 | |
| 335 DEST_MASK specifies the mask of allowed image types. | |
| 336 | |
| 337 If this fails, signal an error. INSTANTIATOR is only used | |
| 338 in the error message. */ | |
| 339 | |
| 340 static void | |
| 440 | 341 init_image_instance_from_dibitmap (Lisp_Image_Instance *ii, |
| 428 | 342 BITMAPINFO *bmp_info, |
| 343 int dest_mask, | |
| 344 void *bmp_data, | |
| 345 int bmp_bits, | |
| 346 int slices, | |
| 434 | 347 Lisp_Object instantiator, |
| 428 | 348 int x_hot, int y_hot, |
| 349 int create_mask) | |
| 350 { | |
| 442 | 351 struct device *d = XDEVICE (IMAGE_INSTANCE_DEVICE (ii)); |
| 771 | 352 void *bmp_buf = 0; |
| 442 | 353 enum image_instance_type type; |
| 428 | 354 HBITMAP bitmap; |
| 355 HDC hdc; | |
| 356 | |
| 357 if (dest_mask & IMAGE_COLOR_PIXMAP_MASK) | |
| 358 type = IMAGE_COLOR_PIXMAP; | |
| 359 else if (dest_mask & IMAGE_POINTER_MASK) | |
| 360 type = IMAGE_POINTER; | |
| 434 | 361 else |
| 428 | 362 incompatible_image_types (instantiator, dest_mask, |
| 363 IMAGE_COLOR_PIXMAP_MASK | IMAGE_POINTER_MASK); | |
| 442 | 364 |
| 365 hdc = get_device_compdc (d); | |
| 366 bitmap = CreateDIBSection (hdc, | |
| 367 bmp_info, | |
| 368 DIB_RGB_COLORS, | |
| 369 &bmp_buf, | |
| 370 0, 0); | |
| 428 | 371 |
| 372 if (!bitmap || !bmp_buf) | |
| 563 | 373 signal_image_error ("Unable to create bitmap", instantiator); |
| 428 | 374 |
| 375 /* copy in the actual bitmap */ | |
| 376 memcpy (bmp_buf, bmp_data, bmp_bits); | |
| 377 | |
| 378 mswindows_initialize_dibitmap_image_instance (ii, slices, type); | |
| 379 | |
| 380 IMAGE_INSTANCE_PIXMAP_FILENAME (ii) = | |
| 381 find_keyword_in_vector (instantiator, Q_file); | |
| 382 | |
| 383 /* Fixup a set of bitmaps. */ | |
| 384 IMAGE_INSTANCE_MSWINDOWS_BITMAP (ii) = bitmap; | |
| 385 | |
| 386 IMAGE_INSTANCE_MSWINDOWS_MASK (ii) = NULL; | |
| 442 | 387 IMAGE_INSTANCE_MSWINDOWS_BITMAP_REAL_WIDTH (ii) = |
| 388 bmp_info->bmiHeader.biWidth; | |
| 389 IMAGE_INSTANCE_MSWINDOWS_BITMAP_REAL_HEIGHT (ii) = | |
| 390 bmp_info->bmiHeader.biHeight; | |
| 391 IMAGE_INSTANCE_PIXMAP_DEPTH (ii) = bmp_info->bmiHeader.biBitCount; | |
| 793 | 392 IMAGE_INSTANCE_PIXMAP_HOTSPOT_X (ii) = make_int (x_hot); |
| 393 IMAGE_INSTANCE_PIXMAP_HOTSPOT_Y (ii) = make_int (y_hot); | |
| 442 | 394 init_image_instance_geometry (ii); |
| 428 | 395 |
| 396 if (create_mask) | |
| 397 { | |
| 442 | 398 mswindows_initialize_image_instance_mask (ii, hdc); |
| 428 | 399 } |
| 434 | 400 |
| 428 | 401 if (type == IMAGE_POINTER) |
| 402 { | |
| 403 mswindows_initialize_image_instance_icon(ii, TRUE); | |
| 404 } | |
| 405 } | |
| 406 | |
| 407 static void | |
| 440 | 408 image_instance_add_dibitmap (Lisp_Image_Instance *ii, |
| 428 | 409 BITMAPINFO *bmp_info, |
| 410 void *bmp_data, | |
| 411 int bmp_bits, | |
| 412 int slice, | |
| 413 Lisp_Object instantiator) | |
| 414 { | |
| 442 | 415 struct device *d = XDEVICE (IMAGE_INSTANCE_DEVICE (ii)); |
| 771 | 416 void *bmp_buf = 0; |
| 442 | 417 |
| 418 HBITMAP bitmap = CreateDIBSection (get_device_compdc (d), | |
| 428 | 419 bmp_info, |
| 420 DIB_RGB_COLORS, | |
| 434 | 421 &bmp_buf, |
| 428 | 422 0,0); |
| 434 | 423 |
| 428 | 424 if (!bitmap || !bmp_buf) |
| 563 | 425 signal_image_error ("Unable to create bitmap", instantiator); |
| 428 | 426 |
| 427 /* copy in the actual bitmap */ | |
| 428 memcpy (bmp_buf, bmp_data, bmp_bits); | |
| 429 IMAGE_INSTANCE_MSWINDOWS_BITMAP_SLICE (ii, slice) = bitmap; | |
| 430 } | |
| 431 | |
| 432 static void | |
| 440 | 433 mswindows_init_image_instance_from_eimage (Lisp_Image_Instance *ii, |
| 428 | 434 int width, int height, |
| 435 int slices, | |
| 2367 | 436 Binbyte *eimage, |
| 428 | 437 int dest_mask, |
| 438 Lisp_Object instantiator, | |
| 2959 | 439 Lisp_Object UNUSED (pointer_fg), |
| 440 Lisp_Object UNUSED (pointer_bg), | |
| 428 | 441 Lisp_Object domain) |
| 442 { | |
| 443 Lisp_Object device = IMAGE_INSTANCE_DEVICE (ii); | |
| 771 | 444 BITMAPINFO * bmp_info; |
| 2367 | 445 Binbyte * bmp_data; |
| 428 | 446 int bmp_bits; |
| 447 COLORREF bkcolor; | |
| 448 int slice; | |
| 434 | 449 |
| 442 | 450 CHECK_MSGDI_DEVICE (device); |
| 428 | 451 |
| 452 /* this is a hack but MaskBlt and TransparentBlt are not supported | |
| 453 on most windows variants */ | |
| 434 | 454 bkcolor = COLOR_INSTANCE_MSWINDOWS_COLOR |
| 428 | 455 (XCOLOR_INSTANCE (FACE_BACKGROUND (Vdefault_face, domain))); |
| 456 | |
| 457 for (slice = 0; slice < slices; slice++) | |
| 458 { | |
| 459 /* build a bitmap from the eimage */ | |
| 771 | 460 if (!(bmp_info = convert_EImage_to_DIBitmap (device, width, height, |
| 428 | 461 eimage + (width * height * 3 * slice), |
| 462 &bmp_bits, &bmp_data))) | |
| 463 { | |
| 563 | 464 signal_image_error ("EImage to DIBitmap conversion failed", |
| 465 instantiator); | |
| 428 | 466 } |
| 467 | |
| 468 /* Now create the pixmap and set up the image instance */ | |
| 469 if (slice == 0) | |
| 470 init_image_instance_from_dibitmap (ii, bmp_info, dest_mask, | |
| 471 bmp_data, bmp_bits, slices, instantiator, | |
| 472 0, 0, 0); | |
| 473 else | |
| 474 image_instance_add_dibitmap (ii, bmp_info, bmp_data, bmp_bits, slice, | |
| 475 instantiator); | |
| 434 | 476 |
|
4976
16112448d484
Rename xfree(FOO, TYPE) -> xfree(FOO)
Ben Wing <ben@xemacs.org>
parents:
4952
diff
changeset
|
477 xfree (bmp_info); |
|
16112448d484
Rename xfree(FOO, TYPE) -> xfree(FOO)
Ben Wing <ben@xemacs.org>
parents:
4952
diff
changeset
|
478 xfree (bmp_data); |
| 428 | 479 } |
| 480 } | |
| 481 | |
| 442 | 482 inline static void |
| 2367 | 483 set_mono_pixel (Binbyte *bits, |
| 442 | 484 int bpline, int height, |
| 485 int x, int y, int white) | |
| 434 | 486 { |
| 438 | 487 int i; |
| 2367 | 488 Binbyte bitnum; |
| 428 | 489 /* Find the byte on which this scanline begins */ |
| 438 | 490 i = (height - y - 1) * bpline; |
| 428 | 491 /* Find the byte containing this pixel */ |
| 438 | 492 i += (x >> 3); |
| 428 | 493 /* Which bit is it? */ |
| 2367 | 494 bitnum = (Binbyte) (7 - (x & 7)); |
| 442 | 495 if (white) /* Turn it on */ |
| 496 bits[i] |= (1 << bitnum); | |
| 497 else /* Turn it off */ | |
| 498 bits[i] &= ~(1 << bitnum); | |
| 434 | 499 } |
| 428 | 500 |
| 501 static void | |
| 771 | 502 mswindows_initialize_image_instance_mask (Lisp_Image_Instance *image, |
| 442 | 503 HDC hcdc) |
| 428 | 504 { |
| 505 HBITMAP mask; | |
| 506 HGDIOBJ old = NULL; | |
| 2367 | 507 Binbyte *dibits, *and_bits; |
| 442 | 508 BITMAPINFO *bmp_info = |
| 771 | 509 (BITMAPINFO *) xmalloc_and_zero (sizeof (BITMAPINFO) + sizeof (RGBQUAD)); |
| 428 | 510 int i, j; |
| 442 | 511 int height = IMAGE_INSTANCE_MSWINDOWS_BITMAP_REAL_HEIGHT (image); |
| 512 | |
| 513 int maskbpline = BPLINE ((IMAGE_INSTANCE_MSWINDOWS_BITMAP_REAL_WIDTH (image) + 7) / 8); | |
| 514 int bpline = BPLINE (IMAGE_INSTANCE_MSWINDOWS_BITMAP_REAL_WIDTH (image) * 3); | |
| 428 | 515 |
| 516 if (!bmp_info) | |
| 517 return; | |
| 518 | |
| 771 | 519 bmp_info->bmiHeader.biWidth = IMAGE_INSTANCE_MSWINDOWS_BITMAP_REAL_WIDTH (image); |
| 428 | 520 bmp_info->bmiHeader.biHeight = height; |
| 442 | 521 bmp_info->bmiHeader.biPlanes = 1; |
| 771 | 522 bmp_info->bmiHeader.biSize = sizeof(BITMAPINFOHEADER); |
| 442 | 523 bmp_info->bmiHeader.biBitCount = 1; |
| 524 bmp_info->bmiHeader.biCompression = BI_RGB; | |
| 434 | 525 bmp_info->bmiHeader.biClrUsed = 2; |
| 526 bmp_info->bmiHeader.biClrImportant = 2; | |
| 527 bmp_info->bmiHeader.biSizeImage = height * maskbpline; | |
| 428 | 528 bmp_info->bmiColors[0].rgbRed = 0; |
| 529 bmp_info->bmiColors[0].rgbGreen = 0; | |
| 530 bmp_info->bmiColors[0].rgbBlue = 0; | |
| 531 bmp_info->bmiColors[0].rgbReserved = 0; | |
| 532 bmp_info->bmiColors[1].rgbRed = 255; | |
| 533 bmp_info->bmiColors[1].rgbGreen = 255; | |
| 534 bmp_info->bmiColors[1].rgbBlue = 255; | |
| 535 bmp_info->bmiColors[0].rgbReserved = 0; | |
| 434 | 536 |
| 537 if (!(mask = CreateDIBSection (hcdc, | |
| 428 | 538 bmp_info, |
| 539 DIB_RGB_COLORS, | |
| 2367 | 540 /* The intermediate cast fools gcc into |
| 541 not outputting strict-aliasing | |
| 542 complaints */ | |
| 543 (void **) (void *) &and_bits, | |
| 428 | 544 0,0))) |
| 545 { | |
|
4976
16112448d484
Rename xfree(FOO, TYPE) -> xfree(FOO)
Ben Wing <ben@xemacs.org>
parents:
4952
diff
changeset
|
546 xfree (bmp_info); |
| 428 | 547 return; |
| 548 } | |
| 549 | |
| 550 old = SelectObject (hcdc, IMAGE_INSTANCE_MSWINDOWS_BITMAP (image)); | |
| 551 /* build up an in-memory set of bits to mess with */ | |
| 552 xzero (*bmp_info); | |
| 553 | |
| 442 | 554 bmp_info->bmiHeader.biWidth = IMAGE_INSTANCE_MSWINDOWS_BITMAP_REAL_WIDTH (image); |
| 428 | 555 bmp_info->bmiHeader.biHeight = -height; |
| 442 | 556 bmp_info->bmiHeader.biPlanes = 1; |
| 557 bmp_info->bmiHeader.biSize = sizeof(BITMAPINFOHEADER); | |
| 558 bmp_info->bmiHeader.biBitCount = 24; | |
| 559 bmp_info->bmiHeader.biCompression = BI_RGB; | |
| 434 | 560 bmp_info->bmiHeader.biClrUsed = 0; |
| 561 bmp_info->bmiHeader.biClrImportant = 0; | |
| 428 | 562 bmp_info->bmiHeader.biSizeImage = height * bpline; |
| 563 | |
| 2367 | 564 dibits = xnew_array_and_zero (Binbyte, bpline * height); |
| 428 | 565 if (GetDIBits (hcdc, |
| 566 IMAGE_INSTANCE_MSWINDOWS_BITMAP (image), | |
| 567 0, | |
| 568 height, | |
| 569 dibits, | |
| 570 bmp_info, | |
| 571 DIB_RGB_COLORS) <= 0) | |
| 572 { | |
|
4976
16112448d484
Rename xfree(FOO, TYPE) -> xfree(FOO)
Ben Wing <ben@xemacs.org>
parents:
4952
diff
changeset
|
573 xfree (bmp_info); |
| 428 | 574 return; |
| 575 } | |
| 576 | |
| 577 /* now set the colored bits in the mask and transparent ones to | |
| 578 black in the original */ | |
| 442 | 579 for (i = 0; i < IMAGE_INSTANCE_MSWINDOWS_BITMAP_REAL_WIDTH (image); i++) |
| 434 | 580 { |
| 771 | 581 for (j = 0; j < height; j++) |
| 434 | 582 { |
| 2367 | 583 Binbyte *idx = &dibits[j * bpline + i * 3]; |
| 428 | 584 |
| 442 | 585 if (RGB (idx[2], idx[1], idx[0]) == transparent_color) |
| 434 | 586 { |
| 428 | 587 idx[0] = idx[1] = idx[2] = 0; |
| 442 | 588 set_mono_pixel (and_bits, maskbpline, height, i, j, TRUE); |
| 428 | 589 } |
| 434 | 590 else |
| 591 { | |
| 442 | 592 set_mono_pixel (and_bits, maskbpline, height, i, j, FALSE); |
| 428 | 593 } |
| 594 } | |
| 595 } | |
| 596 | |
| 597 SetDIBits (hcdc, | |
| 598 IMAGE_INSTANCE_MSWINDOWS_BITMAP (image), | |
| 599 0, | |
| 600 height, | |
| 601 dibits, | |
| 602 bmp_info, | |
| 603 DIB_RGB_COLORS); | |
| 604 | |
|
4976
16112448d484
Rename xfree(FOO, TYPE) -> xfree(FOO)
Ben Wing <ben@xemacs.org>
parents:
4952
diff
changeset
|
605 xfree (bmp_info); |
|
16112448d484
Rename xfree(FOO, TYPE) -> xfree(FOO)
Ben Wing <ben@xemacs.org>
parents:
4952
diff
changeset
|
606 xfree (dibits); |
| 434 | 607 |
| 428 | 608 SelectObject(hcdc, old); |
| 609 | |
| 610 IMAGE_INSTANCE_MSWINDOWS_MASK (image) = mask; | |
| 611 } | |
| 612 | |
| 613 void | |
| 771 | 614 mswindows_initialize_image_instance_icon (Lisp_Image_Instance *image, |
| 428 | 615 int cursor) |
| 616 { | |
| 617 ICONINFO x_icon; | |
| 618 | |
| 619 /* we rely on windows to do any resizing necessary */ | |
| 771 | 620 x_icon.fIcon = cursor ? FALSE : TRUE; |
| 621 x_icon.xHotspot = XINT (IMAGE_INSTANCE_PIXMAP_HOTSPOT_X (image)); | |
| 622 x_icon.yHotspot = XINT (IMAGE_INSTANCE_PIXMAP_HOTSPOT_Y (image)); | |
| 623 x_icon.hbmMask = IMAGE_INSTANCE_MSWINDOWS_MASK (image); | |
| 624 x_icon.hbmColor = IMAGE_INSTANCE_MSWINDOWS_BITMAP (image); | |
| 434 | 625 |
| 428 | 626 IMAGE_INSTANCE_MSWINDOWS_ICON (image)= |
| 627 CreateIconIndirect (&x_icon); | |
| 628 } | |
| 629 | |
| 442 | 630 static HBITMAP |
| 631 create_resized_bitmap (HBITMAP curbmp, struct frame *f, | |
| 632 int curx, int cury, | |
| 633 int newx, int newy) | |
| 428 | 634 { |
| 635 HBITMAP newbmp; | |
| 636 HGDIOBJ old1, old2; | |
| 442 | 637 |
| 638 HDC hcdc = get_device_compdc (XDEVICE (FRAME_DEVICE (f))); | |
| 434 | 639 HDC hdcDst = CreateCompatibleDC (hcdc); |
| 640 | |
| 442 | 641 old1 = SelectObject (hcdc, curbmp); |
| 434 | 642 |
| 428 | 643 newbmp = CreateCompatibleBitmap (hcdc, newx, newy); |
| 644 | |
| 645 old2 = SelectObject (hdcDst, newbmp); | |
| 434 | 646 |
| 428 | 647 if (!StretchBlt (hdcDst, 0, 0, newx, newy, |
| 434 | 648 hcdc, 0, 0, |
| 442 | 649 curx, |
| 650 cury, | |
| 428 | 651 SRCCOPY)) |
| 652 { | |
| 653 DeleteObject (newbmp); | |
| 654 DeleteDC (hdcDst); | |
| 655 return 0; | |
| 656 } | |
| 657 | |
| 658 SelectObject (hdcDst, old2); | |
| 659 SelectObject (hcdc, old1); | |
| 660 DeleteDC (hdcDst); | |
| 661 | |
| 662 return newbmp; | |
| 663 } | |
| 664 | |
| 665 HBITMAP | |
| 771 | 666 mswindows_create_resized_bitmap (Lisp_Image_Instance *ii, |
| 667 struct frame *f, | |
| 442 | 668 int newx, int newy) |
| 669 { | |
| 670 return create_resized_bitmap (IMAGE_INSTANCE_MSWINDOWS_BITMAP (ii), | |
| 671 f, | |
| 672 IMAGE_INSTANCE_MSWINDOWS_BITMAP_REAL_WIDTH (ii), | |
| 673 IMAGE_INSTANCE_MSWINDOWS_BITMAP_REAL_HEIGHT (ii), | |
| 674 newx, newy); | |
| 675 } | |
| 676 | |
| 677 HBITMAP | |
| 771 | 678 mswindows_create_resized_mask (Lisp_Image_Instance *ii, |
| 679 struct frame *f, | |
| 428 | 680 int newx, int newy) |
| 681 { | |
| 442 | 682 if (IMAGE_INSTANCE_MSWINDOWS_MASK (ii) == NULL) |
| 683 return NULL; | |
| 684 | |
| 685 return create_resized_bitmap (IMAGE_INSTANCE_MSWINDOWS_MASK (ii), | |
| 686 f, | |
| 687 IMAGE_INSTANCE_MSWINDOWS_BITMAP_REAL_WIDTH (ii), | |
| 688 IMAGE_INSTANCE_MSWINDOWS_BITMAP_REAL_HEIGHT (ii), | |
| 689 newx, newy); | |
| 428 | 690 } |
| 691 | |
| 442 | 692 #if 0 /* Currently unused */ |
| 693 /* #### Warning: This function is not correct anymore with | |
| 694 resizable printer bitmaps. If you uncomment it, clean it. --kkm */ | |
| 428 | 695 int |
| 771 | 696 mswindows_resize_dibitmap_instance (Lisp_Image_Instance *ii, |
| 697 struct frame *f, | |
| 428 | 698 int newx, int newy) |
| 699 { | |
| 700 HBITMAP newbmp = mswindows_create_resized_bitmap (ii, f, newx, newy); | |
| 701 HBITMAP newmask = mswindows_create_resized_mask (ii, f, newx, newy); | |
| 702 | |
| 703 if (!newbmp) | |
| 704 return FALSE; | |
| 434 | 705 |
| 428 | 706 if (IMAGE_INSTANCE_MSWINDOWS_BITMAP (ii)) |
| 707 DeleteObject (IMAGE_INSTANCE_MSWINDOWS_BITMAP (ii)); | |
| 708 if (IMAGE_INSTANCE_MSWINDOWS_MASK (ii)) | |
| 709 DeleteObject (IMAGE_INSTANCE_MSWINDOWS_MASK (ii)); | |
| 710 | |
| 711 IMAGE_INSTANCE_MSWINDOWS_BITMAP (ii) = newbmp; | |
| 712 IMAGE_INSTANCE_MSWINDOWS_MASK (ii) = newmask; | |
| 713 IMAGE_INSTANCE_PIXMAP_WIDTH (ii) = newx; | |
| 714 IMAGE_INSTANCE_PIXMAP_HEIGHT (ii) = newy; | |
| 715 | |
| 716 return TRUE; | |
| 717 } | |
| 442 | 718 #endif |
| 428 | 719 |
| 720 /********************************************************************** | |
| 721 * XPM * | |
| 722 **********************************************************************/ | |
| 723 | |
| 724 #ifdef HAVE_XPM | |
| 725 | |
| 726 struct color_symbol | |
| 727 { | |
| 867 | 728 Ibyte * name; |
| 428 | 729 COLORREF color; |
| 730 }; | |
| 731 | |
| 771 | 732 static struct color_symbol * |
| 428 | 733 extract_xpm_color_names (Lisp_Object device, |
| 734 Lisp_Object domain, | |
| 735 Lisp_Object color_symbol_alist, | |
| 771 | 736 int *nsymbols) |
| 428 | 737 { |
| 738 /* This function can GC */ | |
| 739 Lisp_Object rest; | |
| 740 Lisp_Object results = Qnil; | |
| 741 int i, j; | |
| 742 struct color_symbol *colortbl; | |
| 743 struct gcpro gcpro1, gcpro2; | |
| 744 | |
| 745 GCPRO2 (results, device); | |
| 746 | |
| 747 /* We built up results to be (("name" . #<color>) ...) so that if an | |
| 748 error happens we don't lose any malloc()ed data, or more importantly, | |
| 749 leave any pixels allocated in the server. */ | |
| 750 i = 0; | |
| 751 LIST_LOOP (rest, color_symbol_alist) | |
| 752 { | |
| 753 Lisp_Object cons = XCAR (rest); | |
| 754 Lisp_Object name = XCAR (cons); | |
| 755 Lisp_Object value = XCDR (cons); | |
| 756 if (NILP (value)) | |
| 757 continue; | |
| 758 if (STRINGP (value)) | |
| 759 value = | |
| 760 Fmake_color_instance | |
| 793 | 761 (value, device, encode_error_behavior_flag (ERROR_ME_DEBUG_WARN)); |
| 428 | 762 else |
| 763 { | |
| 764 assert (COLOR_SPECIFIERP (value)); | |
| 765 value = Fspecifier_instance (value, domain, Qnil, Qnil); | |
| 766 } | |
| 767 if (NILP (value)) | |
| 768 continue; | |
| 769 results = noseeum_cons (noseeum_cons (name, value), results); | |
| 770 i++; | |
| 771 } | |
| 772 UNGCPRO; /* no more evaluation */ | |
| 773 | |
| 771 | 774 *nsymbols = i; |
| 428 | 775 if (i == 0) return 0; |
| 776 | |
| 777 colortbl = xnew_array_and_zero (struct color_symbol, i); | |
| 778 | |
| 771 | 779 for (j = 0; j < i; j++) |
| 428 | 780 { |
| 781 Lisp_Object cons = XCAR (results); | |
| 434 | 782 colortbl[j].color = |
| 428 | 783 COLOR_INSTANCE_MSWINDOWS_COLOR (XCOLOR_INSTANCE (XCDR (cons))); |
| 784 | |
| 771 | 785 /* mustn't lose this when we return */ |
| 786 colortbl[j].name = qxestrdup (XSTRING_DATA (XCAR (cons))); | |
| 853 | 787 free_cons (cons); |
| 428 | 788 cons = results; |
| 789 results = XCDR (results); | |
| 853 | 790 free_cons (cons); |
| 428 | 791 } |
| 792 return colortbl; | |
| 793 } | |
| 794 | |
| 442 | 795 static int xpm_to_eimage (Lisp_Object image, const Extbyte *buffer, |
| 2367 | 796 Binbyte **data, |
| 771 | 797 int *width, int *height, |
| 798 int *x_hot, int *y_hot, | |
| 799 int *transp, | |
| 800 struct color_symbol *color_symbols, | |
| 428 | 801 int nsymbols) |
| 802 { | |
| 803 XpmImage xpmimage; | |
| 804 XpmInfo xpminfo; | |
| 805 int result, i, j, transp_idx, maskbpline; | |
| 2367 | 806 Binbyte *dptr; |
| 771 | 807 unsigned int *sptr; |
| 428 | 808 COLORREF color; /* the american spelling virus hits again .. */ |
| 771 | 809 COLORREF *colortbl; |
| 428 | 810 |
| 811 xzero (xpmimage); | |
| 812 xzero (xpminfo); | |
| 771 | 813 xpminfo.valuemask = XpmHotspot; |
| 814 *transp = FALSE; | |
| 815 | |
| 816 result = XpmCreateXpmImageFromBuffer ((char *)buffer, | |
| 428 | 817 &xpmimage, |
| 818 &xpminfo); | |
| 819 switch (result) | |
| 820 { | |
| 821 case XpmSuccess: | |
| 822 break; | |
| 823 case XpmFileInvalid: | |
| 824 { | |
| 563 | 825 signal_image_error ("Invalid XPM data", image); |
| 428 | 826 } |
| 827 case XpmNoMemory: | |
| 828 { | |
| 563 | 829 signal_double_image_error ("Parsing pixmap data", |
| 830 "out of memory", image); | |
| 428 | 831 } |
| 832 default: | |
| 833 { | |
| 563 | 834 signal_double_image_error_2 ("Parsing pixmap data", |
| 835 "unknown error", | |
| 836 make_int (result), image); | |
| 428 | 837 } |
| 838 } | |
| 434 | 839 |
| 428 | 840 *width = xpmimage.width; |
| 841 *height = xpmimage.height; | |
| 434 | 842 maskbpline = BPLINE ((~7UL & (unsigned long)(*width + 7)) / 8); |
| 843 | |
| 2367 | 844 *data = xnew_array_and_zero (Binbyte, *width * *height * 3); |
| 428 | 845 |
| 846 if (!*data) | |
| 847 { | |
| 848 XpmFreeXpmImage (&xpmimage); | |
| 849 XpmFreeXpmInfo (&xpminfo); | |
| 850 return 0; | |
| 851 } | |
| 852 | |
| 853 /* build a color table to speed things up */ | |
| 854 colortbl = xnew_array_and_zero (COLORREF, xpmimage.ncolors); | |
| 855 if (!colortbl) | |
| 856 { | |
|
4976
16112448d484
Rename xfree(FOO, TYPE) -> xfree(FOO)
Ben Wing <ben@xemacs.org>
parents:
4952
diff
changeset
|
857 xfree (*data); |
| 428 | 858 XpmFreeXpmImage (&xpmimage); |
| 859 XpmFreeXpmInfo (&xpminfo); | |
| 860 return 0; | |
| 861 } | |
| 862 | |
| 771 | 863 for (i = 0; i < (int) xpmimage.ncolors; i++) |
| 428 | 864 { |
| 865 /* goto alert!!!! */ | |
| 866 /* pick up symbolic colors in preference */ | |
| 867 if (xpmimage.colorTable[i].symbolic) | |
| 868 { | |
| 771 | 869 if (!strcasecmp (xpmimage.colorTable[i].symbolic, "BgColor") |
| 428 | 870 || |
| 771 | 871 !strcasecmp (xpmimage.colorTable[i].symbolic, "None")) |
| 428 | 872 { |
| 771 | 873 *transp = TRUE; |
| 874 colortbl[i] = transparent_color; | |
| 875 transp_idx = i; | |
| 428 | 876 goto label_found_color; |
| 877 } | |
| 878 else if (color_symbols) | |
| 879 { | |
| 771 | 880 for (j = 0; j < nsymbols; j++) |
| 428 | 881 { |
| 2367 | 882 if (!qxestrcmp_ascii (color_symbols[j].name, |
| 771 | 883 xpmimage.colorTable[i].symbolic)) |
| 428 | 884 { |
| 771 | 885 colortbl[i] = color_symbols[j].color; |
| 428 | 886 goto label_found_color; |
| 887 } | |
| 888 } | |
| 889 } | |
| 890 else if (xpmimage.colorTable[i].c_color == 0) | |
| 891 { | |
| 892 goto label_no_color; | |
| 893 } | |
| 894 } | |
| 895 /* pick up transparencies */ | |
| 771 | 896 if (!strcasecmp (xpmimage.colorTable[i].c_color, "None")) |
| 428 | 897 { |
| 771 | 898 *transp = TRUE; |
| 899 colortbl[i] = transparent_color; | |
| 900 transp_idx = i; | |
| 428 | 901 goto label_found_color; |
| 902 } | |
| 903 /* finally pick up a normal color spec */ | |
| 904 if (xpmimage.colorTable[i].c_color) | |
| 905 { | |
| 906 colortbl[i]= | |
| 867 | 907 mswindows_string_to_color ((Ibyte *) |
| 771 | 908 xpmimage.colorTable[i].c_color); |
| 428 | 909 goto label_found_color; |
| 910 } | |
| 434 | 911 |
| 428 | 912 label_no_color: |
|
4976
16112448d484
Rename xfree(FOO, TYPE) -> xfree(FOO)
Ben Wing <ben@xemacs.org>
parents:
4952
diff
changeset
|
913 xfree (*data); |
|
16112448d484
Rename xfree(FOO, TYPE) -> xfree(FOO)
Ben Wing <ben@xemacs.org>
parents:
4952
diff
changeset
|
914 xfree (colortbl); |
| 428 | 915 XpmFreeXpmImage (&xpmimage); |
| 916 XpmFreeXpmInfo (&xpminfo); | |
| 917 return 0; | |
| 434 | 918 |
| 428 | 919 label_found_color:; |
| 920 } | |
| 921 | |
| 922 /* convert the image */ | |
| 771 | 923 sptr = xpmimage.data; |
| 924 dptr= *data; | |
| 428 | 925 for (i = 0; i< *width * *height; i++) |
| 926 { | |
| 927 color = colortbl[*sptr++]; | |
| 928 | |
| 929 /* split out the 0x02bbggrr colorref into an rgb triple */ | |
| 930 *dptr++=GetRValue (color); /* red */ | |
| 931 *dptr++=GetGValue (color); /* green */ | |
| 932 *dptr++=GetBValue (color); /* blue */ | |
| 933 } | |
| 934 | |
| 771 | 935 *x_hot = xpminfo.x_hotspot; |
| 936 *y_hot = xpminfo.y_hotspot; | |
| 428 | 937 |
| 938 XpmFreeXpmImage (&xpmimage); | |
| 939 XpmFreeXpmInfo (&xpminfo); | |
|
4976
16112448d484
Rename xfree(FOO, TYPE) -> xfree(FOO)
Ben Wing <ben@xemacs.org>
parents:
4952
diff
changeset
|
940 xfree (colortbl); |
| 428 | 941 return TRUE; |
| 942 } | |
| 943 | |
| 944 static void | |
| 945 mswindows_xpm_instantiate (Lisp_Object image_instance, | |
| 946 Lisp_Object instantiator, | |
| 2286 | 947 Lisp_Object UNUSED (pointer_fg), |
| 948 Lisp_Object UNUSED (pointer_bg), | |
| 428 | 949 int dest_mask, Lisp_Object domain) |
| 950 { | |
| 440 | 951 Lisp_Image_Instance *ii = XIMAGE_INSTANCE (image_instance); |
| 428 | 952 Lisp_Object device = IMAGE_INSTANCE_DEVICE (ii); |
| 442 | 953 const Extbyte *bytes; |
| 665 | 954 Bytecount len; |
| 2367 | 955 Binbyte *eimage; |
| 428 | 956 int width, height, x_hot, y_hot; |
| 957 BITMAPINFO* bmp_info; | |
| 2367 | 958 Binbyte* bmp_data; |
| 428 | 959 int bmp_bits; |
| 771 | 960 int nsymbols = 0, transp; |
| 961 struct color_symbol* color_symbols = NULL; | |
| 434 | 962 |
| 428 | 963 Lisp_Object data = find_keyword_in_vector (instantiator, Q_data); |
| 964 Lisp_Object color_symbol_alist = find_keyword_in_vector (instantiator, | |
| 965 Q_color_symbols); | |
| 966 | |
| 442 | 967 CHECK_MSGDI_DEVICE (device); |
| 428 | 968 |
| 969 assert (!NILP (data)); | |
| 970 | |
|
4981
4aebb0131297
Cleanups/renaming of EXTERNAL_TO_C_STRING and friends
Ben Wing <ben@xemacs.org>
parents:
4952
diff
changeset
|
971 LISP_STRING_TO_SIZED_EXTERNAL (data, bytes, len, Qbinary); |
| 428 | 972 |
| 973 /* in case we have color symbols */ | |
| 974 color_symbols = extract_xpm_color_names (device, domain, | |
| 975 color_symbol_alist, &nsymbols); | |
| 976 | |
| 977 /* convert to an eimage to make processing easier */ | |
| 978 if (!xpm_to_eimage (image_instance, bytes, &eimage, &width, &height, | |
| 979 &x_hot, &y_hot, &transp, color_symbols, nsymbols)) | |
| 980 { | |
| 563 | 981 signal_image_error ("XPM to EImage conversion failed", |
| 982 image_instance); | |
| 428 | 983 } |
| 434 | 984 |
| 428 | 985 if (color_symbols) |
| 986 { | |
| 987 while (nsymbols--) | |
| 988 { | |
|
4976
16112448d484
Rename xfree(FOO, TYPE) -> xfree(FOO)
Ben Wing <ben@xemacs.org>
parents:
4952
diff
changeset
|
989 xfree (color_symbols[nsymbols].name); |
| 428 | 990 } |
|
4976
16112448d484
Rename xfree(FOO, TYPE) -> xfree(FOO)
Ben Wing <ben@xemacs.org>
parents:
4952
diff
changeset
|
991 xfree (color_symbols); |
| 428 | 992 } |
| 434 | 993 |
| 428 | 994 /* build a bitmap from the eimage */ |
| 771 | 995 if (!(bmp_info = convert_EImage_to_DIBitmap (device, width, height, eimage, |
| 428 | 996 &bmp_bits, &bmp_data))) |
| 997 { | |
| 563 | 998 signal_image_error ("XPM to EImage conversion failed", |
| 999 image_instance); | |
| 428 | 1000 } |
|
4976
16112448d484
Rename xfree(FOO, TYPE) -> xfree(FOO)
Ben Wing <ben@xemacs.org>
parents:
4952
diff
changeset
|
1001 xfree (eimage); |
| 428 | 1002 |
| 1003 /* Now create the pixmap and set up the image instance */ | |
| 1004 init_image_instance_from_dibitmap (ii, bmp_info, dest_mask, | |
| 1005 bmp_data, bmp_bits, 1, instantiator, | |
| 1006 x_hot, y_hot, transp); | |
| 1007 | |
|
4976
16112448d484
Rename xfree(FOO, TYPE) -> xfree(FOO)
Ben Wing <ben@xemacs.org>
parents:
4952
diff
changeset
|
1008 xfree (bmp_info); |
|
16112448d484
Rename xfree(FOO, TYPE) -> xfree(FOO)
Ben Wing <ben@xemacs.org>
parents:
4952
diff
changeset
|
1009 xfree (bmp_data); |
| 428 | 1010 } |
| 1011 #endif /* HAVE_XPM */ | |
| 1012 | |
| 1013 /********************************************************************** | |
| 1014 * BMP * | |
| 1015 **********************************************************************/ | |
| 1016 | |
| 1017 static void | |
| 1018 bmp_validate (Lisp_Object instantiator) | |
| 1019 { | |
| 1020 file_or_data_must_be_present (instantiator); | |
| 1021 } | |
| 1022 | |
| 1023 static Lisp_Object | |
| 442 | 1024 bmp_normalize (Lisp_Object inst, Lisp_Object console_type, |
| 2286 | 1025 Lisp_Object UNUSED (dest_mask)) |
| 428 | 1026 { |
| 1027 return simple_image_type_normalize (inst, console_type, Qbmp); | |
| 1028 } | |
| 1029 | |
| 1030 static int | |
| 1031 bmp_possible_dest_types (void) | |
| 1032 { | |
| 1033 return IMAGE_COLOR_PIXMAP_MASK; | |
| 1034 } | |
| 1035 | |
| 1036 static void | |
| 1037 bmp_instantiate (Lisp_Object image_instance, Lisp_Object instantiator, | |
| 2286 | 1038 Lisp_Object UNUSED (pointer_fg), |
| 1039 Lisp_Object UNUSED (pointer_bg), | |
| 1040 int dest_mask, Lisp_Object UNUSED (domain)) | |
| 428 | 1041 { |
| 440 | 1042 Lisp_Image_Instance *ii = XIMAGE_INSTANCE (image_instance); |
| 428 | 1043 Lisp_Object device = IMAGE_INSTANCE_DEVICE (ii); |
| 442 | 1044 const Extbyte *bytes; |
| 665 | 1045 Bytecount len; |
| 771 | 1046 BITMAPFILEHEADER * bmp_file_header; |
| 1047 BITMAPINFO * bmp_info; | |
| 1048 void * bmp_data; | |
| 428 | 1049 int bmp_bits; |
| 1050 Lisp_Object data = find_keyword_in_vector (instantiator, Q_data); | |
| 1051 | |
| 442 | 1052 CHECK_MSGDI_DEVICE (device); |
| 428 | 1053 |
| 1054 assert (!NILP (data)); | |
| 1055 | |
|
4981
4aebb0131297
Cleanups/renaming of EXTERNAL_TO_C_STRING and friends
Ben Wing <ben@xemacs.org>
parents:
4952
diff
changeset
|
1056 LISP_STRING_TO_SIZED_EXTERNAL (data, bytes, len, Qbinary); |
| 434 | 1057 |
| 428 | 1058 /* Then slurp the image into memory, decoding along the way. |
| 1059 The result is the image in a simple one-byte-per-pixel | |
| 1060 format. */ | |
| 434 | 1061 |
| 771 | 1062 bmp_file_header = (BITMAPFILEHEADER *)bytes; |
| 1063 bmp_info = (BITMAPINFO *)(bytes + sizeof(BITMAPFILEHEADER)); | |
| 1064 bmp_data = (Extbyte *)bytes + bmp_file_header->bfOffBits; | |
| 428 | 1065 bmp_bits = bmp_file_header->bfSize - bmp_file_header->bfOffBits; |
| 1066 | |
| 1067 /* Now create the pixmap and set up the image instance */ | |
| 1068 init_image_instance_from_dibitmap (ii, bmp_info, dest_mask, | |
| 1069 bmp_data, bmp_bits, 1, instantiator, | |
| 1070 0, 0, 0); | |
| 1071 } | |
| 1072 | |
| 1073 | |
| 1074 /********************************************************************** | |
| 1075 * RESOURCES * | |
| 1076 **********************************************************************/ | |
| 1077 | |
| 1078 static void | |
| 1079 mswindows_resource_validate (Lisp_Object instantiator) | |
| 1080 { | |
| 563 | 1081 shared_resource_validate (instantiator); |
| 428 | 1082 } |
| 1083 | |
| 1084 static Lisp_Object | |
| 442 | 1085 mswindows_resource_normalize (Lisp_Object inst, Lisp_Object console_type, |
| 1086 Lisp_Object dest_mask) | |
| 428 | 1087 { |
| 563 | 1088 return shared_resource_normalize (inst, console_type, dest_mask, |
| 1089 Qmswindows_resource); | |
| 428 | 1090 } |
| 1091 | |
| 1092 static int | |
| 1093 mswindows_resource_possible_dest_types (void) | |
| 1094 { | |
| 1095 return IMAGE_POINTER_MASK | IMAGE_COLOR_PIXMAP_MASK; | |
| 1096 } | |
| 1097 | |
| 434 | 1098 typedef struct |
| 428 | 1099 { |
| 4932 | 1100 const Ascbyte *name; |
| 428 | 1101 int resource_id; |
| 1102 } resource_t; | |
| 1103 | |
| 442 | 1104 static const resource_t bitmap_table[] = |
| 428 | 1105 { |
| 1106 /* bitmaps */ | |
| 1107 { "close", OBM_CLOSE }, | |
| 1108 { "uparrow", OBM_UPARROW }, | |
| 1109 { "dnarrow", OBM_DNARROW }, | |
| 1110 { "rgarrow", OBM_RGARROW }, | |
| 1111 { "lfarrow", OBM_LFARROW }, | |
| 1112 { "reduce", OBM_REDUCE }, | |
| 1113 { "zoom", OBM_ZOOM }, | |
| 1114 { "restore", OBM_RESTORE }, | |
| 1115 { "reduced", OBM_REDUCED }, | |
| 1116 { "zoomd", OBM_ZOOMD }, | |
| 1117 { "restored", OBM_RESTORED }, | |
| 1118 { "uparrowd", OBM_UPARROWD }, | |
| 1119 { "dnarrowd", OBM_DNARROWD }, | |
| 1120 { "rgarrowd", OBM_RGARROWD }, | |
| 1121 { "lfarrowd", OBM_LFARROWD }, | |
| 1122 { "mnarrow", OBM_MNARROW }, | |
| 1123 { "combo", OBM_COMBO }, | |
| 1124 { "uparrowi", OBM_UPARROWI }, | |
| 1125 { "dnarrowi", OBM_DNARROWI }, | |
| 1126 { "rgarrowi", OBM_RGARROWI }, | |
| 1127 { "lfarrowi", OBM_LFARROWI }, | |
| 1128 { "size", OBM_SIZE }, | |
| 1129 { "btsize", OBM_BTSIZE }, | |
| 1130 { "check", OBM_CHECK }, | |
| 1131 { "checkboxes", OBM_CHECKBOXES }, | |
| 1132 { "btncorners" , OBM_BTNCORNERS }, | |
| 1133 {0} | |
| 1134 }; | |
| 1135 | |
| 442 | 1136 static const resource_t cursor_table[] = |
| 428 | 1137 { |
| 1138 /* cursors */ | |
| 1139 { "normal", OCR_NORMAL }, | |
| 1140 { "ibeam", OCR_IBEAM }, | |
| 1141 { "wait", OCR_WAIT }, | |
| 1142 { "cross", OCR_CROSS }, | |
| 1143 { "up", OCR_UP }, | |
| 1144 /* { "icon", OCR_ICON }, */ | |
| 1145 { "sizenwse", OCR_SIZENWSE }, | |
| 1146 { "sizenesw", OCR_SIZENESW }, | |
| 1147 { "sizewe", OCR_SIZEWE }, | |
| 1148 { "sizens", OCR_SIZENS }, | |
| 1149 { "sizeall", OCR_SIZEALL }, | |
| 1150 /* { "icour", OCR_ICOCUR }, */ | |
| 1151 { "no", OCR_NO }, | |
| 1152 { 0 } | |
| 1153 }; | |
| 1154 | |
| 442 | 1155 static const resource_t icon_table[] = |
| 428 | 1156 { |
| 1157 /* icons */ | |
| 1158 { "sample", OIC_SAMPLE }, | |
| 1159 { "hand", OIC_HAND }, | |
| 1160 { "ques", OIC_QUES }, | |
| 1161 { "bang", OIC_BANG }, | |
| 1162 { "note", OIC_NOTE }, | |
| 1163 { "winlogo", OIC_WINLOGO }, | |
| 1164 {0} | |
| 1165 }; | |
| 1166 | |
| 771 | 1167 static int |
| 1168 resource_name_to_resource (Lisp_Object name, int type) | |
| 428 | 1169 { |
| 771 | 1170 const resource_t *res = (type == IMAGE_CURSOR ? cursor_table |
| 434 | 1171 : type == IMAGE_ICON ? icon_table |
| 428 | 1172 : bitmap_table); |
| 1173 | |
| 1174 if (INTP (name)) | |
| 771 | 1175 return XINT (name); |
| 1176 else if (!STRINGP (name)) | |
| 1177 invalid_argument ("invalid resource identifier", name); | |
| 1178 | |
| 1179 do | |
| 428 | 1180 { |
| 867 | 1181 if (!qxestrcasecmp_i18n ((Ibyte *) res->name, XSTRING_DATA (name))) |
| 771 | 1182 return res->resource_id; |
| 428 | 1183 } |
| 771 | 1184 while ((++res)->name); |
| 428 | 1185 return 0; |
| 1186 } | |
| 1187 | |
| 1188 static int | |
| 1189 resource_symbol_to_type (Lisp_Object data) | |
| 1190 { | |
| 1191 if (EQ (data, Qcursor)) | |
| 1192 return IMAGE_CURSOR; | |
| 1193 else if (EQ (data, Qicon)) | |
| 1194 return IMAGE_ICON; | |
| 1195 else if (EQ (data, Qbitmap)) | |
| 1196 return IMAGE_BITMAP; | |
| 1197 else | |
| 1198 return 0; | |
| 1199 } | |
| 1200 | |
| 1201 static void | |
| 502 | 1202 mswindows_resource_instantiate (Lisp_Object image_instance, |
| 1203 Lisp_Object instantiator, | |
| 2286 | 1204 Lisp_Object UNUSED (pointer_fg), |
| 1205 Lisp_Object UNUSED (pointer_bg), | |
| 1206 int dest_mask, Lisp_Object UNUSED (domain)) | |
| 428 | 1207 { |
| 440 | 1208 Lisp_Image_Instance *ii = XIMAGE_INSTANCE (image_instance); |
| 647 | 1209 int type = 0; |
| 428 | 1210 HANDLE himage = NULL; |
| 771 | 1211 Extbyte *resid = 0; |
| 428 | 1212 HINSTANCE hinst = NULL; |
| 1213 ICONINFO iconinfo; | |
| 442 | 1214 enum image_instance_type iitype; |
| 428 | 1215 Lisp_Object device = IMAGE_INSTANCE_DEVICE (ii); |
| 1216 | |
| 1217 Lisp_Object file = find_keyword_in_vector (instantiator, Q_file); | |
| 434 | 1218 Lisp_Object resource_type = find_keyword_in_vector (instantiator, |
| 428 | 1219 Q_resource_type); |
| 434 | 1220 Lisp_Object resource_id = find_keyword_in_vector (instantiator, |
| 428 | 1221 Q_resource_id); |
| 1222 | |
| 1223 xzero (iconinfo); | |
| 1224 | |
| 442 | 1225 CHECK_MSGDI_DEVICE (device); |
| 428 | 1226 |
| 1227 type = resource_symbol_to_type (resource_type); | |
| 1228 | |
| 1229 if (dest_mask & IMAGE_POINTER_MASK && type == IMAGE_CURSOR) | |
| 1230 iitype = IMAGE_POINTER; | |
| 1231 else if (dest_mask & IMAGE_COLOR_PIXMAP_MASK) | |
| 1232 iitype = IMAGE_COLOR_PIXMAP; | |
| 434 | 1233 else |
| 428 | 1234 incompatible_image_types (instantiator, dest_mask, |
| 1235 IMAGE_COLOR_PIXMAP_MASK | IMAGE_POINTER_MASK); | |
| 1236 | |
| 1237 /* mess with the keyword info we were provided with */ | |
| 1238 if (!NILP (file)) | |
| 1239 { | |
| 771 | 1240 Extbyte *fname; |
| 1241 | |
|
4834
b3ea9c582280
Use new cygwin_conv_path API with Cygwin 1.7 for converting names between Win32 and POSIX, UTF-8-aware, with attendant changes elsewhere
Ben Wing <ben@xemacs.org>
parents:
2959
diff
changeset
|
1242 LISP_LOCAL_FILE_FORMAT_TO_TSTR (file, fname); |
| 434 | 1243 |
| 428 | 1244 if (NILP (resource_id)) |
| 771 | 1245 resid = fname; |
| 428 | 1246 else |
| 1247 { | |
| 771 | 1248 hinst = qxeLoadLibraryEx (fname, NULL, LOAD_LIBRARY_AS_DATAFILE); |
| 428 | 1249 resid = MAKEINTRESOURCE (resource_name_to_resource (resource_id, |
| 771 | 1250 type)); |
| 434 | 1251 |
| 428 | 1252 if (!resid) |
|
4981
4aebb0131297
Cleanups/renaming of EXTERNAL_TO_C_STRING and friends
Ben Wing <ben@xemacs.org>
parents:
4952
diff
changeset
|
1253 resid = LISP_STRING_TO_TSTR (resource_id); |
| 428 | 1254 } |
| 1255 } | |
| 1256 else if (!(resid = MAKEINTRESOURCE (resource_name_to_resource (resource_id, | |
| 771 | 1257 type)))) |
| 563 | 1258 invalid_argument ("Invalid resource identifier", resource_id); |
| 434 | 1259 |
| 428 | 1260 /* load the image */ |
| 771 | 1261 if (!(himage = qxeLoadImage (hinst, resid, type, 0, 0, |
| 1262 LR_CREATEDIBSECTION | LR_DEFAULTSIZE | | |
| 1263 LR_SHARED | | |
| 1264 (!NILP (file) ? LR_LOADFROMFILE : 0)))) | |
| 1265 signal_image_error ("Cannot load image", instantiator); | |
| 428 | 1266 |
| 1267 if (hinst) | |
| 1268 FreeLibrary (hinst); | |
| 1269 | |
| 1270 mswindows_initialize_dibitmap_image_instance (ii, 1, iitype); | |
| 1271 | |
| 1272 IMAGE_INSTANCE_PIXMAP_FILENAME (ii) = file; | |
| 442 | 1273 IMAGE_INSTANCE_MSWINDOWS_BITMAP_REAL_WIDTH (ii) = |
| 428 | 1274 GetSystemMetrics (type == IMAGE_CURSOR ? SM_CXCURSOR : SM_CXICON); |
| 442 | 1275 IMAGE_INSTANCE_MSWINDOWS_BITMAP_REAL_HEIGHT (ii) = |
| 428 | 1276 GetSystemMetrics (type == IMAGE_CURSOR ? SM_CYCURSOR : SM_CYICON); |
| 1277 IMAGE_INSTANCE_PIXMAP_DEPTH (ii) = 1; | |
| 442 | 1278 init_image_instance_geometry (ii); |
| 428 | 1279 |
| 1280 /* hey, we've got an icon type thing so we can reverse engineer the | |
| 1281 bitmap and mask */ | |
| 1282 if (type != IMAGE_BITMAP) | |
| 1283 { | |
| 442 | 1284 GetIconInfo ((HICON)himage, &iconinfo); |
| 428 | 1285 IMAGE_INSTANCE_MSWINDOWS_BITMAP (ii) = iconinfo.hbmColor; |
| 1286 IMAGE_INSTANCE_MSWINDOWS_MASK (ii) = iconinfo.hbmMask; | |
| 793 | 1287 IMAGE_INSTANCE_PIXMAP_HOTSPOT_X (ii) = make_int (iconinfo.xHotspot); |
| 1288 IMAGE_INSTANCE_PIXMAP_HOTSPOT_Y (ii) = make_int (iconinfo.yHotspot); | |
| 442 | 1289 IMAGE_INSTANCE_MSWINDOWS_ICON (ii) = (HICON) himage; |
| 428 | 1290 } |
| 1291 else | |
| 1292 { | |
| 1293 IMAGE_INSTANCE_MSWINDOWS_ICON (ii) = NULL; | |
| 442 | 1294 IMAGE_INSTANCE_MSWINDOWS_BITMAP (ii) = (HBITMAP) himage; |
| 428 | 1295 IMAGE_INSTANCE_MSWINDOWS_MASK (ii) = NULL; |
| 793 | 1296 IMAGE_INSTANCE_PIXMAP_HOTSPOT_X (ii) = make_int (0); |
| 1297 IMAGE_INSTANCE_PIXMAP_HOTSPOT_Y (ii) = make_int (0); | |
| 428 | 1298 } |
| 1299 } | |
| 1300 | |
| 1301 static void | |
| 1302 check_valid_resource_symbol (Lisp_Object data) | |
| 1303 { | |
| 1304 CHECK_SYMBOL (data); | |
| 1305 if (!resource_symbol_to_type (data)) | |
| 563 | 1306 invalid_constant ("invalid resource type", data); |
| 428 | 1307 } |
| 1308 | |
| 1309 static void | |
| 1310 check_valid_resource_id (Lisp_Object data) | |
| 1311 { | |
| 1312 if (!resource_name_to_resource (data, IMAGE_CURSOR) | |
| 1313 && | |
| 1314 !resource_name_to_resource (data, IMAGE_ICON) | |
| 1315 && | |
| 1316 !resource_name_to_resource (data, IMAGE_BITMAP)) | |
| 563 | 1317 invalid_constant ("invalid resource identifier", data); |
| 428 | 1318 } |
| 1319 | |
| 771 | 1320 |
| 428 | 1321 /********************************************************************** |
| 1322 * XBM * | |
| 1323 **********************************************************************/ | |
| 771 | 1324 |
| 428 | 1325 /* this table flips four bits around. */ |
| 1326 static int flip_table[] = | |
| 1327 { | |
| 1328 0, 8, 4, 12, 2, 10, 6, 14, 1, 9, 5, 13, 3, 11, 7, 15 | |
| 1329 }; | |
| 1330 | |
| 1331 /* the bitmap data comes in the following format: Widths are padded to | |
| 1332 a multiple of 8. Scan lines are stored in increasing byte order | |
| 1333 from left to right, little-endian within a byte. 0 = white, 1 = | |
| 1334 black. It must be converted to the following format: Widths are | |
| 1335 padded to a multiple of 16. Scan lines are stored in increasing | |
| 1336 byte order from left to right, big-endian within a byte. 0 = | |
| 1337 black, 1 = white. */ | |
| 438 | 1338 static HBITMAP |
| 2367 | 1339 xbm_create_bitmap_from_data (HDC hdc, const Binbyte *data, |
| 647 | 1340 int width, int height, |
| 428 | 1341 int mask, COLORREF fg, COLORREF bg) |
| 1342 { | |
| 1343 int old_width = (width + 7)/8; | |
| 771 | 1344 int new_width = BPLINE (2 * ((width + 15)/16)); |
| 2367 | 1345 const Binbyte *offset; |
| 428 | 1346 void *bmp_buf = 0; |
| 2367 | 1347 Binbyte *new_data, *new_offset; |
| 428 | 1348 int i, j; |
| 442 | 1349 BITMAPINFO *bmp_info = |
| 771 | 1350 (BITMAPINFO *) xmalloc_and_zero (sizeof(BITMAPINFO) + sizeof(RGBQUAD)); |
| 428 | 1351 HBITMAP bitmap; |
| 1352 | |
| 1353 if (!bmp_info) | |
| 1354 return NULL; | |
| 434 | 1355 |
| 2367 | 1356 new_data = xnew_array_and_zero (Binbyte, height * new_width); |
| 434 | 1357 |
| 428 | 1358 if (!new_data) |
| 1359 { | |
|
4976
16112448d484
Rename xfree(FOO, TYPE) -> xfree(FOO)
Ben Wing <ben@xemacs.org>
parents:
4952
diff
changeset
|
1360 xfree (bmp_info); |
| 428 | 1361 return NULL; |
| 1362 } | |
| 434 | 1363 |
| 771 | 1364 for (i = 0; i < height; i++) |
| 428 | 1365 { |
| 771 | 1366 offset = data + i * old_width; |
| 1367 new_offset = new_data + i * new_width; | |
| 1368 | |
| 1369 for (j = 0; j < old_width; j++) | |
| 428 | 1370 { |
| 771 | 1371 int bite = offset[j]; |
| 2367 | 1372 new_offset[j] = ~ (Binbyte) |
| 771 | 1373 ((flip_table[bite & 0xf] << 4) + flip_table[bite >> 4]); |
| 428 | 1374 } |
| 1375 } | |
| 1376 | |
| 1377 /* if we want a mask invert the bits */ | |
| 1378 if (!mask) | |
| 1379 { | |
| 1380 new_offset = &new_data[height * new_width]; | |
| 1381 while (new_offset-- != new_data) | |
| 1382 { | |
| 1383 *new_offset ^= 0xff; | |
| 1384 } | |
| 1385 } | |
| 1386 | |
| 771 | 1387 bmp_info->bmiHeader.biWidth = width; |
| 428 | 1388 bmp_info->bmiHeader.biHeight=-(LONG)height; |
| 771 | 1389 bmp_info->bmiHeader.biPlanes = 1; |
| 1390 bmp_info->bmiHeader.biSize = sizeof(BITMAPINFOHEADER); | |
| 1391 bmp_info->bmiHeader.biBitCount = 1; | |
| 1392 bmp_info->bmiHeader.biCompression = BI_RGB; | |
| 434 | 1393 bmp_info->bmiHeader.biClrUsed = 2; |
| 1394 bmp_info->bmiHeader.biClrImportant = 2; | |
| 1395 bmp_info->bmiHeader.biSizeImage = height * new_width; | |
| 428 | 1396 bmp_info->bmiColors[0].rgbRed = GetRValue (fg); |
| 1397 bmp_info->bmiColors[0].rgbGreen = GetGValue (fg); | |
| 1398 bmp_info->bmiColors[0].rgbBlue = GetBValue (fg); | |
| 1399 bmp_info->bmiColors[0].rgbReserved = 0; | |
| 1400 bmp_info->bmiColors[1].rgbRed = GetRValue (bg); | |
| 1401 bmp_info->bmiColors[1].rgbGreen = GetGValue (bg); | |
| 1402 bmp_info->bmiColors[1].rgbBlue = GetBValue (bg); | |
| 1403 bmp_info->bmiColors[1].rgbReserved = 0; | |
| 434 | 1404 |
| 1405 bitmap = CreateDIBSection (hdc, | |
| 428 | 1406 bmp_info, |
| 1407 DIB_RGB_COLORS, | |
| 434 | 1408 &bmp_buf, |
| 428 | 1409 0,0); |
| 1410 | |
|
4976
16112448d484
Rename xfree(FOO, TYPE) -> xfree(FOO)
Ben Wing <ben@xemacs.org>
parents:
4952
diff
changeset
|
1411 xfree (bmp_info); |
| 434 | 1412 |
| 428 | 1413 if (!bitmap || !bmp_buf) |
| 1414 { | |
|
4976
16112448d484
Rename xfree(FOO, TYPE) -> xfree(FOO)
Ben Wing <ben@xemacs.org>
parents:
4952
diff
changeset
|
1415 xfree (new_data); |
| 428 | 1416 return NULL; |
| 1417 } | |
| 434 | 1418 |
| 428 | 1419 /* copy in the actual bitmap */ |
| 1420 memcpy (bmp_buf, new_data, height * new_width); | |
|
4976
16112448d484
Rename xfree(FOO, TYPE) -> xfree(FOO)
Ben Wing <ben@xemacs.org>
parents:
4952
diff
changeset
|
1421 xfree (new_data); |
| 428 | 1422 |
| 1423 return bitmap; | |
| 1424 } | |
| 1425 | |
| 1426 /* Given inline data for a mono pixmap, initialize the given | |
| 1427 image instance accordingly. */ | |
| 1428 | |
| 1429 static void | |
| 440 | 1430 init_image_instance_from_xbm_inline (Lisp_Image_Instance *ii, |
| 428 | 1431 int width, int height, |
| 2367 | 1432 const Binbyte *bits, |
| 428 | 1433 Lisp_Object instantiator, |
| 1434 Lisp_Object pointer_fg, | |
| 1435 Lisp_Object pointer_bg, | |
| 1436 int dest_mask, | |
| 1437 HBITMAP mask, | |
| 2286 | 1438 Lisp_Object UNUSED (mask_filename)) |
| 428 | 1439 { |
| 1440 Lisp_Object device = IMAGE_INSTANCE_DEVICE (ii); | |
| 1441 Lisp_Object foreground = find_keyword_in_vector (instantiator, Q_foreground); | |
| 1442 Lisp_Object background = find_keyword_in_vector (instantiator, Q_background); | |
| 1443 enum image_instance_type type; | |
| 1444 COLORREF black = PALETTERGB (0,0,0); | |
| 1445 COLORREF white = PALETTERGB (255,255,255); | |
| 442 | 1446 HDC hdc; |
| 1447 | |
| 1448 CHECK_MSGDI_DEVICE (device); | |
| 1449 | |
| 1450 hdc = get_device_compdc (XDEVICE (device)); | |
| 428 | 1451 |
| 1452 if ((dest_mask & IMAGE_MONO_PIXMAP_MASK) && | |
| 1453 (dest_mask & IMAGE_COLOR_PIXMAP_MASK)) | |
| 1454 { | |
| 1455 if (!NILP (foreground) || !NILP (background)) | |
| 1456 type = IMAGE_COLOR_PIXMAP; | |
| 1457 else | |
| 1458 type = IMAGE_MONO_PIXMAP; | |
| 1459 } | |
| 1460 else if (dest_mask & IMAGE_MONO_PIXMAP_MASK) | |
| 1461 type = IMAGE_MONO_PIXMAP; | |
| 1462 else if (dest_mask & IMAGE_COLOR_PIXMAP_MASK) | |
| 1463 type = IMAGE_COLOR_PIXMAP; | |
| 1464 else if (dest_mask & IMAGE_POINTER_MASK) | |
| 1465 type = IMAGE_POINTER; | |
| 1466 else | |
| 1467 incompatible_image_types (instantiator, dest_mask, | |
| 1468 IMAGE_MONO_PIXMAP_MASK | IMAGE_COLOR_PIXMAP_MASK | |
| 1469 | IMAGE_POINTER_MASK); | |
| 1470 | |
| 1471 mswindows_initialize_dibitmap_image_instance (ii, 1, type); | |
| 434 | 1472 |
| 428 | 1473 IMAGE_INSTANCE_PIXMAP_FILENAME (ii) = |
| 1474 find_keyword_in_vector (instantiator, Q_file); | |
| 442 | 1475 IMAGE_INSTANCE_MSWINDOWS_BITMAP_REAL_WIDTH (ii) = width; |
| 1476 IMAGE_INSTANCE_MSWINDOWS_BITMAP_REAL_HEIGHT (ii) = height; | |
| 428 | 1477 IMAGE_INSTANCE_PIXMAP_DEPTH (ii) = 1; |
| 793 | 1478 IMAGE_INSTANCE_PIXMAP_HOTSPOT_X (ii) = make_int (0); |
| 1479 IMAGE_INSTANCE_PIXMAP_HOTSPOT_Y (ii) = make_int (0); | |
| 442 | 1480 init_image_instance_geometry (ii); |
| 1481 | |
| 428 | 1482 IMAGE_INSTANCE_MSWINDOWS_MASK (ii) = mask ? mask : |
| 593 | 1483 xbm_create_bitmap_from_data (hdc, bits, width, height, TRUE, black, white); |
| 428 | 1484 |
| 1485 switch (type) | |
| 1486 { | |
| 1487 case IMAGE_MONO_PIXMAP: | |
| 434 | 1488 IMAGE_INSTANCE_MSWINDOWS_BITMAP (ii) = |
| 593 | 1489 xbm_create_bitmap_from_data (hdc, bits, width, height, |
| 428 | 1490 FALSE, black, black); |
| 1491 break; | |
| 1492 | |
| 1493 case IMAGE_COLOR_PIXMAP: | |
| 1494 { | |
| 1495 COLORREF fg = black; | |
| 1496 COLORREF bg = white; | |
| 1497 | |
| 1498 if (!NILP (foreground) && !COLOR_INSTANCEP (foreground)) | |
| 1499 foreground = | |
| 1500 Fmake_color_instance (foreground, device, | |
| 1501 encode_error_behavior_flag (ERROR_ME)); | |
| 1502 | |
| 1503 if (COLOR_INSTANCEP (foreground)) | |
| 1504 fg = COLOR_INSTANCE_MSWINDOWS_COLOR (XCOLOR_INSTANCE (foreground)); | |
| 1505 | |
| 1506 if (!NILP (background) && !COLOR_INSTANCEP (background)) | |
| 1507 background = | |
| 1508 Fmake_color_instance (background, device, | |
| 1509 encode_error_behavior_flag (ERROR_ME)); | |
| 1510 | |
| 1511 if (COLOR_INSTANCEP (background)) | |
| 1512 bg = COLOR_INSTANCE_MSWINDOWS_COLOR (XCOLOR_INSTANCE (background)); | |
| 1513 | |
| 1514 IMAGE_INSTANCE_PIXMAP_FG (ii) = foreground; | |
| 1515 IMAGE_INSTANCE_PIXMAP_BG (ii) = background; | |
| 1516 | |
| 434 | 1517 IMAGE_INSTANCE_MSWINDOWS_BITMAP (ii) = |
| 593 | 1518 xbm_create_bitmap_from_data (hdc, bits, width, height, |
| 428 | 1519 FALSE, fg, black); |
| 1520 } | |
| 1521 break; | |
| 1522 | |
| 1523 case IMAGE_POINTER: | |
| 1524 { | |
| 1525 COLORREF fg = black; | |
| 1526 COLORREF bg = white; | |
| 1527 | |
| 1528 if (NILP (foreground)) | |
| 1529 foreground = pointer_fg; | |
| 1530 if (NILP (background)) | |
| 1531 background = pointer_bg; | |
| 1532 | |
| 434 | 1533 IMAGE_INSTANCE_PIXMAP_HOTSPOT_X (ii) = |
| 428 | 1534 find_keyword_in_vector (instantiator, Q_hotspot_x); |
| 434 | 1535 IMAGE_INSTANCE_PIXMAP_HOTSPOT_Y (ii) = |
| 428 | 1536 find_keyword_in_vector (instantiator, Q_hotspot_y); |
| 1537 IMAGE_INSTANCE_PIXMAP_FG (ii) = foreground; | |
| 1538 IMAGE_INSTANCE_PIXMAP_BG (ii) = background; | |
| 1539 if (COLOR_INSTANCEP (foreground)) | |
| 1540 fg = COLOR_INSTANCE_MSWINDOWS_COLOR (XCOLOR_INSTANCE (foreground)); | |
| 1541 if (COLOR_INSTANCEP (background)) | |
| 1542 bg = COLOR_INSTANCE_MSWINDOWS_COLOR (XCOLOR_INSTANCE (background)); | |
| 1543 | |
| 434 | 1544 IMAGE_INSTANCE_MSWINDOWS_BITMAP (ii) = |
| 593 | 1545 xbm_create_bitmap_from_data (hdc, bits, width, height, |
| 428 | 1546 TRUE, fg, black); |
| 1547 mswindows_initialize_image_instance_icon (ii, TRUE); | |
| 1548 } | |
| 1549 break; | |
| 1550 | |
| 1551 default: | |
| 2500 | 1552 ABORT (); |
| 428 | 1553 } |
| 1554 } | |
| 1555 | |
| 1556 static void | |
| 1557 xbm_instantiate_1 (Lisp_Object image_instance, Lisp_Object instantiator, | |
| 1558 Lisp_Object pointer_fg, Lisp_Object pointer_bg, | |
| 1559 int dest_mask, int width, int height, | |
| 2367 | 1560 const Binbyte *bits) |
| 428 | 1561 { |
| 1562 Lisp_Object mask_data = find_keyword_in_vector (instantiator, Q_mask_data); | |
| 1563 Lisp_Object mask_file = find_keyword_in_vector (instantiator, Q_mask_file); | |
| 440 | 1564 Lisp_Image_Instance *ii = XIMAGE_INSTANCE (image_instance); |
| 442 | 1565 HDC hdc = get_device_compdc (XDEVICE (IMAGE_INSTANCE_DEVICE (ii))); |
| 428 | 1566 HBITMAP mask = 0; |
| 1567 | |
| 1568 if (!NILP (mask_data)) | |
| 1569 { | |
| 2367 | 1570 Binbyte *ext_data; |
| 440 | 1571 |
|
4981
4aebb0131297
Cleanups/renaming of EXTERNAL_TO_C_STRING and friends
Ben Wing <ben@xemacs.org>
parents:
4952
diff
changeset
|
1572 ext_data = |
|
4aebb0131297
Cleanups/renaming of EXTERNAL_TO_C_STRING and friends
Ben Wing <ben@xemacs.org>
parents:
4952
diff
changeset
|
1573 (Binbyte *) LISP_STRING_TO_EXTERNAL (XCAR (XCDR (XCDR (mask_data))), |
|
4aebb0131297
Cleanups/renaming of EXTERNAL_TO_C_STRING and friends
Ben Wing <ben@xemacs.org>
parents:
4952
diff
changeset
|
1574 Qbinary); |
| 440 | 1575 mask = xbm_create_bitmap_from_data (hdc, |
| 593 | 1576 ext_data, |
| 440 | 1577 XINT (XCAR (mask_data)), |
| 1578 XINT (XCAR (XCDR (mask_data))), | |
| 1579 FALSE, | |
| 1580 PALETTERGB (0,0,0), | |
| 1581 PALETTERGB (255,255,255)); | |
| 428 | 1582 } |
| 1583 | |
| 1584 init_image_instance_from_xbm_inline (ii, width, height, bits, | |
| 1585 instantiator, pointer_fg, pointer_bg, | |
| 1586 dest_mask, mask, mask_file); | |
| 1587 } | |
| 1588 | |
| 1589 /* Instantiate method for XBM's. */ | |
| 1590 | |
| 1591 static void | |
| 434 | 1592 mswindows_xbm_instantiate (Lisp_Object image_instance, |
| 428 | 1593 Lisp_Object instantiator, |
| 1594 Lisp_Object pointer_fg, Lisp_Object pointer_bg, | |
| 2286 | 1595 int dest_mask, Lisp_Object UNUSED (domain)) |
| 428 | 1596 { |
| 1597 Lisp_Object data = find_keyword_in_vector (instantiator, Q_data); | |
| 2367 | 1598 const Binbyte *ext_data; |
| 428 | 1599 |
| 1600 assert (!NILP (data)); | |
| 1601 | |
|
4981
4aebb0131297
Cleanups/renaming of EXTERNAL_TO_C_STRING and friends
Ben Wing <ben@xemacs.org>
parents:
4952
diff
changeset
|
1602 ext_data = |
|
4aebb0131297
Cleanups/renaming of EXTERNAL_TO_C_STRING and friends
Ben Wing <ben@xemacs.org>
parents:
4952
diff
changeset
|
1603 (const Binbyte *) LISP_STRING_TO_EXTERNAL (XCAR (XCDR (XCDR (data))), |
|
4aebb0131297
Cleanups/renaming of EXTERNAL_TO_C_STRING and friends
Ben Wing <ben@xemacs.org>
parents:
4952
diff
changeset
|
1604 Qbinary); |
| 428 | 1605 |
| 1606 xbm_instantiate_1 (image_instance, instantiator, pointer_fg, | |
| 1607 pointer_bg, dest_mask, XINT (XCAR (data)), | |
| 440 | 1608 XINT (XCAR (XCDR (data))), ext_data); |
| 428 | 1609 } |
| 1610 | |
| 1611 #ifdef HAVE_XFACE | |
| 1612 /********************************************************************** | |
| 1613 * X-Face * | |
| 1614 **********************************************************************/ | |
| 1615 #if defined(EXTERN) | |
| 1616 /* This is about to get redefined! */ | |
| 1617 #undef EXTERN | |
| 1618 #endif | |
| 1619 /* We have to define SYSV32 so that compface.h includes string.h | |
| 1620 instead of strings.h. */ | |
| 1621 #define SYSV32 | |
| 1743 | 1622 BEGIN_C_DECLS |
| 2500 | 1623 #ifndef __STDC__ /* Needed to avoid prototype warnings */ |
| 1624 #define __STDC__ | |
| 1625 #endif | |
| 428 | 1626 #include <compface.h> |
| 1743 | 1627 END_C_DECLS |
| 1628 | |
| 428 | 1629 /* JMP_BUF cannot be used here because if it doesn't get defined |
| 1630 to jmp_buf we end up with a conflicting type error with the | |
| 1631 definition in compface.h */ | |
| 1632 extern jmp_buf comp_env; | |
| 1633 #undef SYSV32 | |
| 1634 | |
| 1635 static void | |
| 502 | 1636 mswindows_xface_instantiate (Lisp_Object image_instance, |
| 1637 Lisp_Object instantiator, | |
| 428 | 1638 Lisp_Object pointer_fg, Lisp_Object pointer_bg, |
| 2286 | 1639 int dest_mask, Lisp_Object UNUSED (domain)) |
| 428 | 1640 { |
| 1641 Lisp_Object data = find_keyword_in_vector (instantiator, Q_data); | |
| 1642 int i, stattis; | |
| 2367 | 1643 Binbyte *p, *bits, *bp; |
| 867 | 1644 const CIbyte * volatile emsg = 0; |
| 2367 | 1645 const Binbyte * volatile dstring; |
| 428 | 1646 |
| 1647 assert (!NILP (data)); | |
| 1648 | |
|
4981
4aebb0131297
Cleanups/renaming of EXTERNAL_TO_C_STRING and friends
Ben Wing <ben@xemacs.org>
parents:
4952
diff
changeset
|
1649 dstring = (const Binbyte *) LISP_STRING_TO_EXTERNAL (data, Qbinary); |
| 428 | 1650 |
| 2367 | 1651 if ((p = (Binbyte *) strchr ((char *) dstring, ':'))) |
| 428 | 1652 { |
| 1653 dstring = p + 1; | |
| 1654 } | |
| 1655 | |
| 1656 /* Must use setjmp not SETJMP because we used jmp_buf above not JMP_BUF */ | |
| 1657 if (!(stattis = setjmp (comp_env))) | |
| 1658 { | |
| 1659 UnCompAll ((char *) dstring); | |
| 1660 UnGenFace (); | |
| 1661 } | |
| 1662 | |
| 1663 switch (stattis) | |
| 1664 { | |
| 1665 case -2: | |
| 1666 emsg = "uncompface: internal error"; | |
| 1667 break; | |
| 1668 case -1: | |
| 1669 emsg = "uncompface: insufficient or invalid data"; | |
| 1670 break; | |
| 1671 case 1: | |
| 1672 emsg = "uncompface: excess data ignored"; | |
| 1673 break; | |
| 1674 } | |
| 1675 | |
| 1676 if (emsg) | |
| 563 | 1677 signal_image_error_2 (emsg, data, Qimage); |
| 428 | 1678 |
| 2367 | 1679 bp = bits = alloca_binbytes (PIXELS / 8); |
| 428 | 1680 |
| 1681 /* the compface library exports char F[], which uses a single byte per | |
| 1682 pixel to represent a 48x48 bitmap. Yuck. */ | |
| 2367 | 1683 for (i = 0, p = (Binbyte *) F; i < (PIXELS / 8); ++i) |
| 428 | 1684 { |
| 1685 int n, b; | |
| 1686 /* reverse the bit order of each byte... */ | |
| 1687 for (b = n = 0; b < 8; ++b) | |
| 1688 { | |
| 1689 n |= ((*p++) << b); | |
| 1690 } | |
| 2367 | 1691 *bp++ = (Binbyte) n; |
| 428 | 1692 } |
| 1693 | |
| 1694 xbm_instantiate_1 (image_instance, instantiator, pointer_fg, | |
| 1695 pointer_bg, dest_mask, 48, 48, bits); | |
| 1696 } | |
| 1697 #endif /* HAVE_XFACE */ | |
| 1698 | |
| 1699 | |
| 1700 /************************************************************************/ | |
| 1701 /* image instance methods */ | |
| 1702 /************************************************************************/ | |
| 1703 | |
| 1704 static void | |
| 440 | 1705 mswindows_print_image_instance (Lisp_Image_Instance *p, |
| 428 | 1706 Lisp_Object printcharfun, |
| 2286 | 1707 int UNUSED (escapeflag)) |
| 428 | 1708 { |
| 1709 switch (IMAGE_INSTANCE_TYPE (p)) | |
| 1710 { | |
| 1711 case IMAGE_MONO_PIXMAP: | |
| 1712 case IMAGE_COLOR_PIXMAP: | |
| 1713 case IMAGE_POINTER: | |
| 800 | 1714 write_fmt_string (printcharfun, " (0x%lx", |
| 1715 (unsigned long) IMAGE_INSTANCE_MSWINDOWS_BITMAP (p)); | |
| 428 | 1716 if (IMAGE_INSTANCE_MSWINDOWS_MASK (p)) |
| 1717 { | |
| 800 | 1718 write_fmt_string (printcharfun, "/0x%lx", |
| 1719 (unsigned long) IMAGE_INSTANCE_MSWINDOWS_MASK (p)); | |
| 428 | 1720 } |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
1721 write_ascstring (printcharfun, ")"); |
| 428 | 1722 break; |
| 1723 | |
| 1724 default: | |
| 1725 break; | |
| 1726 } | |
| 1727 } | |
| 1728 | |
| 1729 #ifdef DEBUG_WIDGETS | |
| 1730 extern int debug_widget_instances; | |
| 1731 #endif | |
| 1732 | |
| 1733 static void | |
| 611 | 1734 finalize_destroy_window (void *win) |
| 1735 { | |
| 1736 DestroyWindow ((HWND) win); | |
| 1737 } | |
| 1738 | |
| 1739 static void | |
| 440 | 1740 mswindows_finalize_image_instance (Lisp_Image_Instance *p) |
| 428 | 1741 { |
| 442 | 1742 if (!p->data) |
| 1743 return; | |
| 1744 | |
| 1745 if (DEVICE_LIVE_P (XDEVICE (IMAGE_INSTANCE_DEVICE (p)))) | |
| 428 | 1746 { |
| 442 | 1747 if (image_instance_type_to_mask (IMAGE_INSTANCE_TYPE (p)) |
| 1748 & (IMAGE_WIDGET_MASK | IMAGE_SUBWINDOW_MASK)) | |
| 428 | 1749 { |
| 1750 #ifdef DEBUG_WIDGETS | |
| 1751 debug_widget_instances--; | |
| 1752 stderr_out ("widget destroyed, %d left\n", debug_widget_instances); | |
| 1753 #endif | |
| 1754 if (IMAGE_INSTANCE_SUBWINDOW_ID (p)) | |
| 1755 { | |
| 611 | 1756 /* DestroyWindow is not safe here, as it will send messages |
| 1757 to our window proc. */ | |
| 1758 register_post_gc_action | |
| 1759 (finalize_destroy_window, | |
| 1760 (void *) (WIDGET_INSTANCE_MSWINDOWS_HANDLE (p))); | |
| 1761 register_post_gc_action | |
| 1762 (finalize_destroy_window, | |
| 1763 (void *) (IMAGE_INSTANCE_MSWINDOWS_CLIPWINDOW (p))); | |
| 428 | 1764 IMAGE_INSTANCE_SUBWINDOW_ID (p) = 0; |
| 1765 } | |
| 1766 } | |
| 1767 else if (p->data) | |
| 1768 { | |
| 1769 int i; | |
| 1770 if (IMAGE_INSTANCE_PIXMAP_TIMEOUT (p)) | |
| 1771 disable_glyph_animated_timeout (IMAGE_INSTANCE_PIXMAP_TIMEOUT (p)); | |
| 1772 | |
| 1773 if (IMAGE_INSTANCE_MSWINDOWS_BITMAP_SLICES (p)) | |
| 1774 { | |
| 1775 for (i = 0; i < IMAGE_INSTANCE_PIXMAP_MAXSLICE (p); i++) | |
| 1776 { | |
| 1777 if (IMAGE_INSTANCE_MSWINDOWS_BITMAP_SLICE (p, i)) | |
| 1778 DeleteObject (IMAGE_INSTANCE_MSWINDOWS_BITMAP_SLICE (p, i)); | |
| 1779 IMAGE_INSTANCE_MSWINDOWS_BITMAP_SLICE (p, i) = 0; | |
| 1780 } | |
|
4976
16112448d484
Rename xfree(FOO, TYPE) -> xfree(FOO)
Ben Wing <ben@xemacs.org>
parents:
4952
diff
changeset
|
1781 xfree (IMAGE_INSTANCE_MSWINDOWS_BITMAP_SLICES (p)); |
| 428 | 1782 IMAGE_INSTANCE_MSWINDOWS_BITMAP_SLICES (p) = 0; |
| 1783 } | |
| 1784 if (IMAGE_INSTANCE_MSWINDOWS_MASK (p)) | |
| 1785 DeleteObject (IMAGE_INSTANCE_MSWINDOWS_MASK (p)); | |
| 1786 IMAGE_INSTANCE_MSWINDOWS_MASK (p) = 0; | |
| 1787 if (IMAGE_INSTANCE_MSWINDOWS_ICON (p)) | |
| 1788 DestroyIcon (IMAGE_INSTANCE_MSWINDOWS_ICON (p)); | |
| 1789 IMAGE_INSTANCE_MSWINDOWS_ICON (p) = 0; | |
| 1790 } | |
| 1791 } | |
| 1792 | |
| 1793 if (p->data) | |
| 1794 { | |
|
4976
16112448d484
Rename xfree(FOO, TYPE) -> xfree(FOO)
Ben Wing <ben@xemacs.org>
parents:
4952
diff
changeset
|
1795 xfree (p->data); |
| 428 | 1796 p->data = 0; |
| 1797 } | |
| 1798 } | |
| 1799 | |
| 1800 /************************************************************************/ | |
| 771 | 1801 /* subwindow and widget support */ |
| 428 | 1802 /************************************************************************/ |
| 1803 | |
| 771 | 1804 static Lisp_Object |
| 2333 | 1805 charset_of_text (Lisp_Object USED_IF_MULE (text)) |
| 771 | 1806 { |
| 1807 #ifdef MULE | |
| 867 | 1808 Ibyte *p; |
| 771 | 1809 |
| 1810 if (NILP (text)) | |
| 1811 return Vcharset_ascii; | |
| 1812 for (p = XSTRING_DATA (text); *p;) | |
| 1813 { | |
| 867 | 1814 Ichar c = itext_ichar (p); |
| 1815 if (!EQ (ichar_charset (c), Vcharset_ascii)) | |
| 1816 return ichar_charset (c); | |
| 1817 INC_IBYTEPTR (p); | |
| 771 | 1818 } |
| 1819 #endif /* MULE */ | |
| 1820 | |
| 1821 return Vcharset_ascii; | |
| 1822 } | |
| 1823 | |
| 1824 | |
| 440 | 1825 static HFONT |
| 771 | 1826 mswindows_widget_hfont (Lisp_Object face, |
| 1827 Lisp_Object domain, | |
| 1828 Lisp_Object text) | |
| 440 | 1829 { |
| 1830 int under = FACE_UNDERLINE_P (face, domain); | |
| 1831 int strike = FACE_STRIKETHRU_P (face, domain); | |
| 771 | 1832 Lisp_Object font; |
| 1833 struct face_cachel frame_cachel; | |
| 1834 struct face_cachel *cachel; | |
| 1835 Lisp_Object charset; | |
| 1836 | |
| 1837 reset_face_cachel (&frame_cachel); | |
| 1838 update_face_cachel_data (&frame_cachel, domain, face); | |
| 1839 cachel = &frame_cachel; | |
| 1840 /* !!#### This is a big hack. We return the first non-ASCII charset in | |
| 1841 the string, on the assumption that we can display ASCII characters in | |
| 1842 all fonts. We really need to draw the text of the widget ourselves; | |
| 1843 or perhaps there are fonts supporting lots of character sets? */ | |
| 1844 charset = charset_of_text (text); | |
| 1845 | |
| 1846 font = FACE_CACHEL_FONT (cachel, charset); | |
| 1847 | |
| 1848 if (!FONT_INSTANCEP (font)) | |
| 1849 font = ensure_face_cachel_contains_charset (cachel, domain, charset); | |
| 1850 | |
| 1851 if (EQ (font, Vthe_null_font_instance)) | |
| 1852 font = FACE_CACHEL_FONT (cachel, Vcharset_ascii); | |
| 440 | 1853 |
| 1854 return mswindows_get_hfont (XFONT_INSTANCE (font), under, strike); | |
| 1855 } | |
| 1856 | |
| 872 | 1857 #ifdef DEFER_WINDOW_POS |
| 1858 | |
| 442 | 1859 static HDWP |
| 1860 begin_defer_window_pos (struct frame *f) | |
| 1861 { | |
| 1862 if (FRAME_MSWINDOWS_DATA (f)->hdwp == 0) | |
| 1863 FRAME_MSWINDOWS_DATA (f)->hdwp = BeginDeferWindowPos (10); | |
| 1864 return FRAME_MSWINDOWS_DATA (f)->hdwp; | |
| 1865 } | |
| 1866 | |
| 872 | 1867 #endif |
| 1868 | |
| 428 | 1869 /* unmap the image if it is a widget. This is used by redisplay via |
| 1870 redisplay_unmap_subwindows */ | |
| 1871 static void | |
| 440 | 1872 mswindows_unmap_subwindow (Lisp_Image_Instance *p) |
| 428 | 1873 { |
| 1874 if (IMAGE_INSTANCE_SUBWINDOW_ID (p)) | |
| 1875 { | |
| 442 | 1876 #ifdef DEFER_WINDOW_POS |
| 1877 struct frame *f = XFRAME (IMAGE_INSTANCE_FRAME (p)); | |
| 1878 HDWP hdwp = begin_defer_window_pos (f); | |
| 1879 HDWP new_hdwp; | |
| 1880 new_hdwp = DeferWindowPos (hdwp, IMAGE_INSTANCE_MSWINDOWS_CLIPWINDOW (p), | |
| 1881 NULL, | |
| 1882 0, 0, 0, 0, | |
| 1883 SWP_HIDEWINDOW | SWP_NOACTIVATE | | |
| 1884 SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER | |
| 1885 /* Setting this flag causes the call to | |
| 1886 DeferWindowPos to fail with | |
| 1887 "Invalid parameter". I don't understand | |
| 1888 why we bother to try and set this | |
| 1889 anyway. -- ben */ | |
| 1890 /* | SWP_NOSENDCHANGING */ | |
| 1891 ); | |
| 1892 if (!new_hdwp) | |
| 1893 mswindows_output_last_error ("unmapping"); | |
| 1894 else | |
| 1895 hdwp = new_hdwp; | |
| 1896 FRAME_MSWINDOWS_DATA (f)->hdwp = hdwp; | |
| 1897 #else | |
| 434 | 1898 SetWindowPos (IMAGE_INSTANCE_MSWINDOWS_CLIPWINDOW (p), |
| 1899 NULL, | |
| 428 | 1900 0, 0, 0, 0, |
| 442 | 1901 SWP_HIDEWINDOW | SWP_NOACTIVATE | |
| 1902 SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER ); | |
| 1903 #endif | |
| 440 | 1904 if (GetFocus() == WIDGET_INSTANCE_MSWINDOWS_HANDLE (p)) |
| 1905 SetFocus (GetParent (IMAGE_INSTANCE_MSWINDOWS_CLIPWINDOW (p))); | |
| 428 | 1906 } |
| 1907 } | |
| 1908 | |
| 1909 /* map the subwindow. This is used by redisplay via | |
| 1910 redisplay_output_subwindow */ | |
| 1911 static void | |
| 440 | 1912 mswindows_map_subwindow (Lisp_Image_Instance *p, int x, int y, |
| 771 | 1913 struct display_glyph_area *dga) |
| 428 | 1914 { |
| 442 | 1915 #ifdef DEFER_WINDOW_POS |
| 1916 struct frame *f = XFRAME (IMAGE_INSTANCE_FRAME (p)); | |
| 1917 HDWP hdwp = begin_defer_window_pos (f); | |
| 1918 HDWP new_hdwp; | |
| 1919 #endif | |
| 428 | 1920 /* move the window before mapping it ... */ |
| 1921 SetWindowPos (IMAGE_INSTANCE_MSWINDOWS_CLIPWINDOW (p), | |
| 434 | 1922 NULL, |
| 428 | 1923 x, y, dga->width, dga->height, |
| 434 | 1924 SWP_NOZORDER |
| 428 | 1925 | SWP_NOCOPYBITS | SWP_NOSENDCHANGING); |
| 1926 /* ... adjust the child ... */ | |
| 1927 SetWindowPos (WIDGET_INSTANCE_MSWINDOWS_HANDLE (p), | |
| 434 | 1928 NULL, |
| 428 | 1929 -dga->xoffset, -dga->yoffset, 0, 0, |
| 1930 SWP_NOZORDER | SWP_NOSIZE | |
| 1931 | SWP_NOCOPYBITS | SWP_NOSENDCHANGING); | |
| 1932 /* ... now map it - we are not allowed to move it at the same time. */ | |
| 442 | 1933 if (!IMAGE_INSTANCE_SUBWINDOW_DISPLAYEDP (p)) |
| 1934 { | |
| 1935 #ifdef DEFER_WINDOW_POS | |
| 1936 new_hdwp = DeferWindowPos | |
| 1937 (hdwp, | |
| 1938 IMAGE_INSTANCE_MSWINDOWS_CLIPWINDOW (p), | |
| 1939 NULL, 0, 0, 0, 0, | |
| 1940 SWP_NOZORDER | SWP_NOSIZE | SWP_NOMOVE | |
| 1941 | SWP_SHOWWINDOW | |
| 1942 /* | SWP_NOCOPYBITS */ | |
| 1943 /* Setting this flag causes the call to | |
| 1944 DeferWindowPos to fail with | |
| 1945 "Invalid parameter". I don't understand | |
| 1946 why we bother to try and set this | |
| 1947 anyway. -- ben */ | |
| 1948 /* | SWP_NOSENDCHANGING */ | |
| 1949 | SWP_NOACTIVATE); | |
| 1950 if (!new_hdwp) | |
| 1951 mswindows_output_last_error ("mapping"); | |
| 1952 else | |
| 1953 hdwp = new_hdwp; | |
| 1954 FRAME_MSWINDOWS_DATA (f)->hdwp = hdwp; | |
| 1955 #else | |
| 1956 SetWindowPos (IMAGE_INSTANCE_MSWINDOWS_CLIPWINDOW (p), | |
| 1957 NULL, | |
| 1958 0, 0, 0, 0, | |
| 1959 SWP_NOZORDER | SWP_NOSIZE | SWP_NOMOVE | |
| 1960 | SWP_SHOWWINDOW | SWP_NOCOPYBITS | SWP_NOACTIVATE); | |
| 863 | 1961 |
| 1962 /* Doing this once does not seem to be enough, for instance when | |
| 1963 mapping the search dialog this gets called four times. If we | |
| 1964 only set on the first time through then the subwindow never | |
| 1965 gets focus as intended. However, doing this everytime doesn't | |
| 1966 seem so bad, after all we only need to redo this after the | |
| 1967 focus changes - and if that happens resetting the initial | |
| 1968 focus doesn't seem so bad. */ | |
| 1969 if (IMAGE_INSTANCE_WANTS_INITIAL_FOCUS (p)) | |
| 1970 SetFocus (WIDGET_INSTANCE_MSWINDOWS_HANDLE (p)); | |
| 442 | 1971 #endif |
| 1972 } | |
| 428 | 1973 } |
| 1974 | |
| 1975 /* resize the subwindow instance */ | |
| 434 | 1976 static void |
| 771 | 1977 mswindows_resize_subwindow (Lisp_Image_Instance *ii, int w, int h) |
| 428 | 1978 { |
| 1979 /* Set the size of the control .... */ | |
| 442 | 1980 if (!SetWindowPos (WIDGET_INSTANCE_MSWINDOWS_HANDLE (ii), |
| 1981 NULL, | |
| 1982 0, 0, w, h, | |
| 1983 SWP_NOZORDER | SWP_NOMOVE | |
| 1984 | SWP_NOCOPYBITS | SWP_NOSENDCHANGING)) | |
| 1985 mswindows_output_last_error ("resizing"); | |
| 1986 } | |
| 1987 | |
| 1988 /* Simply resize the window here. */ | |
| 1989 static void | |
| 1990 mswindows_redisplay_subwindow (Lisp_Image_Instance *p) | |
| 1991 { | |
| 1992 mswindows_resize_subwindow (p, | |
| 1993 IMAGE_INSTANCE_WIDTH (p), | |
| 1994 IMAGE_INSTANCE_HEIGHT (p)); | |
| 428 | 1995 } |
| 1996 | |
| 1997 /* when you click on a widget you may activate another widget this | |
| 1998 needs to be checked and all appropriate widgets updated */ | |
| 1999 static void | |
| 442 | 2000 mswindows_redisplay_widget (Lisp_Image_Instance *p) |
| 428 | 2001 { |
| 442 | 2002 /* Possibly update the face font and colors. */ |
| 2003 if (!NILP (IMAGE_INSTANCE_WIDGET_TEXT (p)) | |
| 2004 && (IMAGE_INSTANCE_WIDGET_FACE_CHANGED (p) | |
| 2005 || XFRAME (IMAGE_INSTANCE_FRAME (p))->faces_changed | |
| 2006 || IMAGE_INSTANCE_WIDGET_ITEMS_CHANGED (p))) | |
| 428 | 2007 { |
| 2008 /* set the widget font from the widget face */ | |
| 771 | 2009 qxeSendMessage (WIDGET_INSTANCE_MSWINDOWS_HANDLE (p), |
| 2010 WM_SETFONT, | |
| 2011 (WPARAM) mswindows_widget_hfont | |
| 2012 (IMAGE_INSTANCE_WIDGET_FACE (p), | |
| 2013 IMAGE_INSTANCE_FRAME (p), | |
| 2014 IMAGE_INSTANCE_WIDGET_TEXT (p)), | |
| 2015 MAKELPARAM (TRUE, 0)); | |
| 428 | 2016 } |
| 442 | 2017 /* Possibly update the dimensions. */ |
| 2018 if (IMAGE_INSTANCE_SIZE_CHANGED (p)) | |
| 2019 { | |
| 2020 mswindows_resize_subwindow (p, | |
| 2021 IMAGE_INSTANCE_WIDTH (p), | |
| 2022 IMAGE_INSTANCE_HEIGHT (p)); | |
| 2023 } | |
| 2024 /* Possibly update the text in the widget. */ | |
| 2025 if (IMAGE_INSTANCE_TEXT_CHANGED (p) | |
| 2026 && !NILP (IMAGE_INSTANCE_WIDGET_TEXT (p))) | |
| 2027 { | |
| 771 | 2028 Extbyte *lparam = 0; |
|
4981
4aebb0131297
Cleanups/renaming of EXTERNAL_TO_C_STRING and friends
Ben Wing <ben@xemacs.org>
parents:
4952
diff
changeset
|
2029 lparam = LISP_STRING_TO_TSTR (IMAGE_INSTANCE_WIDGET_TEXT (p)); |
| 771 | 2030 qxeSendMessage (WIDGET_INSTANCE_MSWINDOWS_HANDLE (p), |
| 2031 WM_SETTEXT, 0, (LPARAM) lparam); | |
| 442 | 2032 } |
| 454 | 2033 /* Set active state. */ |
| 2034 if (IMAGE_INSTANCE_WIDGET_ITEMS_CHANGED (p)) | |
| 2035 { | |
| 2036 Lisp_Object item = IMAGE_INSTANCE_WIDGET_PENDING_ITEMS (p); | |
| 771 | 2037 LONG style = qxeGetWindowLong |
| 454 | 2038 (WIDGET_INSTANCE_MSWINDOWS_HANDLE (p), |
| 2039 GWL_STYLE); | |
| 2040 | |
| 2041 if (CONSP (item)) | |
| 2042 item = XCAR (item); | |
| 2043 | |
| 1913 | 2044 if (gui_item_active_p (item)) |
| 771 | 2045 qxeSetWindowLong (WIDGET_INSTANCE_MSWINDOWS_HANDLE (p), |
| 2046 GWL_STYLE, style & ~WS_DISABLED); | |
| 454 | 2047 else |
| 771 | 2048 qxeSetWindowLong (WIDGET_INSTANCE_MSWINDOWS_HANDLE (p), |
| 2049 GWL_STYLE, style | WS_DISABLED); | |
| 454 | 2050 } |
| 428 | 2051 } |
| 2052 | |
| 771 | 2053 #ifdef HAVE_WIDGETS |
| 2054 | |
| 863 | 2055 /* Account for some of the limitations with widget images. */ |
| 2056 static int | |
| 2057 mswindows_widget_border_width (void) | |
| 2058 { | |
| 2059 return DEFAULT_WIDGET_BORDER_WIDTH; | |
| 2060 } | |
| 2061 | |
| 442 | 2062 /* register widgets into our hashtable so that we can cope with the |
| 428 | 2063 callbacks. The hashtable is weak so deregistration is handled |
| 2064 automatically */ | |
| 2065 static int | |
| 442 | 2066 mswindows_register_gui_item (Lisp_Object image_instance, |
| 2067 Lisp_Object gui, Lisp_Object domain) | |
| 428 | 2068 { |
| 442 | 2069 Lisp_Object frame = DOMAIN_FRAME (domain); |
| 771 | 2070 struct frame *f = XFRAME (frame); |
| 442 | 2071 int id = gui_item_id_hash (FRAME_MSWINDOWS_WIDGET_HASH_TABLE2 (f), |
| 428 | 2072 gui, |
| 2073 WIDGET_GLYPH_SLOT); | |
| 442 | 2074 Fputhash (make_int (id), image_instance, |
| 2075 FRAME_MSWINDOWS_WIDGET_HASH_TABLE1 (f)); | |
| 2076 Fputhash (make_int (id), XGUI_ITEM (gui)->callback, | |
| 2077 FRAME_MSWINDOWS_WIDGET_HASH_TABLE2 (f)); | |
| 2078 Fputhash (make_int (id), XGUI_ITEM (gui)->callback_ex, | |
| 2079 FRAME_MSWINDOWS_WIDGET_HASH_TABLE3 (f)); | |
| 428 | 2080 return id; |
| 2081 } | |
| 2082 | |
| 2083 static int | |
| 2084 mswindows_register_widget_instance (Lisp_Object instance, Lisp_Object domain) | |
| 2085 { | |
| 442 | 2086 return mswindows_register_gui_item (instance, |
| 2087 XIMAGE_INSTANCE_WIDGET_ITEM (instance), | |
| 428 | 2088 domain); |
| 2089 } | |
| 2090 | |
| 2091 static void | |
| 502 | 2092 mswindows_subwindow_instantiate (Lisp_Object image_instance, |
| 2286 | 2093 Lisp_Object UNUSED (instantiator), |
| 2094 Lisp_Object UNUSED (pointer_fg), | |
| 2095 Lisp_Object UNUSED (pointer_bg), | |
| 2096 int UNUSED (dest_mask), Lisp_Object domain) | |
| 428 | 2097 { |
| 440 | 2098 Lisp_Image_Instance *ii = XIMAGE_INSTANCE (image_instance); |
| 428 | 2099 Lisp_Object device = IMAGE_INSTANCE_DEVICE (ii); |
| 442 | 2100 Lisp_Object frame = DOMAIN_FRAME (domain); |
| 428 | 2101 HWND wnd; |
| 2102 | |
| 442 | 2103 CHECK_MSWINDOWS_DEVICE (device); |
| 428 | 2104 |
| 2105 /* have to set the type this late in case there is no device | |
| 2106 instantiation for a widget */ | |
| 2107 IMAGE_INSTANCE_TYPE (ii) = IMAGE_SUBWINDOW; | |
| 2108 /* Allocate space for the clip window */ | |
| 2109 ii->data = xnew_and_zero (struct mswindows_subwindow_data); | |
| 2110 | |
| 2111 if ((IMAGE_INSTANCE_MSWINDOWS_CLIPWINDOW (ii) | |
| 771 | 2112 = qxeCreateWindowEx ( |
| 2113 0, /* EX flags */ | |
| 2114 XETEXT (XEMACS_CONTROL_CLASS), | |
| 2115 0, /* text */ | |
| 2116 WS_CLIPCHILDREN | WS_CLIPSIBLINGS | WS_CHILD, | |
| 2117 0, /* starting x position */ | |
| 2118 0, /* starting y position */ | |
| 2119 IMAGE_INSTANCE_WIDGET_WIDTH (ii), | |
| 2120 IMAGE_INSTANCE_WIDGET_HEIGHT (ii), | |
| 2121 /* parent window */ | |
| 2122 FRAME_MSWINDOWS_HANDLE (XFRAME (frame)), | |
| 2123 NULL, /* No menu */ | |
| 2124 NULL, /* must be null for this class */ | |
| 2125 NULL)) == NULL) | |
| 563 | 2126 gui_error ("window creation failed with code", |
| 2127 make_int (GetLastError())); | |
| 428 | 2128 |
| 771 | 2129 wnd = qxeCreateWindow (XETEXT ("STATIC"), XETEXT (""), |
| 2130 WS_CHILD, | |
| 2131 0, /* starting x position */ | |
| 2132 0, /* starting y position */ | |
| 2133 IMAGE_INSTANCE_WIDGET_WIDTH (ii), | |
| 2134 IMAGE_INSTANCE_WIDGET_HEIGHT (ii), | |
| 2135 IMAGE_INSTANCE_MSWINDOWS_CLIPWINDOW (ii), | |
| 2136 0, | |
| 2137 (HINSTANCE) | |
| 2138 qxeGetWindowLong | |
| 2139 (FRAME_MSWINDOWS_HANDLE (XFRAME (frame)), | |
| 2140 GWL_HINSTANCE), | |
| 2141 NULL); | |
| 2142 | |
| 5013 | 2143 qxeSetWindowLong (wnd, GWL_USERDATA, (LONG)STORE_LISP_IN_VOID(image_instance)); |
| 428 | 2144 IMAGE_INSTANCE_SUBWINDOW_ID (ii) = wnd; |
| 2145 } | |
| 2146 | |
| 771 | 2147 #endif /* HAVE_WIDGETS */ |
| 2148 | |
| 428 | 2149 static int |
| 440 | 2150 mswindows_image_instance_equal (Lisp_Image_Instance *p1, |
| 2286 | 2151 Lisp_Image_Instance *p2, int UNUSED (depth)) |
| 428 | 2152 { |
| 2153 switch (IMAGE_INSTANCE_TYPE (p1)) | |
| 2154 { | |
| 2155 case IMAGE_MONO_PIXMAP: | |
| 2156 case IMAGE_COLOR_PIXMAP: | |
| 2157 case IMAGE_POINTER: | |
| 434 | 2158 if (IMAGE_INSTANCE_MSWINDOWS_BITMAP (p1) |
| 428 | 2159 != IMAGE_INSTANCE_MSWINDOWS_BITMAP (p2)) |
| 2160 return 0; | |
| 2161 break; | |
| 434 | 2162 |
| 428 | 2163 default: |
| 2164 break; | |
| 2165 } | |
| 2166 | |
| 2167 return 1; | |
| 2168 } | |
| 2169 | |
| 665 | 2170 static Hashcode |
| 2286 | 2171 mswindows_image_instance_hash (Lisp_Image_Instance *p, int UNUSED (depth)) |
| 428 | 2172 { |
| 2173 switch (IMAGE_INSTANCE_TYPE (p)) | |
| 2174 { | |
| 2175 case IMAGE_MONO_PIXMAP: | |
| 2176 case IMAGE_COLOR_PIXMAP: | |
| 2177 case IMAGE_POINTER: | |
| 665 | 2178 return (Hashcode) IMAGE_INSTANCE_MSWINDOWS_BITMAP (p); |
| 434 | 2179 |
| 428 | 2180 default: |
| 2181 return 0; | |
| 2182 } | |
| 2183 } | |
| 2184 | |
| 2185 /* Set all the slots in an image instance structure to reasonable | |
| 2186 default values. This is used somewhere within an instantiate | |
| 2187 method. It is assumed that the device slot within the image | |
| 2188 instance is already set -- this is the case when instantiate | |
| 2189 methods are called. */ | |
| 2190 | |
| 2191 static void | |
| 440 | 2192 mswindows_initialize_dibitmap_image_instance (Lisp_Image_Instance *ii, |
| 428 | 2193 int slices, |
| 2194 enum image_instance_type type) | |
| 2195 { | |
| 2196 ii->data = xnew_and_zero (struct mswindows_image_instance_data); | |
| 2197 IMAGE_INSTANCE_TYPE (ii) = type; | |
| 2198 IMAGE_INSTANCE_PIXMAP_FILENAME (ii) = Qnil; | |
| 2199 IMAGE_INSTANCE_PIXMAP_MASK_FILENAME (ii) = Qnil; | |
| 2200 IMAGE_INSTANCE_PIXMAP_HOTSPOT_X (ii) = Qnil; | |
| 2201 IMAGE_INSTANCE_PIXMAP_HOTSPOT_Y (ii) = Qnil; | |
| 2202 IMAGE_INSTANCE_PIXMAP_FG (ii) = Qnil; | |
| 2203 IMAGE_INSTANCE_PIXMAP_BG (ii) = Qnil; | |
| 2204 IMAGE_INSTANCE_PIXMAP_MAXSLICE (ii) = slices; | |
| 434 | 2205 IMAGE_INSTANCE_MSWINDOWS_BITMAP_SLICES (ii) = |
| 428 | 2206 xnew_array_and_zero (HBITMAP, slices); |
| 2207 } | |
| 2208 | |
| 2209 | |
| 2210 #ifdef HAVE_WIDGETS | |
| 2211 | |
| 2212 /************************************************************************/ | |
| 771 | 2213 /* widgets */ |
| 428 | 2214 /************************************************************************/ |
| 2215 static void | |
| 502 | 2216 mswindows_widget_instantiate (Lisp_Object image_instance, |
| 2286 | 2217 Lisp_Object UNUSED (instantiator), |
| 2218 Lisp_Object UNUSED (pointer_fg), | |
| 2219 Lisp_Object UNUSED (pointer_bg), | |
| 2220 int UNUSED (dest_mask), Lisp_Object domain, | |
| 1204 | 2221 const CIbyte *class_, int flags, int exflags) |
| 428 | 2222 { |
| 2223 /* this function can call lisp */ | |
| 440 | 2224 Lisp_Image_Instance *ii = XIMAGE_INSTANCE (image_instance); |
| 428 | 2225 Lisp_Object device = IMAGE_INSTANCE_DEVICE (ii), style; |
| 442 | 2226 Lisp_Object frame = DOMAIN_FRAME (domain); |
| 771 | 2227 Extbyte *nm = 0; |
| 2228 Extbyte *classext; | |
| 428 | 2229 HWND wnd; |
| 2230 int id = 0xffff; | |
| 2231 Lisp_Object gui = IMAGE_INSTANCE_WIDGET_ITEM (ii); | |
| 771 | 2232 Lisp_Gui_Item *pgui = XGUI_ITEM (gui); |
| 428 | 2233 |
| 442 | 2234 CHECK_MSWINDOWS_DEVICE (device); |
| 428 | 2235 |
| 1913 | 2236 if (!gui_item_active_p (gui)) |
| 428 | 2237 flags |= WS_DISABLED; |
| 2238 | |
| 2239 style = pgui->style; | |
| 2240 | |
| 442 | 2241 if (!NILP (pgui->callback) || !NILP (pgui->callback_ex)) |
| 428 | 2242 { |
| 2243 id = mswindows_register_widget_instance (image_instance, domain); | |
| 2244 } | |
| 438 | 2245 |
| 428 | 2246 if (!NILP (IMAGE_INSTANCE_WIDGET_TEXT (ii))) |
|
4981
4aebb0131297
Cleanups/renaming of EXTERNAL_TO_C_STRING and friends
Ben Wing <ben@xemacs.org>
parents:
4952
diff
changeset
|
2247 nm = LISP_STRING_TO_TSTR (IMAGE_INSTANCE_WIDGET_TEXT (ii)); |
| 428 | 2248 |
| 2249 /* allocate space for the clip window and then allocate the clip window */ | |
| 2250 ii->data = xnew_and_zero (struct mswindows_subwindow_data); | |
| 2251 | |
| 2252 if ((IMAGE_INSTANCE_MSWINDOWS_CLIPWINDOW (ii) | |
| 771 | 2253 = qxeCreateWindowEx (WS_EX_CONTROLPARENT, /* EX flags */ |
| 2254 XETEXT (XEMACS_CONTROL_CLASS), | |
| 2255 0, /* text */ | |
| 2256 WS_CLIPCHILDREN | WS_CLIPSIBLINGS | WS_CHILD, | |
| 428 | 2257 0, /* starting x position */ |
| 2258 0, /* starting y position */ | |
| 2259 IMAGE_INSTANCE_WIDGET_WIDTH (ii), | |
| 2260 IMAGE_INSTANCE_WIDGET_HEIGHT (ii), | |
| 2261 /* parent window */ | |
| 771 | 2262 DOMAIN_MSWINDOWS_HANDLE (domain), |
| 428 | 2263 (HMENU)id, /* No menu */ |
| 771 | 2264 NULL, /* must be null for this class */ |
| 428 | 2265 NULL)) == NULL) |
| 563 | 2266 gui_error ("window creation failed with code", |
| 2267 make_int (GetLastError())); | |
| 428 | 2268 |
|
4981
4aebb0131297
Cleanups/renaming of EXTERNAL_TO_C_STRING and friends
Ben Wing <ben@xemacs.org>
parents:
4952
diff
changeset
|
2269 classext = ITEXT_TO_TSTR (class_); |
| 771 | 2270 |
| 2271 if ((wnd = qxeCreateWindowEx (exflags /* | WS_EX_NOPARENTNOTIFY*/, | |
| 2272 classext, | |
| 2273 nm, | |
| 2274 flags | WS_CHILD | WS_VISIBLE, | |
| 2275 0, /* starting x position */ | |
| 2276 0, /* starting y position */ | |
| 2277 IMAGE_INSTANCE_WIDGET_WIDTH (ii), | |
| 2278 IMAGE_INSTANCE_WIDGET_HEIGHT (ii), | |
| 2279 /* parent window */ | |
| 2280 IMAGE_INSTANCE_MSWINDOWS_CLIPWINDOW (ii), | |
| 2281 (HMENU)id, /* No menu */ | |
| 2282 (HINSTANCE) | |
| 2283 qxeGetWindowLong | |
| 2284 (FRAME_MSWINDOWS_HANDLE (XFRAME (frame)), | |
| 2285 GWL_HINSTANCE), | |
| 2286 NULL)) == NULL) | |
| 2287 gui_error ("window creation failed with code", | |
| 2288 make_int (GetLastError())); | |
| 2289 | |
| 428 | 2290 IMAGE_INSTANCE_SUBWINDOW_ID (ii) = wnd; |
| 5013 | 2291 qxeSetWindowLong (wnd, GWL_USERDATA, (LONG)STORE_LISP_IN_VOID(image_instance)); |
| 428 | 2292 /* set the widget font from the widget face */ |
| 442 | 2293 if (!NILP (IMAGE_INSTANCE_WIDGET_TEXT (ii))) |
| 771 | 2294 qxeSendMessage (wnd, WM_SETFONT, |
| 2295 (WPARAM) mswindows_widget_hfont | |
| 2296 (IMAGE_INSTANCE_WIDGET_FACE (ii), domain, | |
| 2297 IMAGE_INSTANCE_WIDGET_TEXT (ii)), | |
| 2298 MAKELPARAM (TRUE, 0)); | |
| 442 | 2299 } |
| 2300 | |
| 2301 /* Instantiate a native layout widget. */ | |
| 2302 static void | |
| 2303 mswindows_native_layout_instantiate (Lisp_Object image_instance, | |
| 2304 Lisp_Object instantiator, | |
| 502 | 2305 Lisp_Object pointer_fg, |
| 2306 Lisp_Object pointer_bg, | |
| 442 | 2307 int dest_mask, Lisp_Object domain) |
| 2308 { | |
| 2309 Lisp_Image_Instance *ii = XIMAGE_INSTANCE (image_instance); | |
| 2310 | |
| 2311 mswindows_widget_instantiate (image_instance, instantiator, pointer_fg, | |
| 2312 pointer_bg, dest_mask, domain, "STATIC", | |
| 2313 /* Approximation to styles available with | |
| 2314 an XEmacs layout. */ | |
| 2315 (EQ (IMAGE_INSTANCE_LAYOUT_BORDER (ii), | |
| 2316 Qetched_in) || | |
| 2317 EQ (IMAGE_INSTANCE_LAYOUT_BORDER (ii), | |
| 2318 Qetched_out) || | |
| 2319 GLYPHP (IMAGE_INSTANCE_LAYOUT_BORDER (ii)) | |
| 2320 ? SS_ETCHEDFRAME : SS_SUNKEN) | DS_CONTROL, | |
| 2321 0); | |
| 428 | 2322 } |
| 2323 | |
| 2324 /* Instantiate a button widget. Unfortunately instantiated widgets are | |
| 2325 particular to a frame since they need to have a parent. It's not | |
| 2326 like images where you just select the image into the context you | |
| 438 | 2327 want to display it in and BitBlt it. So image instances can have a |
| 428 | 2328 many-to-one relationship with things you see, whereas widgets can |
| 2329 only be one-to-one (i.e. per frame) */ | |
| 2330 static void | |
| 502 | 2331 mswindows_button_instantiate (Lisp_Object image_instance, |
| 2332 Lisp_Object instantiator, | |
| 428 | 2333 Lisp_Object pointer_fg, Lisp_Object pointer_bg, |
| 2334 int dest_mask, Lisp_Object domain) | |
| 2335 { | |
| 442 | 2336 /* This function can call lisp */ |
| 440 | 2337 Lisp_Image_Instance *ii = XIMAGE_INSTANCE (image_instance); |
| 428 | 2338 HWND wnd; |
| 444 | 2339 int flags = WS_TABSTOP | BS_NOTIFY; |
| 2340 /* BS_NOTIFY #### is needed to get exotic feedback only. Since we | |
| 2341 seem to want nothing beyond BN_CLICK, the style is perhaps not | |
| 2342 necessary -- kkm */ | |
| 428 | 2343 Lisp_Object style; |
| 2344 Lisp_Object gui = IMAGE_INSTANCE_WIDGET_ITEM (ii); | |
| 771 | 2345 Lisp_Gui_Item *pgui = XGUI_ITEM (gui); |
| 428 | 2346 Lisp_Object glyph = find_keyword_in_vector (instantiator, Q_image); |
| 2347 | |
| 2348 if (!NILP (glyph)) | |
| 2349 { | |
| 2350 if (!IMAGE_INSTANCEP (glyph)) | |
| 2351 glyph = glyph_image_instance (glyph, domain, ERROR_ME, 1); | |
| 2352 | |
| 2353 if (IMAGE_INSTANCEP (glyph)) | |
| 434 | 2354 flags |= XIMAGE_INSTANCE_MSWINDOWS_BITMAP (glyph) ? |
| 428 | 2355 BS_BITMAP : BS_ICON; |
| 2356 } | |
| 2357 | |
| 2358 style = pgui->style; | |
| 2359 | |
| 438 | 2360 /* #### consider using the default face for radio and toggle |
| 2361 buttons. */ | |
| 428 | 2362 if (EQ (style, Qradio)) |
| 2363 { | |
| 2364 flags |= BS_RADIOBUTTON; | |
| 2365 } | |
| 2366 else if (EQ (style, Qtoggle)) | |
| 2367 { | |
| 2368 flags |= BS_AUTOCHECKBOX; | |
| 2369 } | |
| 2370 else | |
| 438 | 2371 { |
| 2372 flags |= BS_DEFPUSHBUTTON; | |
| 2373 } | |
| 428 | 2374 |
| 2375 mswindows_widget_instantiate (image_instance, instantiator, pointer_fg, | |
| 771 | 2376 pointer_bg, dest_mask, domain, |
| 2377 "BUTTON", flags, 0); | |
| 428 | 2378 |
| 2379 wnd = WIDGET_INSTANCE_MSWINDOWS_HANDLE (ii); | |
| 2380 /* set the checked state */ | |
| 1913 | 2381 if (gui_item_selected_p (gui)) |
| 771 | 2382 qxeSendMessage (wnd, BM_SETCHECK, (WPARAM)BST_CHECKED, 0); |
| 428 | 2383 else |
| 771 | 2384 qxeSendMessage (wnd, BM_SETCHECK, (WPARAM)BST_UNCHECKED, 0); |
| 428 | 2385 /* add the image if one was given */ |
| 440 | 2386 if (!NILP (glyph) && IMAGE_INSTANCEP (glyph) |
| 2387 && | |
| 2388 IMAGE_INSTANCE_PIXMAP_TYPE_P (XIMAGE_INSTANCE (glyph))) | |
| 428 | 2389 { |
| 771 | 2390 qxeSendMessage (wnd, BM_SETIMAGE, |
| 2391 (WPARAM) (XIMAGE_INSTANCE_MSWINDOWS_BITMAP (glyph) ? | |
| 2392 IMAGE_BITMAP : IMAGE_ICON), | |
| 2393 (XIMAGE_INSTANCE_MSWINDOWS_BITMAP (glyph) ? | |
| 2394 (LPARAM) XIMAGE_INSTANCE_MSWINDOWS_BITMAP (glyph) : | |
| 2395 (LPARAM) XIMAGE_INSTANCE_MSWINDOWS_ICON (glyph))); | |
| 428 | 2396 } |
| 2397 } | |
| 2398 | |
| 442 | 2399 /* Update the state of a button. */ |
| 2400 static void | |
| 2401 mswindows_button_redisplay (Lisp_Object image_instance) | |
| 2402 { | |
| 2403 /* This function can GC if IN_REDISPLAY is false. */ | |
| 2404 Lisp_Image_Instance *ii = XIMAGE_INSTANCE (image_instance); | |
| 2405 | |
| 2406 /* buttons checked or otherwise */ | |
| 1913 | 2407 if (gui_item_selected_p (IMAGE_INSTANCE_WIDGET_ITEM (ii))) |
| 771 | 2408 qxeSendMessage (WIDGET_INSTANCE_MSWINDOWS_HANDLE (ii), |
| 2409 BM_SETCHECK, (WPARAM)BST_CHECKED, 0); | |
| 442 | 2410 else |
| 771 | 2411 qxeSendMessage (WIDGET_INSTANCE_MSWINDOWS_HANDLE (ii), |
| 2412 BM_SETCHECK, (WPARAM)BST_UNCHECKED, 0); | |
| 442 | 2413 } |
| 2414 | |
| 428 | 2415 /* instantiate an edit control */ |
| 2416 static void | |
| 502 | 2417 mswindows_edit_field_instantiate (Lisp_Object image_instance, |
| 2418 Lisp_Object instantiator, | |
| 2419 Lisp_Object pointer_fg, | |
| 2420 Lisp_Object pointer_bg, | |
| 2421 int dest_mask, Lisp_Object domain) | |
| 428 | 2422 { |
| 2423 mswindows_widget_instantiate (image_instance, instantiator, pointer_fg, | |
| 434 | 2424 pointer_bg, dest_mask, domain, "EDIT", |
| 428 | 2425 ES_LEFT | ES_AUTOHSCROLL | WS_TABSTOP |
| 438 | 2426 | WS_BORDER, WS_EX_CLIENTEDGE); |
| 428 | 2427 } |
| 2428 | |
| 2429 /* instantiate a progress gauge */ | |
| 2430 static void | |
| 502 | 2431 mswindows_progress_gauge_instantiate (Lisp_Object image_instance, |
| 2432 Lisp_Object instantiator, | |
| 2433 Lisp_Object pointer_fg, | |
| 2434 Lisp_Object pointer_bg, | |
| 2435 int dest_mask, Lisp_Object domain) | |
| 428 | 2436 { |
| 2437 HWND wnd; | |
| 440 | 2438 Lisp_Image_Instance *ii = XIMAGE_INSTANCE (image_instance); |
| 442 | 2439 Lisp_Object val; |
| 428 | 2440 mswindows_widget_instantiate (image_instance, instantiator, pointer_fg, |
| 434 | 2441 pointer_bg, dest_mask, domain, PROGRESS_CLASS, |
| 438 | 2442 WS_BORDER | PBS_SMOOTH, WS_EX_CLIENTEDGE); |
| 428 | 2443 wnd = WIDGET_INSTANCE_MSWINDOWS_HANDLE (ii); |
| 2444 /* set the colors */ | |
| 502 | 2445 #if 0 /* #### fix this */ |
| 771 | 2446 qxeSendMessage (wnd, PBM_SETBKCOLOR, 0, |
| 2447 (LPARAM) (COLOR_INSTANCE_MSWINDOWS_COLOR | |
| 2448 (XCOLOR_INSTANCE | |
| 2449 (FACE_BACKGROUND | |
| 2450 (XIMAGE_INSTANCE_WIDGET_FACE (ii), | |
| 2451 XIMAGE_INSTANCE_FRAME (ii)))))); | |
| 2452 qxeSendMessage (wnd, PBM_SETBARCOLOR, 0, | |
| 2453 (LPARAM) (COLOR_INSTANCE_MSWINDOWS_COLOR | |
| 2454 (XCOLOR_INSTANCE | |
| 2455 (FACE_FOREGROUND | |
| 2456 (XIMAGE_INSTANCE_WIDGET_FACE (ii), | |
| 2457 XIMAGE_INSTANCE_FRAME (ii)))))); | |
| 428 | 2458 #endif |
| 442 | 2459 val = XGUI_ITEM (IMAGE_INSTANCE_WIDGET_ITEMS (ii))->value; |
| 2460 CHECK_INT (val); | |
| 771 | 2461 qxeSendMessage (WIDGET_INSTANCE_MSWINDOWS_HANDLE (ii), |
| 2462 PBM_SETPOS, (WPARAM)XINT (val), 0); | |
| 428 | 2463 } |
| 2464 | |
| 2465 /* instantiate a tree view widget */ | |
| 2466 static HTREEITEM add_tree_item (Lisp_Object image_instance, | |
| 2467 HWND wnd, HTREEITEM parent, Lisp_Object item, | |
| 2468 int children, Lisp_Object domain) | |
| 2469 { | |
| 2470 HTREEITEM ret; | |
| 771 | 2471 TV_INSERTSTRUCTW tvitem; |
| 428 | 2472 |
| 2473 tvitem.hParent = parent; | |
| 2474 tvitem.hInsertAfter = TVI_LAST; | |
| 2475 tvitem.item.mask = TVIF_TEXT | TVIF_CHILDREN; | |
| 2476 tvitem.item.cChildren = children; | |
| 771 | 2477 |
| 428 | 2478 if (GUI_ITEMP (item)) |
| 2479 { | |
| 771 | 2480 tvitem.item.lParam = |
| 2481 mswindows_register_gui_item (image_instance, item, domain); | |
| 428 | 2482 tvitem.item.mask |= TVIF_PARAM; |
|
4981
4aebb0131297
Cleanups/renaming of EXTERNAL_TO_C_STRING and friends
Ben Wing <ben@xemacs.org>
parents:
4952
diff
changeset
|
2483 tvitem.item.pszText = |
|
4aebb0131297
Cleanups/renaming of EXTERNAL_TO_C_STRING and friends
Ben Wing <ben@xemacs.org>
parents:
4952
diff
changeset
|
2484 (LPWSTR) LISP_STRING_TO_TSTR (XGUI_ITEM (item)->name); |
| 428 | 2485 } |
| 2486 else | |
|
4981
4aebb0131297
Cleanups/renaming of EXTERNAL_TO_C_STRING and friends
Ben Wing <ben@xemacs.org>
parents:
4952
diff
changeset
|
2487 tvitem.item.pszText = (LPWSTR) LISP_STRING_TO_TSTR (item); |
| 771 | 2488 |
| 2421 | 2489 tvitem.item.cchTextMax = qxetcslen ((Extbyte *) tvitem.item.pszText); |
| 771 | 2490 |
| 2491 if ((ret = (HTREEITEM) qxeSendMessage (wnd, TVM_INSERTITEM, | |
| 2492 0, (LPARAM) &tvitem)) == 0) | |
| 563 | 2493 gui_error ("error adding tree view entry", item); |
| 428 | 2494 |
| 2495 return ret; | |
| 2496 } | |
| 2497 | |
| 2498 static void add_tree_item_list (Lisp_Object image_instance, | |
| 2499 HWND wnd, HTREEITEM parent, Lisp_Object list, | |
| 2500 Lisp_Object domain) | |
| 2501 { | |
| 2502 Lisp_Object rest; | |
| 2503 | |
| 2504 /* get the first item */ | |
| 2505 parent = add_tree_item (image_instance, wnd, parent, XCAR (list), TRUE, domain); | |
| 2506 /* recursively add items to the tree view */ | |
| 2507 LIST_LOOP (rest, XCDR (list)) | |
| 2508 { | |
| 2509 if (LISTP (XCAR (rest))) | |
| 2510 add_tree_item_list (image_instance, wnd, parent, XCAR (rest), domain); | |
| 2511 else | |
| 2512 add_tree_item (image_instance, wnd, parent, XCAR (rest), FALSE, domain); | |
| 2513 } | |
| 2514 } | |
| 2515 | |
| 2516 static void | |
| 502 | 2517 mswindows_tree_view_instantiate (Lisp_Object image_instance, |
| 2518 Lisp_Object instantiator, | |
| 2519 Lisp_Object pointer_fg, | |
| 2520 Lisp_Object pointer_bg, | |
| 2521 int dest_mask, Lisp_Object domain) | |
| 428 | 2522 { |
| 2523 Lisp_Object rest; | |
| 2524 HWND wnd; | |
| 2525 HTREEITEM parent; | |
| 440 | 2526 Lisp_Image_Instance *ii = XIMAGE_INSTANCE (image_instance); |
| 428 | 2527 mswindows_widget_instantiate (image_instance, instantiator, pointer_fg, |
| 434 | 2528 pointer_bg, dest_mask, domain, WC_TREEVIEW, |
| 428 | 2529 WS_TABSTOP | WS_BORDER | PBS_SMOOTH |
| 2530 | TVS_HASLINES | TVS_HASBUTTONS, | |
| 438 | 2531 WS_EX_CLIENTEDGE); |
| 428 | 2532 |
| 2533 wnd = WIDGET_INSTANCE_MSWINDOWS_HANDLE (ii); | |
| 434 | 2534 |
| 428 | 2535 /* define a root */ |
| 434 | 2536 parent = add_tree_item (image_instance, wnd, NULL, |
| 2537 XCAR (IMAGE_INSTANCE_WIDGET_ITEMS (ii)), | |
| 428 | 2538 TRUE, domain); |
| 434 | 2539 |
| 428 | 2540 /* recursively add items to the tree view */ |
| 2541 /* add items to the tab */ | |
| 2542 LIST_LOOP (rest, XCDR (IMAGE_INSTANCE_WIDGET_ITEMS (ii))) | |
| 2543 { | |
| 2544 if (LISTP (XCAR (rest))) | |
| 2545 add_tree_item_list (image_instance, wnd, parent, XCAR (rest), domain); | |
| 2546 else | |
| 2547 add_tree_item (image_instance, wnd, parent, XCAR (rest), FALSE, domain); | |
| 2548 } | |
| 2549 } | |
| 2550 | |
| 442 | 2551 /* Set the properties of a tree view. */ |
| 2552 static void | |
| 2553 mswindows_tree_view_redisplay (Lisp_Object image_instance) | |
| 2554 { | |
| 2555 /* This function can GC if IN_REDISPLAY is false. */ | |
| 2556 Lisp_Image_Instance *ii = XIMAGE_INSTANCE (image_instance); | |
| 2557 | |
| 2558 if (IMAGE_INSTANCE_WIDGET_ITEMS_CHANGED (ii)) | |
| 2559 { | |
| 2560 HWND wnd = WIDGET_INSTANCE_MSWINDOWS_HANDLE (ii); | |
| 2561 Lisp_Object rest; | |
| 2562 HTREEITEM parent; | |
| 2563 /* Delete previous items. */ | |
| 771 | 2564 qxeSendMessage (wnd, TVM_DELETEITEM, 0, (LPARAM)TVI_ROOT); |
| 442 | 2565 /* define a root */ |
| 2566 parent = add_tree_item (image_instance, wnd, NULL, | |
| 2567 XCAR (IMAGE_INSTANCE_WIDGET_PENDING_ITEMS (ii)), | |
| 2568 TRUE, IMAGE_INSTANCE_DOMAIN (ii)); | |
| 2569 | |
| 2570 /* recursively add items to the tree view */ | |
| 2571 /* add items to the tab */ | |
| 2572 LIST_LOOP (rest, XCDR (IMAGE_INSTANCE_WIDGET_PENDING_ITEMS (ii))) | |
| 2573 { | |
| 2574 if (LISTP (XCAR (rest))) | |
| 2575 add_tree_item_list (image_instance, wnd, parent, XCAR (rest), | |
| 2576 IMAGE_INSTANCE_DOMAIN (ii)); | |
| 2577 else | |
| 2578 add_tree_item (image_instance, wnd, parent, XCAR (rest), FALSE, | |
| 2579 IMAGE_INSTANCE_DOMAIN (ii)); | |
| 2580 } | |
| 2581 } | |
| 2582 } | |
| 2583 | |
| 428 | 2584 /* instantiate a tab control */ |
| 442 | 2585 static int |
| 2586 add_tab_item (Lisp_Object image_instance, | |
| 2587 HWND wnd, Lisp_Object item, | |
| 2588 Lisp_Object domain, int i) | |
| 428 | 2589 { |
| 771 | 2590 TC_ITEMW tcitem; |
| 442 | 2591 int ret = 0; |
| 428 | 2592 |
| 771 | 2593 tcitem.mask = TCIF_TEXT; |
| 434 | 2594 |
| 428 | 2595 if (GUI_ITEMP (item)) |
| 2596 { | |
| 771 | 2597 tcitem.lParam = |
| 2598 mswindows_register_gui_item (image_instance, item, domain); | |
| 2599 tcitem.mask |= TCIF_PARAM; | |
|
4981
4aebb0131297
Cleanups/renaming of EXTERNAL_TO_C_STRING and friends
Ben Wing <ben@xemacs.org>
parents:
4952
diff
changeset
|
2600 tcitem.pszText = (XELPTSTR) LISP_STRING_TO_TSTR (XGUI_ITEM (item)->name); |
| 428 | 2601 } |
| 2602 else | |
| 2603 { | |
| 2604 CHECK_STRING (item); | |
|
4981
4aebb0131297
Cleanups/renaming of EXTERNAL_TO_C_STRING and friends
Ben Wing <ben@xemacs.org>
parents:
4952
diff
changeset
|
2605 tcitem.pszText = (XELPTSTR) LISP_STRING_TO_TSTR (item); |
| 428 | 2606 } |
| 2607 | |
| 2421 | 2608 tcitem.cchTextMax = qxetcslen ((Extbyte *) tcitem.pszText); |
| 771 | 2609 |
| 2610 if ((ret = qxeSendMessage (wnd, TCM_INSERTITEM, i, (LPARAM) &tcitem)) < 0) | |
| 563 | 2611 gui_error ("error adding tab entry", item); |
| 428 | 2612 |
| 2613 return ret; | |
| 2614 } | |
| 2615 | |
| 2616 static void | |
| 502 | 2617 mswindows_tab_control_instantiate (Lisp_Object image_instance, |
| 2618 Lisp_Object instantiator, | |
| 2619 Lisp_Object pointer_fg, | |
| 2620 Lisp_Object pointer_bg, | |
| 2621 int dest_mask, Lisp_Object domain) | |
| 428 | 2622 { |
| 442 | 2623 /* This function can call lisp */ |
| 428 | 2624 Lisp_Object rest; |
| 2625 HWND wnd; | |
| 442 | 2626 int i = 0, selected = 0; |
| 440 | 2627 Lisp_Image_Instance *ii = XIMAGE_INSTANCE (image_instance); |
| 438 | 2628 Lisp_Object orient = find_keyword_in_vector (instantiator, Q_orientation); |
| 2629 unsigned int flags = WS_TABSTOP; | |
| 2630 | |
| 2631 if (EQ (orient, Qleft) || EQ (orient, Qright)) | |
| 2632 { | |
| 2633 flags |= TCS_VERTICAL | TCS_MULTILINE; | |
| 2634 } | |
| 2635 if (EQ (orient, Qright) || EQ (orient, Qbottom)) | |
| 2636 { | |
| 2637 flags |= TCS_BOTTOM; | |
| 2638 } | |
| 2639 | |
| 428 | 2640 mswindows_widget_instantiate (image_instance, instantiator, pointer_fg, |
| 434 | 2641 pointer_bg, dest_mask, domain, WC_TABCONTROL, |
| 428 | 2642 /* borders don't suit tabs so well */ |
| 438 | 2643 flags, 0); |
| 428 | 2644 wnd = WIDGET_INSTANCE_MSWINDOWS_HANDLE (ii); |
| 2645 /* add items to the tab */ | |
| 2646 LIST_LOOP (rest, XCDR (IMAGE_INSTANCE_WIDGET_ITEMS (ii))) | |
| 2647 { | |
| 442 | 2648 int idx = add_tab_item (image_instance, wnd, XCAR (rest), domain, i); |
| 2649 assert (idx == i); | |
| 1913 | 2650 if (gui_item_selected_p (XCAR (rest))) |
| 442 | 2651 selected = i; |
| 438 | 2652 i++; |
| 428 | 2653 } |
| 771 | 2654 qxeSendMessage (wnd, TCM_SETCURSEL, selected, 0); |
| 428 | 2655 } |
| 2656 | |
| 442 | 2657 /* Set the properties of a tab control. */ |
| 2658 static void | |
| 2659 mswindows_tab_control_redisplay (Lisp_Object image_instance) | |
| 428 | 2660 { |
| 442 | 2661 /* This function can GC if IN_REDISPLAY is false. */ |
| 440 | 2662 Lisp_Image_Instance *ii = XIMAGE_INSTANCE (image_instance); |
| 442 | 2663 #ifdef DEBUG_WIDGET_OUTPUT |
| 1318 | 2664 stderr_out ("tab control %p redisplayed\n", |
| 2665 IMAGE_INSTANCE_SUBWINDOW_ID (ii)); | |
| 442 | 2666 #endif |
| 2667 if (IMAGE_INSTANCE_WIDGET_ITEMS_CHANGED (ii) | |
| 2668 || | |
| 2669 IMAGE_INSTANCE_WIDGET_ACTION_OCCURRED (ii)) | |
| 428 | 2670 { |
| 2671 HWND wnd = WIDGET_INSTANCE_MSWINDOWS_HANDLE (ii); | |
| 454 | 2672 int i = 0, selected_idx = 0; |
| 428 | 2673 Lisp_Object rest; |
| 442 | 2674 |
| 2675 assert (!NILP (IMAGE_INSTANCE_WIDGET_ITEMS (ii))); | |
| 2676 | |
| 2677 /* If only the order has changed then simply select the first | |
| 2678 one. This stops horrendous rebuilding of the tabs each time | |
| 2679 you click on one. */ | |
| 2680 if (tab_control_order_only_changed (image_instance)) | |
| 428 | 2681 { |
| 442 | 2682 Lisp_Object selected = |
| 2683 gui_item_list_find_selected | |
| 2684 (NILP (IMAGE_INSTANCE_WIDGET_PENDING_ITEMS (ii)) ? | |
| 2685 XCDR (IMAGE_INSTANCE_WIDGET_ITEMS (ii)) : | |
| 2686 XCDR (IMAGE_INSTANCE_WIDGET_PENDING_ITEMS (ii))); | |
| 2687 | |
| 2688 LIST_LOOP (rest, XCDR (IMAGE_INSTANCE_WIDGET_ITEMS (ii))) | |
| 2689 { | |
| 1913 | 2690 if (gui_item_equal_sans_selected (XCAR (rest), selected, 0)) |
| 442 | 2691 { |
| 1318 | 2692 Lisp_Object old_selected = |
| 2693 gui_item_list_find_selected | |
| 442 | 2694 (XCDR (IMAGE_INSTANCE_WIDGET_ITEMS (ii))); |
| 2695 | |
| 2696 /* Pick up the new selected item. */ | |
| 2697 XGUI_ITEM (old_selected)->selected = | |
| 2698 XGUI_ITEM (XCAR (rest))->selected; | |
| 2699 XGUI_ITEM (XCAR (rest))->selected = | |
| 2700 XGUI_ITEM (selected)->selected; | |
| 2701 /* We're not actually changing the items. */ | |
| 2702 IMAGE_INSTANCE_WIDGET_ITEMS_CHANGED (ii) = 0; | |
| 2703 IMAGE_INSTANCE_WIDGET_PENDING_ITEMS (ii) = Qnil; | |
| 2704 | |
| 771 | 2705 qxeSendMessage (wnd, TCM_SETCURSEL, i, 0); |
| 442 | 2706 #ifdef DEBUG_WIDGET_OUTPUT |
| 2707 stderr_out ("tab control %p selected item %d\n", | |
| 1318 | 2708 IMAGE_INSTANCE_SUBWINDOW_ID (ii), i); |
| 442 | 2709 #endif |
| 2710 break; | |
| 2711 } | |
| 2712 i++; | |
| 2713 } | |
| 428 | 2714 } |
| 442 | 2715 else |
| 2716 { | |
| 2717 /* delete the pre-existing items */ | |
| 771 | 2718 qxeSendMessage (wnd, TCM_DELETEALLITEMS, 0, 0); |
| 442 | 2719 |
| 2720 /* add items to the tab */ | |
| 2721 LIST_LOOP (rest, XCDR (IMAGE_INSTANCE_WIDGET_PENDING_ITEMS (ii))) | |
| 2722 { | |
| 2723 add_tab_item (image_instance, wnd, XCAR (rest), | |
| 2724 IMAGE_INSTANCE_FRAME (ii), i); | |
| 1913 | 2725 if (gui_item_selected_p (XCAR (rest))) |
| 454 | 2726 selected_idx = i; |
| 442 | 2727 i++; |
| 2728 } | |
| 771 | 2729 qxeSendMessage (wnd, TCM_SETCURSEL, selected_idx, 0); |
| 442 | 2730 } |
| 428 | 2731 } |
| 2732 } | |
| 2733 | |
| 2734 /* instantiate a static control possible for putting other things in */ | |
| 2735 static void | |
| 502 | 2736 mswindows_label_instantiate (Lisp_Object image_instance, |
| 2737 Lisp_Object instantiator, | |
| 428 | 2738 Lisp_Object pointer_fg, Lisp_Object pointer_bg, |
| 2739 int dest_mask, Lisp_Object domain) | |
| 2740 { | |
| 2741 mswindows_widget_instantiate (image_instance, instantiator, pointer_fg, | |
| 771 | 2742 pointer_bg, dest_mask, domain, |
| 2743 "STATIC", 0, WS_EX_STATICEDGE); | |
| 428 | 2744 } |
| 2745 | |
| 2746 /* instantiate a scrollbar control */ | |
| 2747 static void | |
| 502 | 2748 mswindows_scrollbar_instantiate (Lisp_Object image_instance, |
| 2749 Lisp_Object instantiator, | |
| 2750 Lisp_Object pointer_fg, | |
| 2751 Lisp_Object pointer_bg, | |
| 428 | 2752 int dest_mask, Lisp_Object domain) |
| 2753 { | |
| 2754 mswindows_widget_instantiate (image_instance, instantiator, pointer_fg, | |
| 771 | 2755 pointer_bg, dest_mask, domain, |
| 2756 "SCROLLBAR", WS_TABSTOP, WS_EX_CLIENTEDGE); | |
| 428 | 2757 } |
| 2758 | |
| 2759 /* instantiate a combo control */ | |
| 2760 static void | |
| 502 | 2761 mswindows_combo_box_instantiate (Lisp_Object image_instance, |
| 2762 Lisp_Object instantiator, | |
| 2763 Lisp_Object pointer_fg, | |
| 2764 Lisp_Object pointer_bg, | |
| 2765 int dest_mask, Lisp_Object domain) | |
| 428 | 2766 { |
| 440 | 2767 Lisp_Image_Instance *ii = XIMAGE_INSTANCE (image_instance); |
| 442 | 2768 HWND wnd; |
| 428 | 2769 Lisp_Object rest; |
| 442 | 2770 Lisp_Object items = find_keyword_in_vector (instantiator, Q_items); |
| 438 | 2771 int len, height; |
| 428 | 2772 |
| 2773 /* Maybe ought to generalise this more but it may be very windows | |
| 2774 specific. In windows the window height of a combo box is the | |
| 2775 height when the combo box is open. Thus we need to set the height | |
| 2776 before creating the window and then reset it to a single line | |
| 2777 after the window is created so that redisplay does the right | |
| 2778 thing. */ | |
| 438 | 2779 widget_instantiate (image_instance, instantiator, pointer_fg, |
| 2780 pointer_bg, dest_mask, domain); | |
| 2781 | |
| 2782 /* We now have everything right apart from the height. */ | |
|
5047
07dcc7000bbf
put width before height consistently, fix a real bug found in the process
Ben Wing <ben@xemacs.org>
parents:
5013
diff
changeset
|
2783 default_face_font_info (domain, 0, 0, 0, &height, 0); |
| 442 | 2784 GET_LIST_LENGTH (items, len); |
| 438 | 2785 |
| 863 | 2786 height = (height + DEFAULT_WIDGET_BORDER_WIDTH * 2 ) * len; |
| 438 | 2787 IMAGE_INSTANCE_HEIGHT (ii) = height; |
| 440 | 2788 |
| 438 | 2789 /* Now create the widget. */ |
| 428 | 2790 mswindows_widget_instantiate (image_instance, instantiator, pointer_fg, |
| 771 | 2791 pointer_bg, dest_mask, domain, |
| 2792 "COMBOBOX", | |
| 428 | 2793 WS_BORDER | WS_TABSTOP | CBS_DROPDOWN |
| 434 | 2794 | CBS_AUTOHSCROLL |
| 428 | 2795 | CBS_HASSTRINGS | WS_VSCROLL, |
| 438 | 2796 WS_EX_CLIENTEDGE); |
| 2797 /* Reset the height. layout will probably do this safely, but better make sure. */ | |
| 440 | 2798 image_instance_layout (image_instance, |
| 438 | 2799 IMAGE_UNSPECIFIED_GEOMETRY, |
| 2800 IMAGE_UNSPECIFIED_GEOMETRY, | |
| 442 | 2801 IMAGE_UNCHANGED_GEOMETRY, |
| 2802 IMAGE_UNCHANGED_GEOMETRY, | |
| 438 | 2803 domain); |
| 2804 | |
| 428 | 2805 wnd = WIDGET_INSTANCE_MSWINDOWS_HANDLE (ii); |
| 2806 /* add items to the combo box */ | |
| 771 | 2807 qxeSendMessage (wnd, CB_RESETCONTENT, 0, 0); |
| 442 | 2808 LIST_LOOP (rest, items) |
| 428 | 2809 { |
| 771 | 2810 Extbyte *lparam; |
|
4981
4aebb0131297
Cleanups/renaming of EXTERNAL_TO_C_STRING and friends
Ben Wing <ben@xemacs.org>
parents:
4952
diff
changeset
|
2811 lparam = LISP_STRING_TO_TSTR (XCAR (rest)); |
| 771 | 2812 if (qxeSendMessage (wnd, CB_ADDSTRING, 0, (LPARAM)lparam) == CB_ERR) |
| 563 | 2813 gui_error ("error adding combo entries", instantiator); |
| 428 | 2814 } |
| 2815 } | |
| 2816 | |
| 2817 /* get properties of a control */ | |
| 2818 static Lisp_Object | |
| 2819 mswindows_widget_property (Lisp_Object image_instance, Lisp_Object prop) | |
| 2820 { | |
| 440 | 2821 Lisp_Image_Instance *ii = XIMAGE_INSTANCE (image_instance); |
| 442 | 2822 HWND wnd = WIDGET_INSTANCE_MSWINDOWS_HANDLE (ii); |
| 428 | 2823 /* get the text from a control */ |
| 2824 if (EQ (prop, Q_text)) | |
| 2825 { | |
| 771 | 2826 Charcount tchar_len = qxeSendMessage (wnd, WM_GETTEXTLENGTH, 0, 0); |
| 2367 | 2827 Extbyte *buf = alloca_extbytes (XETCHAR_SIZE * (tchar_len + 1)); |
| 771 | 2828 |
| 2829 qxeSendMessage (wnd, WM_GETTEXT, (WPARAM)tchar_len + 1, (LPARAM) buf); | |
| 2830 return build_tstr_string (buf); | |
| 428 | 2831 } |
| 2832 return Qunbound; | |
| 2833 } | |
| 2834 | |
| 2835 /* get properties of a button */ | |
| 2836 static Lisp_Object | |
| 2837 mswindows_button_property (Lisp_Object image_instance, Lisp_Object prop) | |
| 2838 { | |
| 440 | 2839 Lisp_Image_Instance *ii = XIMAGE_INSTANCE (image_instance); |
| 442 | 2840 HWND wnd = WIDGET_INSTANCE_MSWINDOWS_HANDLE (ii); |
| 428 | 2841 /* check the state of a button */ |
| 2842 if (EQ (prop, Q_selected)) | |
| 2843 { | |
| 771 | 2844 if (qxeSendMessage (wnd, BM_GETSTATE, 0, 0) & BST_CHECKED) |
| 428 | 2845 return Qt; |
| 2846 else | |
| 2847 return Qnil; | |
| 2848 } | |
| 2849 return Qunbound; | |
| 2850 } | |
| 2851 | |
| 2852 /* get properties of a combo box */ | |
| 2853 static Lisp_Object | |
| 2854 mswindows_combo_box_property (Lisp_Object image_instance, Lisp_Object prop) | |
| 2855 { | |
| 440 | 2856 Lisp_Image_Instance *ii = XIMAGE_INSTANCE (image_instance); |
| 442 | 2857 HWND wnd = WIDGET_INSTANCE_MSWINDOWS_HANDLE (ii); |
| 428 | 2858 /* get the text from a control */ |
| 2859 if (EQ (prop, Q_text)) | |
| 2860 { | |
| 771 | 2861 long item = qxeSendMessage (wnd, CB_GETCURSEL, 0, 0); |
| 2862 Charcount tchar_len = qxeSendMessage (wnd, CB_GETLBTEXTLEN, | |
| 2863 (WPARAM)item, 0); | |
| 2367 | 2864 Extbyte *buf = alloca_extbytes (XETCHAR_SIZE * (tchar_len + 1)); |
| 771 | 2865 qxeSendMessage (wnd, CB_GETLBTEXT, (WPARAM)item, (LPARAM) buf); |
| 2866 return build_tstr_string (buf); | |
| 428 | 2867 } |
| 2868 return Qunbound; | |
| 2869 } | |
| 2870 | |
| 442 | 2871 /* set the properties of a progress gauge */ |
| 2872 static void | |
| 2873 mswindows_progress_gauge_redisplay (Lisp_Object image_instance) | |
| 428 | 2874 { |
| 440 | 2875 Lisp_Image_Instance *ii = XIMAGE_INSTANCE (image_instance); |
| 428 | 2876 |
| 442 | 2877 if (IMAGE_INSTANCE_WIDGET_ITEMS_CHANGED (ii)) |
| 428 | 2878 { |
| 442 | 2879 Lisp_Object val; |
| 2880 val = XGUI_ITEM (IMAGE_INSTANCE_WIDGET_PENDING_ITEMS (ii))->value; | |
| 2881 #ifdef DEBUG_WIDGET_OUTPUT | |
| 2882 stderr_out ("progress gauge displayed value on %p updated to %ld\n", | |
| 2883 WIDGET_INSTANCE_MSWINDOWS_HANDLE (ii), | |
| 2884 XINT(val)); | |
| 2885 #endif | |
| 428 | 2886 CHECK_INT (val); |
| 771 | 2887 qxeSendMessage (WIDGET_INSTANCE_MSWINDOWS_HANDLE (ii), |
| 2888 PBM_SETPOS, (WPARAM)XINT (val), 0); | |
| 428 | 2889 } |
| 2890 } | |
| 2891 | |
| 2892 LRESULT WINAPI | |
| 438 | 2893 mswindows_control_wnd_proc (HWND hwnd, UINT msg, |
| 428 | 2894 WPARAM wParam, LPARAM lParam) |
| 2895 { | |
| 438 | 2896 switch (msg) |
| 428 | 2897 { |
| 2898 case WM_NOTIFY: | |
| 2899 case WM_COMMAND: | |
| 2900 case WM_CTLCOLORBTN: | |
| 2901 case WM_CTLCOLORLISTBOX: | |
| 2902 case WM_CTLCOLOREDIT: | |
| 2903 case WM_CTLCOLORSTATIC: | |
| 2904 case WM_CTLCOLORSCROLLBAR: | |
| 2905 | |
| 438 | 2906 return mswindows_wnd_proc (GetParent (hwnd), msg, wParam, lParam); |
| 428 | 2907 default: |
| 771 | 2908 return qxeDefWindowProc (hwnd, msg, wParam, lParam); |
| 2909 } | |
| 2910 } | |
| 2911 | |
| 2912 static void | |
| 2913 mswindows_widget_query_string_geometry (Lisp_Object string, Lisp_Object face, | |
| 2914 int *width, int *height, | |
| 2915 Lisp_Object domain) | |
| 2916 { | |
| 2917 if (height) | |
| 2918 query_string_geometry (string, face, 0, height, 0, domain); | |
| 2919 | |
| 2920 if (width) | |
| 2921 { | |
| 2922 HDC hdc = FRAME_MSWINDOWS_DC (DOMAIN_XFRAME (domain)); | |
| 2923 Extbyte *str; | |
| 2924 Bytecount len; | |
| 2925 SIZE size; | |
| 2926 | |
| 2927 SelectObject (hdc, mswindows_widget_hfont (face, domain, string)); | |
|
4981
4aebb0131297
Cleanups/renaming of EXTERNAL_TO_C_STRING and friends
Ben Wing <ben@xemacs.org>
parents:
4952
diff
changeset
|
2928 LISP_STRING_TO_SIZED_EXTERNAL (string, str, len, Qmswindows_tstr); |
| 771 | 2929 qxeGetTextExtentPoint32 (hdc, str, len / XETCHAR_SIZE, &size); |
| 2930 *width = size.cx; | |
| 428 | 2931 } |
| 2932 } | |
| 2933 | |
| 2934 #endif /* HAVE_WIDGETS */ | |
| 2935 | |
| 2936 | |
| 2937 /************************************************************************/ | |
| 2938 /* initialization */ | |
| 2939 /************************************************************************/ | |
| 2940 | |
| 2941 void | |
| 2942 syms_of_glyphs_mswindows (void) | |
| 2943 { | |
| 2944 } | |
| 2945 | |
| 2946 void | |
| 2947 console_type_create_glyphs_mswindows (void) | |
| 2948 { | |
| 442 | 2949 /* image methods - display */ |
| 428 | 2950 CONSOLE_HAS_METHOD (mswindows, print_image_instance); |
| 2951 CONSOLE_HAS_METHOD (mswindows, finalize_image_instance); | |
| 2952 CONSOLE_HAS_METHOD (mswindows, unmap_subwindow); | |
| 2953 CONSOLE_HAS_METHOD (mswindows, map_subwindow); | |
| 442 | 2954 CONSOLE_HAS_METHOD (mswindows, redisplay_subwindow); |
| 2955 CONSOLE_HAS_METHOD (mswindows, resize_subwindow); | |
| 2956 CONSOLE_HAS_METHOD (mswindows, redisplay_widget); | |
| 428 | 2957 CONSOLE_HAS_METHOD (mswindows, image_instance_equal); |
| 2958 CONSOLE_HAS_METHOD (mswindows, image_instance_hash); | |
| 2959 CONSOLE_HAS_METHOD (mswindows, init_image_instance_from_eimage); | |
| 2960 CONSOLE_HAS_METHOD (mswindows, locate_pixmap_file); | |
| 771 | 2961 #ifdef HAVE_WIDGETS |
| 2962 CONSOLE_HAS_METHOD (mswindows, widget_query_string_geometry); | |
| 863 | 2963 CONSOLE_HAS_METHOD (mswindows, widget_border_width); |
| 771 | 2964 #endif |
| 442 | 2965 |
| 2966 /* image methods - printer */ | |
| 2967 CONSOLE_INHERITS_METHOD (msprinter, mswindows, print_image_instance); | |
| 2968 CONSOLE_INHERITS_METHOD (msprinter, mswindows, finalize_image_instance); | |
| 2969 CONSOLE_INHERITS_METHOD (msprinter, mswindows, image_instance_equal); | |
| 2970 CONSOLE_INHERITS_METHOD (msprinter, mswindows, image_instance_hash); | |
| 771 | 2971 CONSOLE_INHERITS_METHOD (msprinter, mswindows, |
| 2972 init_image_instance_from_eimage); | |
| 442 | 2973 CONSOLE_INHERITS_METHOD (msprinter, mswindows, locate_pixmap_file); |
| 428 | 2974 } |
| 2975 | |
| 2976 void | |
| 2977 image_instantiator_format_create_glyphs_mswindows (void) | |
| 2978 { | |
| 442 | 2979 IIFORMAT_VALID_CONSOLE2 (mswindows, msprinter, nothing); |
| 2980 IIFORMAT_VALID_CONSOLE2 (mswindows, msprinter, string); | |
| 2981 IIFORMAT_VALID_CONSOLE2 (mswindows, msprinter, formatted_string); | |
| 2982 IIFORMAT_VALID_CONSOLE2 (mswindows, msprinter, inherit); | |
| 428 | 2983 /* image-instantiator types */ |
| 442 | 2984 INITIALIZE_DEVICE_IIFORMAT (mswindows, xbm); |
| 2985 INITIALIZE_DEVICE_IIFORMAT (msprinter, xbm); | |
| 2986 IIFORMAT_HAS_DEVMETHOD (mswindows, xbm, instantiate); | |
| 2987 IIFORMAT_INHERITS_DEVMETHOD (msprinter, mswindows, xbm, instantiate); | |
| 428 | 2988 #ifdef HAVE_XPM |
| 2989 INITIALIZE_DEVICE_IIFORMAT (mswindows, xpm); | |
| 442 | 2990 INITIALIZE_DEVICE_IIFORMAT (msprinter, xpm); |
| 428 | 2991 IIFORMAT_HAS_DEVMETHOD (mswindows, xpm, instantiate); |
| 442 | 2992 IIFORMAT_INHERITS_DEVMETHOD (msprinter, mswindows, xpm, instantiate); |
| 428 | 2993 #endif |
| 2994 #ifdef HAVE_XFACE | |
| 2995 INITIALIZE_DEVICE_IIFORMAT (mswindows, xface); | |
| 442 | 2996 INITIALIZE_DEVICE_IIFORMAT (msprinter, xface); |
| 428 | 2997 IIFORMAT_HAS_DEVMETHOD (mswindows, xface, instantiate); |
| 442 | 2998 IIFORMAT_INHERITS_DEVMETHOD (msprinter, mswindows, xface, instantiate); |
| 428 | 2999 #endif |
| 3000 #ifdef HAVE_JPEG | |
| 442 | 3001 IIFORMAT_VALID_CONSOLE2 (mswindows, msprinter, jpeg); |
| 428 | 3002 #endif |
| 3003 #ifdef HAVE_TIFF | |
| 442 | 3004 IIFORMAT_VALID_CONSOLE2 (mswindows, msprinter, tiff); |
| 434 | 3005 #endif |
| 428 | 3006 #ifdef HAVE_PNG |
| 442 | 3007 IIFORMAT_VALID_CONSOLE2 (mswindows, msprinter, png); |
| 434 | 3008 #endif |
| 428 | 3009 #ifdef HAVE_GIF |
| 442 | 3010 IIFORMAT_VALID_CONSOLE2 (mswindows, msprinter, gif); |
| 434 | 3011 #endif |
| 428 | 3012 #ifdef HAVE_WIDGETS |
| 442 | 3013 INITIALIZE_DEVICE_IIFORMAT (mswindows, widget); |
| 3014 IIFORMAT_HAS_DEVMETHOD (mswindows, widget, property); | |
| 3015 /* layout widget */ | |
| 3016 IIFORMAT_VALID_CONSOLE (mswindows, layout); | |
| 3017 INITIALIZE_DEVICE_IIFORMAT (mswindows, native_layout); | |
| 3018 IIFORMAT_HAS_DEVMETHOD (mswindows, native_layout, instantiate); | |
| 428 | 3019 /* button widget */ |
| 3020 INITIALIZE_DEVICE_IIFORMAT (mswindows, button); | |
| 3021 IIFORMAT_HAS_DEVMETHOD (mswindows, button, property); | |
| 3022 IIFORMAT_HAS_DEVMETHOD (mswindows, button, instantiate); | |
| 442 | 3023 IIFORMAT_HAS_DEVMETHOD (mswindows, button, redisplay); |
| 3024 /* edit-field widget */ | |
| 428 | 3025 INITIALIZE_DEVICE_IIFORMAT (mswindows, edit_field); |
| 3026 IIFORMAT_HAS_DEVMETHOD (mswindows, edit_field, instantiate); | |
| 442 | 3027 /* subwindow */ |
| 428 | 3028 INITIALIZE_DEVICE_IIFORMAT (mswindows, subwindow); |
| 3029 IIFORMAT_HAS_DEVMETHOD (mswindows, subwindow, instantiate); | |
| 3030 /* label */ | |
| 3031 INITIALIZE_DEVICE_IIFORMAT (mswindows, label); | |
| 3032 IIFORMAT_HAS_DEVMETHOD (mswindows, label, instantiate); | |
| 3033 /* combo box */ | |
| 3034 INITIALIZE_DEVICE_IIFORMAT (mswindows, combo_box); | |
| 3035 IIFORMAT_HAS_DEVMETHOD (mswindows, combo_box, property); | |
| 3036 IIFORMAT_HAS_DEVMETHOD (mswindows, combo_box, instantiate); | |
| 3037 /* scrollbar */ | |
| 3038 INITIALIZE_DEVICE_IIFORMAT (mswindows, scrollbar); | |
| 3039 IIFORMAT_HAS_DEVMETHOD (mswindows, scrollbar, instantiate); | |
| 3040 /* progress gauge */ | |
| 3041 INITIALIZE_DEVICE_IIFORMAT (mswindows, progress_gauge); | |
| 442 | 3042 IIFORMAT_HAS_DEVMETHOD (mswindows, progress_gauge, redisplay); |
| 428 | 3043 IIFORMAT_HAS_DEVMETHOD (mswindows, progress_gauge, instantiate); |
| 3044 /* tree view widget */ | |
| 3045 INITIALIZE_DEVICE_IIFORMAT (mswindows, tree_view); | |
| 3046 IIFORMAT_HAS_DEVMETHOD (mswindows, tree_view, instantiate); | |
| 442 | 3047 IIFORMAT_HAS_DEVMETHOD (mswindows, tree_view, redisplay); |
| 428 | 3048 /* tab control widget */ |
| 3049 INITIALIZE_DEVICE_IIFORMAT (mswindows, tab_control); | |
| 3050 IIFORMAT_HAS_DEVMETHOD (mswindows, tab_control, instantiate); | |
| 442 | 3051 IIFORMAT_HAS_DEVMETHOD (mswindows, tab_control, redisplay); |
| 428 | 3052 #endif |
| 3053 /* windows bitmap format */ | |
| 3054 INITIALIZE_IMAGE_INSTANTIATOR_FORMAT (bmp, "bmp"); | |
| 3055 IIFORMAT_HAS_METHOD (bmp, validate); | |
| 3056 IIFORMAT_HAS_METHOD (bmp, normalize); | |
| 3057 IIFORMAT_HAS_METHOD (bmp, possible_dest_types); | |
| 3058 IIFORMAT_HAS_METHOD (bmp, instantiate); | |
| 3059 | |
| 3060 IIFORMAT_VALID_KEYWORD (bmp, Q_data, check_valid_string); | |
| 3061 IIFORMAT_VALID_KEYWORD (bmp, Q_file, check_valid_string); | |
| 442 | 3062 IIFORMAT_VALID_CONSOLE2 (mswindows, msprinter, bmp); |
| 428 | 3063 |
| 3064 /* mswindows resources */ | |
| 3065 INITIALIZE_IMAGE_INSTANTIATOR_FORMAT (mswindows_resource, | |
| 3066 "mswindows-resource"); | |
| 3067 | |
| 3068 IIFORMAT_HAS_METHOD (mswindows_resource, validate); | |
| 3069 IIFORMAT_HAS_METHOD (mswindows_resource, normalize); | |
| 3070 IIFORMAT_HAS_METHOD (mswindows_resource, possible_dest_types); | |
| 3071 IIFORMAT_HAS_METHOD (mswindows_resource, instantiate); | |
| 3072 | |
| 434 | 3073 IIFORMAT_VALID_KEYWORD (mswindows_resource, Q_resource_type, |
| 428 | 3074 check_valid_resource_symbol); |
| 3075 IIFORMAT_VALID_KEYWORD (mswindows_resource, Q_resource_id, check_valid_resource_id); | |
| 3076 IIFORMAT_VALID_KEYWORD (mswindows_resource, Q_file, check_valid_string); | |
| 442 | 3077 IIFORMAT_VALID_CONSOLE2 (mswindows, msprinter, mswindows_resource); |
| 428 | 3078 } |
| 3079 | |
| 3080 void | |
| 3081 vars_of_glyphs_mswindows (void) | |
| 3082 { | |
| 3083 DEFVAR_LISP ("mswindows-bitmap-file-path", &Vmswindows_bitmap_file_path /* | |
| 3084 A list of the directories in which mswindows bitmap files may be found. | |
| 3085 This is used by the `make-image-instance' function. | |
| 3086 */ ); | |
| 3087 Vmswindows_bitmap_file_path = Qnil; | |
| 3088 } | |
| 3089 | |
| 3090 void | |
| 3091 complex_vars_of_glyphs_mswindows (void) | |
| 3092 { | |
| 3093 } |