1 /* mswindows-specific glyph objects.
2 Copyright (C) 1998, 1999 Andy Piper.
4 This file is part of XEmacs.
6 XEmacs is free software; you can redistribute it and/or modify it
7 under the terms of the GNU General Public License as published by the
8 Free Software Foundation; either version 2, or (at your option) any
11 XEmacs is distributed in the hope that it will be useful, but WITHOUT
12 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
16 You should have received a copy of the GNU General Public License
17 along with XEmacs; see the file COPYING. If not, write to
18 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
19 Boston, MA 02111-1307, USA. */
21 /* Synched up with: Not in FSF. */
23 /* written by Andy Piper <andy@xemacs.org> plagerising bits from
30 #define OEMRESOURCE /* Define OCR_ and friend constants */
31 #include "console-msw.h"
32 #include "glyphs-msw.h"
33 #include "objects-msw.h"
46 #include "file-coding.h"
54 #define WIDGET_GLYPH_SLOT 0
56 DECLARE_IMAGE_INSTANTIATOR_FORMAT (nothing);
57 DECLARE_IMAGE_INSTANTIATOR_FORMAT (string);
58 DECLARE_IMAGE_INSTANTIATOR_FORMAT (formatted_string);
59 DECLARE_IMAGE_INSTANTIATOR_FORMAT (inherit);
60 DECLARE_IMAGE_INSTANTIATOR_FORMAT (layout);
62 DECLARE_IMAGE_INSTANTIATOR_FORMAT (jpeg);
65 DECLARE_IMAGE_INSTANTIATOR_FORMAT (tiff);
68 DECLARE_IMAGE_INSTANTIATOR_FORMAT (png);
71 DECLARE_IMAGE_INSTANTIATOR_FORMAT (gif);
74 DEFINE_DEVICE_IIFORMAT (mswindows, xpm);
76 DEFINE_DEVICE_IIFORMAT (mswindows, xbm);
78 DEFINE_DEVICE_IIFORMAT (mswindows, xface);
80 DEFINE_DEVICE_IIFORMAT (mswindows, button);
81 DEFINE_DEVICE_IIFORMAT (mswindows, edit_field);
82 DEFINE_DEVICE_IIFORMAT (mswindows, subwindow);
83 DEFINE_DEVICE_IIFORMAT (mswindows, widget);
84 DEFINE_DEVICE_IIFORMAT (mswindows, label);
85 DEFINE_DEVICE_IIFORMAT (mswindows, scrollbar);
86 DEFINE_DEVICE_IIFORMAT (mswindows, combo_box);
87 DEFINE_DEVICE_IIFORMAT (mswindows, progress_gauge);
88 DEFINE_DEVICE_IIFORMAT (mswindows, tree_view);
89 DEFINE_DEVICE_IIFORMAT (mswindows, tab_control);
91 DEFINE_IMAGE_INSTANTIATOR_FORMAT (bmp);
93 Lisp_Object Vmswindows_bitmap_file_path;
94 static COLORREF transparent_color = RGB (1,1,1);
96 DEFINE_IMAGE_INSTANTIATOR_FORMAT (mswindows_resource);
97 Lisp_Object Q_resource_type, Q_resource_id;
98 Lisp_Object Qmswindows_resource;
101 mswindows_initialize_dibitmap_image_instance (struct Lisp_Image_Instance *ii,
103 enum image_instance_type type);
105 mswindows_initialize_image_instance_mask (struct Lisp_Image_Instance* image,
108 COLORREF mswindows_string_to_color (CONST char *name);
110 #define BPLINE(width) ((int)(~3UL & (unsigned long)((width) +3)))
112 /************************************************************************/
113 /* convert from a series of RGB triples to a BITMAPINFO formated for the*/
115 /************************************************************************/
116 static BITMAPINFO* convert_EImage_to_DIBitmap (Lisp_Object device,
117 int width, int height,
120 unsigned char** bmp_data)
122 struct device *d = XDEVICE (device);
126 BITMAPINFO* bmp_info;
127 unsigned char *ip, *dp;
129 if (DEVICE_MSWINDOWS_BITSPIXEL (d) > 0)
131 int bpline = BPLINE(width * 3);
132 /* FIXME: we can do this because 24bpp implies no color table, once
133 * we start palettizing this is no longer true. The X versions of
134 * this function quantises to 256 colors or bit masks down to a
135 * long. Windows can actually handle rgb triples in the raw so I
136 * don't see much point trying to optimize down to the best
137 * structure - unless it has memory / color allocation implications
139 bmp_info=xnew_and_zero (BITMAPINFO);
146 bmp_info->bmiHeader.biBitCount=24; /* just RGB triples for now */
147 bmp_info->bmiHeader.biCompression=BI_RGB; /* just RGB triples for now */
148 bmp_info->bmiHeader.biSizeImage=width*height*3;
150 /* bitmap data needs to be in blue, green, red triples - in that
151 order, eimage is in RGB format so we need to convert */
152 *bmp_data = xnew_array_and_zero (unsigned char, bpline * height);
153 *bit_count = bpline * height;
162 for (i = height-1; i >= 0; i--) {
163 dp = (*bmp_data) + (i * bpline);
164 for (j = 0; j < width; j++) {
172 else /* scale to 256 colors */
176 int bpline = BPLINE (width * 3);
177 /* Quantize the image and get a histogram while we're at it.
178 Do this first to save memory */
179 qtable = build_EImage_quantable(pic, width, height, 256);
180 if (qtable == NULL) return NULL;
182 /* use our quantize table to allocate the colors */
183 ncolors = qtable->num_active_colors;
184 bmp_info=(BITMAPINFO*)xmalloc_and_zero (sizeof(BITMAPINFOHEADER) +
185 sizeof(RGBQUAD) * ncolors);
192 colortbl=(RGBQUAD*)(((unsigned char*)bmp_info)+sizeof(BITMAPINFOHEADER));
194 bmp_info->bmiHeader.biBitCount=8;
195 bmp_info->bmiHeader.biCompression=BI_RGB;
196 bmp_info->bmiHeader.biSizeImage=bpline*height;
197 bmp_info->bmiHeader.biClrUsed=ncolors;
198 bmp_info->bmiHeader.biClrImportant=ncolors;
200 *bmp_data = (unsigned char *) xmalloc_and_zero (bpline * height);
201 *bit_count = bpline * height;
210 /* build up an RGBQUAD colortable */
211 for (i = 0; i < qtable->num_active_colors; i++) {
212 colortbl[i].rgbRed = (BYTE) qtable->rm[i];
213 colortbl[i].rgbGreen = (BYTE) qtable->gm[i];
214 colortbl[i].rgbBlue = (BYTE) qtable->bm[i];
215 colortbl[i].rgbReserved = 0;
218 /* now build up the data. picture has to be upside-down and
219 back-to-front for msw bitmaps */
221 for (i = height-1; i >= 0; i--) {
222 dp = (*bmp_data) + (i * bpline);
223 for (j = 0; j < width; j++) {
227 *dp++ = QUANT_GET_COLOR (qtable,rd,gr,bl);
232 /* fix up the standard stuff */
233 bmp_info->bmiHeader.biWidth=width;
234 bmp_info->bmiHeader.biHeight=height;
235 bmp_info->bmiHeader.biPlanes=1;
236 bmp_info->bmiHeader.biSize=sizeof(BITMAPINFOHEADER);
237 bmp_info->bmiHeader.biXPelsPerMeter=0; /* unless you know better */
238 bmp_info->bmiHeader.biYPelsPerMeter=0;
243 /* Given a pixmap filename, look through all of the "standard" places
244 where the file might be located. Return a full pathname if found;
245 otherwise, return Qnil. */
248 mswindows_locate_pixmap_file (Lisp_Object name)
250 /* This function can GC if IN_REDISPLAY is false */
253 /* Check non-absolute pathnames with a directory component relative to
254 the search path; that's the way Xt does it. */
255 if (IS_DIRECTORY_SEP(XSTRING_BYTE (name, 0)) ||
256 (XSTRING_BYTE (name, 0) == '.' &&
257 (IS_DIRECTORY_SEP(XSTRING_BYTE (name, 1)) ||
258 (XSTRING_BYTE (name, 1) == '.' &&
259 (IS_DIRECTORY_SEP(XSTRING_BYTE (name, 2)))))))
261 if (!NILP (Ffile_readable_p (name)))
267 if (locate_file (Vmswindows_bitmap_file_path, name, Qnil, &found, R_OK) < 0)
269 Lisp_Object temp = list1 (Vdata_directory);
273 locate_file (temp, name, Qnil, &found, R_OK);
281 /* Initialize an image instance from a bitmap
283 DEST_MASK specifies the mask of allowed image types.
285 If this fails, signal an error. INSTANTIATOR is only used
286 in the error message. */
289 init_image_instance_from_dibitmap (struct Lisp_Image_Instance *ii,
290 BITMAPINFO *bmp_info,
295 Lisp_Object instantiator,
296 int x_hot, int y_hot,
299 Lisp_Object device = IMAGE_INSTANCE_DEVICE (ii);
300 struct device *d = XDEVICE (device);
307 if (!DEVICE_MSWINDOWS_P (d))
308 signal_simple_error ("Not an mswindows device", device);
310 if (NILP (DEVICE_SELECTED_FRAME (d)))
311 signal_simple_error ("No selected frame on mswindows device", device);
313 f = XFRAME (DEVICE_SELECTED_FRAME (d));
315 if (dest_mask & IMAGE_COLOR_PIXMAP_MASK)
316 type = IMAGE_COLOR_PIXMAP;
317 else if (dest_mask & IMAGE_POINTER_MASK)
318 type = IMAGE_POINTER;
320 incompatible_image_types (instantiator, dest_mask,
321 IMAGE_COLOR_PIXMAP_MASK | IMAGE_POINTER_MASK);
322 hdc = FRAME_MSWINDOWS_CDC (f);
324 bitmap=CreateDIBSection (hdc,
330 if (!bitmap || !bmp_buf)
331 signal_simple_error ("Unable to create bitmap", instantiator);
333 /* copy in the actual bitmap */
334 memcpy (bmp_buf, bmp_data, bmp_bits);
336 mswindows_initialize_dibitmap_image_instance (ii, slices, type);
338 IMAGE_INSTANCE_PIXMAP_FILENAME (ii) =
339 find_keyword_in_vector (instantiator, Q_file);
341 /* Fixup a set of bitmaps. */
342 IMAGE_INSTANCE_MSWINDOWS_BITMAP (ii) = bitmap;
344 IMAGE_INSTANCE_MSWINDOWS_MASK (ii) = NULL;
345 IMAGE_INSTANCE_PIXMAP_WIDTH (ii) = bmp_info->bmiHeader.biWidth;
346 IMAGE_INSTANCE_PIXMAP_HEIGHT (ii) = bmp_info->bmiHeader.biHeight;
347 IMAGE_INSTANCE_PIXMAP_DEPTH (ii) = bmp_info->bmiHeader.biBitCount;
348 XSETINT (IMAGE_INSTANCE_PIXMAP_HOTSPOT_X (ii), x_hot);
349 XSETINT (IMAGE_INSTANCE_PIXMAP_HOTSPOT_Y (ii), y_hot);
353 mswindows_initialize_image_instance_mask (ii, f);
356 if (type == IMAGE_POINTER)
358 mswindows_initialize_image_instance_icon(ii, TRUE);
363 image_instance_add_dibitmap (struct Lisp_Image_Instance *ii,
364 BITMAPINFO *bmp_info,
368 Lisp_Object instantiator)
370 Lisp_Object device = IMAGE_INSTANCE_DEVICE (ii);
371 struct device *d = XDEVICE (device);
372 struct frame *f = XFRAME (DEVICE_SELECTED_FRAME (d));
374 HDC hdc = FRAME_MSWINDOWS_CDC (f);
375 HBITMAP bitmap = CreateDIBSection (hdc,
381 if (!bitmap || !bmp_buf)
382 signal_simple_error ("Unable to create bitmap", instantiator);
384 /* copy in the actual bitmap */
385 memcpy (bmp_buf, bmp_data, bmp_bits);
386 IMAGE_INSTANCE_MSWINDOWS_BITMAP_SLICE (ii, slice) = bitmap;
390 mswindows_init_image_instance_from_eimage (struct Lisp_Image_Instance *ii,
391 int width, int height,
393 unsigned char *eimage,
395 Lisp_Object instantiator,
398 Lisp_Object device = IMAGE_INSTANCE_DEVICE (ii);
399 BITMAPINFO* bmp_info;
400 unsigned char* bmp_data;
405 if (!DEVICE_MSWINDOWS_P (XDEVICE (device)))
406 signal_simple_error ("Not an mswindows device", device);
408 /* this is a hack but MaskBlt and TransparentBlt are not supported
409 on most windows variants */
410 bkcolor = COLOR_INSTANCE_MSWINDOWS_COLOR
411 (XCOLOR_INSTANCE (FACE_BACKGROUND (Vdefault_face, domain)));
413 for (slice = 0; slice < slices; slice++)
415 /* build a bitmap from the eimage */
416 if (!(bmp_info=convert_EImage_to_DIBitmap (device, width, height,
417 eimage + (width * height * 3 * slice),
418 &bmp_bits, &bmp_data)))
420 signal_simple_error ("EImage to DIBitmap conversion failed",
424 /* Now create the pixmap and set up the image instance */
426 init_image_instance_from_dibitmap (ii, bmp_info, dest_mask,
427 bmp_data, bmp_bits, slices, instantiator,
430 image_instance_add_dibitmap (ii, bmp_info, bmp_data, bmp_bits, slice,
438 static void set_mono_pixel ( unsigned char* bits,
439 int bpline, int height,
440 int x, int y, int white )
443 unsigned char bitnum;
444 /* Find the byte on which this scanline begins */
445 index = (height - y - 1) * bpline;
446 /* Find the byte containing this pixel */
448 /* Which bit is it? */
449 bitnum = (unsigned char)( 7 - (x % 8) );
450 if( white ) /* Turn it on */
451 bits[index] |= (1<<bitnum);
452 else /* Turn it off */
453 bits[index] &= ~(1<<bitnum);
457 mswindows_initialize_image_instance_mask (struct Lisp_Image_Instance* image,
462 HDC hcdc = FRAME_MSWINDOWS_CDC (f);
463 unsigned char* dibits;
464 BITMAPINFO* bmp_info =
465 xmalloc_and_zero (sizeof(BITMAPINFO) + sizeof(RGBQUAD));
467 int height = IMAGE_INSTANCE_PIXMAP_HEIGHT (image);
470 int maskbpline = BPLINE (((IMAGE_INSTANCE_PIXMAP_WIDTH (image)+7)/8));
471 int bpline = BPLINE (IMAGE_INSTANCE_PIXMAP_WIDTH (image) * 3);
476 bmp_info->bmiHeader.biWidth=IMAGE_INSTANCE_PIXMAP_WIDTH (image);
477 bmp_info->bmiHeader.biHeight = height;
478 bmp_info->bmiHeader.biPlanes=1;
479 bmp_info->bmiHeader.biSize=sizeof(BITMAPINFOHEADER);
480 bmp_info->bmiHeader.biBitCount=1;
481 bmp_info->bmiHeader.biCompression=BI_RGB;
482 bmp_info->bmiHeader.biClrUsed = 2;
483 bmp_info->bmiHeader.biClrImportant = 2;
484 bmp_info->bmiHeader.biSizeImage = height * maskbpline;
485 bmp_info->bmiColors[0].rgbRed = 0;
486 bmp_info->bmiColors[0].rgbGreen = 0;
487 bmp_info->bmiColors[0].rgbBlue = 0;
488 bmp_info->bmiColors[0].rgbReserved = 0;
489 bmp_info->bmiColors[1].rgbRed = 255;
490 bmp_info->bmiColors[1].rgbGreen = 255;
491 bmp_info->bmiColors[1].rgbBlue = 255;
492 bmp_info->bmiColors[0].rgbReserved = 0;
494 if (!(mask = CreateDIBSection (hcdc,
504 old = SelectObject (hcdc, IMAGE_INSTANCE_MSWINDOWS_BITMAP (image));
505 /* build up an in-memory set of bits to mess with */
508 bmp_info->bmiHeader.biWidth=IMAGE_INSTANCE_PIXMAP_WIDTH (image);
509 bmp_info->bmiHeader.biHeight = -height;
510 bmp_info->bmiHeader.biPlanes=1;
511 bmp_info->bmiHeader.biSize=sizeof(BITMAPINFOHEADER);
512 bmp_info->bmiHeader.biBitCount=24;
513 bmp_info->bmiHeader.biCompression=BI_RGB;
514 bmp_info->bmiHeader.biClrUsed = 0;
515 bmp_info->bmiHeader.biClrImportant = 0;
516 bmp_info->bmiHeader.biSizeImage = height * bpline;
518 dibits = xmalloc_and_zero (bpline * height);
520 IMAGE_INSTANCE_MSWINDOWS_BITMAP (image),
525 DIB_RGB_COLORS) <= 0)
531 /* now set the colored bits in the mask and transparent ones to
532 black in the original */
533 for(i=0; i<IMAGE_INSTANCE_PIXMAP_WIDTH (image); i++)
535 for(j=0; j<height; j++)
537 unsigned char* idx = &dibits[j * bpline + i * 3];
539 if( RGB (idx[2], idx[1], idx[0]) == transparent_color )
541 idx[0] = idx[1] = idx[2] = 0;
542 set_mono_pixel( and_bits, maskbpline, height, i, j, TRUE );
546 set_mono_pixel( and_bits, maskbpline, height, i, j, FALSE );
552 IMAGE_INSTANCE_MSWINDOWS_BITMAP (image),
562 SelectObject(hcdc, old);
564 IMAGE_INSTANCE_MSWINDOWS_MASK (image) = mask;
568 mswindows_initialize_image_instance_icon (struct Lisp_Image_Instance* image,
573 /* we rely on windows to do any resizing necessary */
574 x_icon.fIcon=cursor ? FALSE : TRUE;
575 x_icon.xHotspot=XINT (IMAGE_INSTANCE_PIXMAP_HOTSPOT_X (image));
576 x_icon.yHotspot=XINT (IMAGE_INSTANCE_PIXMAP_HOTSPOT_Y (image));
577 x_icon.hbmMask=IMAGE_INSTANCE_MSWINDOWS_MASK (image);
578 x_icon.hbmColor=IMAGE_INSTANCE_MSWINDOWS_BITMAP (image);
580 IMAGE_INSTANCE_MSWINDOWS_ICON (image)=
581 CreateIconIndirect (&x_icon);
585 mswindows_create_resized_bitmap (struct Lisp_Image_Instance* ii,
591 HDC hcdc = FRAME_MSWINDOWS_CDC (f);
592 HDC hdcDst = CreateCompatibleDC (hcdc);
594 old1 = SelectObject (hcdc, IMAGE_INSTANCE_MSWINDOWS_BITMAP (ii));
596 newbmp = CreateCompatibleBitmap (hcdc, newx, newy);
598 old2 = SelectObject (hdcDst, newbmp);
600 if (!StretchBlt (hdcDst, 0, 0, newx, newy,
602 IMAGE_INSTANCE_PIXMAP_WIDTH (ii),
603 IMAGE_INSTANCE_PIXMAP_HEIGHT (ii),
606 DeleteObject (newbmp);
611 SelectObject (hdcDst, old2);
612 SelectObject (hcdc, old1);
619 mswindows_create_resized_mask (struct Lisp_Image_Instance* ii,
623 if (IMAGE_INSTANCE_MSWINDOWS_MASK (ii))
627 HDC hcdc = FRAME_MSWINDOWS_CDC (f);
628 HDC hdcDst = CreateCompatibleDC (hcdc);
630 old1 = SelectObject (hcdc, IMAGE_INSTANCE_MSWINDOWS_MASK (ii));
631 newmask = CreateCompatibleBitmap(hcdc, newx, newy);
632 old2 = SelectObject (hdcDst, newmask);
634 if (!StretchBlt(hdcDst, 0, 0, newx, newy,
636 IMAGE_INSTANCE_PIXMAP_WIDTH (ii),
637 IMAGE_INSTANCE_PIXMAP_HEIGHT (ii),
640 DeleteObject (newmask);
645 SelectObject (hdcDst, old2);
646 SelectObject (hcdc, old1);
657 mswindows_resize_dibitmap_instance (struct Lisp_Image_Instance* ii,
661 HBITMAP newbmp = mswindows_create_resized_bitmap (ii, f, newx, newy);
662 HBITMAP newmask = mswindows_create_resized_mask (ii, f, newx, newy);
667 if (IMAGE_INSTANCE_MSWINDOWS_BITMAP (ii))
668 DeleteObject (IMAGE_INSTANCE_MSWINDOWS_BITMAP (ii));
669 if (IMAGE_INSTANCE_MSWINDOWS_MASK (ii))
670 DeleteObject (IMAGE_INSTANCE_MSWINDOWS_MASK (ii));
672 IMAGE_INSTANCE_MSWINDOWS_BITMAP (ii) = newbmp;
673 IMAGE_INSTANCE_MSWINDOWS_MASK (ii) = newmask;
674 IMAGE_INSTANCE_PIXMAP_WIDTH (ii) = newx;
675 IMAGE_INSTANCE_PIXMAP_HEIGHT (ii) = newy;
680 /**********************************************************************
682 **********************************************************************/
692 static struct color_symbol*
693 extract_xpm_color_names (Lisp_Object device,
695 Lisp_Object color_symbol_alist,
698 /* This function can GC */
700 Lisp_Object results = Qnil;
702 struct color_symbol *colortbl;
703 struct gcpro gcpro1, gcpro2;
705 GCPRO2 (results, device);
707 /* We built up results to be (("name" . #<color>) ...) so that if an
708 error happens we don't lose any malloc()ed data, or more importantly,
709 leave any pixels allocated in the server. */
711 LIST_LOOP (rest, color_symbol_alist)
713 Lisp_Object cons = XCAR (rest);
714 Lisp_Object name = XCAR (cons);
715 Lisp_Object value = XCDR (cons);
721 (value, device, encode_error_behavior_flag (ERROR_ME_NOT));
724 assert (COLOR_SPECIFIERP (value));
725 value = Fspecifier_instance (value, domain, Qnil, Qnil);
729 results = noseeum_cons (noseeum_cons (name, value), results);
732 UNGCPRO; /* no more evaluation */
735 if (i == 0) return 0;
737 colortbl = xnew_array_and_zero (struct color_symbol, i);
741 Lisp_Object cons = XCAR (results);
743 COLOR_INSTANCE_MSWINDOWS_COLOR (XCOLOR_INSTANCE (XCDR (cons)));
745 GET_C_STRING_OS_DATA_ALLOCA (XCAR (cons), colortbl[j].name);
746 colortbl[j].name = xstrdup (colortbl[j].name); /* mustn't lose this when we return */
747 free_cons (XCONS (cons));
749 results = XCDR (results);
750 free_cons (XCONS (cons));
755 static int xpm_to_eimage (Lisp_Object image, CONST Extbyte *buffer,
756 unsigned char** data,
757 int* width, int* height,
758 int* x_hot, int* y_hot,
760 struct color_symbol* color_symbols,
765 int result, i, j, transp_idx, maskbpline;
768 COLORREF color; /* the american spelling virus hits again .. */
773 xpminfo.valuemask=XpmHotspot;
776 result = XpmCreateXpmImageFromBuffer ((char*)buffer,
785 signal_simple_error ("Invalid XPM data", image);
789 signal_double_file_error ("Parsing pixmap data",
790 "out of memory", image);
794 signal_double_file_error_2 ("Parsing pixmap data",
795 "unknown error code",
796 make_int (result), image);
800 *width = xpmimage.width;
801 *height = xpmimage.height;
802 maskbpline = BPLINE (((~7UL & (unsigned long)(*width + 7)) / 8));
804 *data = xnew_array_and_zero (unsigned char, *width * *height * 3);
808 XpmFreeXpmImage (&xpmimage);
809 XpmFreeXpmInfo (&xpminfo);
813 /* build a color table to speed things up */
814 colortbl = xnew_array_and_zero (COLORREF, xpmimage.ncolors);
818 XpmFreeXpmImage (&xpmimage);
819 XpmFreeXpmInfo (&xpminfo);
823 for (i=0; i<xpmimage.ncolors; i++)
826 /* pick up symbolic colors in preference */
827 if (xpmimage.colorTable[i].symbolic)
829 if (!strcasecmp (xpmimage.colorTable[i].symbolic,"BgColor")
831 !strcasecmp (xpmimage.colorTable[i].symbolic,"None"))
834 colortbl[i]=transparent_color;
836 goto label_found_color;
838 else if (color_symbols)
840 for (j = 0; j<nsymbols; j++)
842 if (!strcmp (xpmimage.colorTable[i].symbolic,
843 color_symbols[j].name ))
845 colortbl[i]=color_symbols[j].color;
846 goto label_found_color;
850 else if (xpmimage.colorTable[i].c_color == 0)
855 /* pick up transparencies */
856 if (!strcasecmp (xpmimage.colorTable[i].c_color,"None"))
859 colortbl[i]=transparent_color;
861 goto label_found_color;
863 /* finally pick up a normal color spec */
864 if (xpmimage.colorTable[i].c_color)
867 mswindows_string_to_color (xpmimage.colorTable[i].c_color);
868 goto label_found_color;
874 XpmFreeXpmImage (&xpmimage);
875 XpmFreeXpmInfo (&xpminfo);
881 /* convert the image */
884 for (i = 0; i< *width * *height; i++)
886 color = colortbl[*sptr++];
888 /* split out the 0x02bbggrr colorref into an rgb triple */
889 *dptr++=GetRValue (color); /* red */
890 *dptr++=GetGValue (color); /* green */
891 *dptr++=GetBValue (color); /* blue */
894 *x_hot=xpminfo.x_hotspot;
895 *y_hot=xpminfo.y_hotspot;
897 XpmFreeXpmImage (&xpmimage);
898 XpmFreeXpmInfo (&xpminfo);
904 mswindows_xpm_instantiate (Lisp_Object image_instance,
905 Lisp_Object instantiator,
906 Lisp_Object pointer_fg, Lisp_Object pointer_bg,
907 int dest_mask, Lisp_Object domain)
909 struct Lisp_Image_Instance *ii = XIMAGE_INSTANCE (image_instance);
910 Lisp_Object device = IMAGE_INSTANCE_DEVICE (ii);
911 CONST Extbyte *bytes;
913 unsigned char *eimage;
914 int width, height, x_hot, y_hot;
915 BITMAPINFO* bmp_info;
916 unsigned char* bmp_data;
918 int nsymbols=0, transp;
919 struct color_symbol* color_symbols=NULL;
921 Lisp_Object data = find_keyword_in_vector (instantiator, Q_data);
922 Lisp_Object color_symbol_alist = find_keyword_in_vector (instantiator,
925 if (!DEVICE_MSWINDOWS_P (XDEVICE (device)))
926 signal_simple_error ("Not an mswindows device", device);
928 assert (!NILP (data));
930 GET_STRING_BINARY_DATA_ALLOCA (data, bytes, len);
932 /* in case we have color symbols */
933 color_symbols = extract_xpm_color_names (device, domain,
934 color_symbol_alist, &nsymbols);
936 /* convert to an eimage to make processing easier */
937 if (!xpm_to_eimage (image_instance, bytes, &eimage, &width, &height,
938 &x_hot, &y_hot, &transp, color_symbols, nsymbols))
940 signal_simple_error ("XPM to EImage conversion failed",
948 xfree (color_symbols[nsymbols].name);
950 xfree(color_symbols);
953 /* build a bitmap from the eimage */
954 if (!(bmp_info=convert_EImage_to_DIBitmap (device, width, height, eimage,
955 &bmp_bits, &bmp_data)))
957 signal_simple_error ("XPM to EImage conversion failed",
962 /* Now create the pixmap and set up the image instance */
963 init_image_instance_from_dibitmap (ii, bmp_info, dest_mask,
964 bmp_data, bmp_bits, 1, instantiator,
965 x_hot, y_hot, transp);
970 #endif /* HAVE_XPM */
972 /**********************************************************************
974 **********************************************************************/
977 bmp_validate (Lisp_Object instantiator)
979 file_or_data_must_be_present (instantiator);
983 bmp_normalize (Lisp_Object inst, Lisp_Object console_type)
985 return simple_image_type_normalize (inst, console_type, Qbmp);
989 bmp_possible_dest_types (void)
991 return IMAGE_COLOR_PIXMAP_MASK;
995 bmp_instantiate (Lisp_Object image_instance, Lisp_Object instantiator,
996 Lisp_Object pointer_fg, Lisp_Object pointer_bg,
997 int dest_mask, Lisp_Object domain)
999 struct Lisp_Image_Instance *ii = XIMAGE_INSTANCE (image_instance);
1000 Lisp_Object device = IMAGE_INSTANCE_DEVICE (ii);
1001 CONST Extbyte *bytes;
1003 BITMAPFILEHEADER* bmp_file_header;
1004 BITMAPINFO* bmp_info;
1007 Lisp_Object data = find_keyword_in_vector (instantiator, Q_data);
1009 if (!DEVICE_MSWINDOWS_P (XDEVICE (device)))
1010 signal_simple_error ("Not an mswindows device", device);
1012 assert (!NILP (data));
1014 GET_STRING_BINARY_DATA_ALLOCA (data, bytes, len);
1016 /* Then slurp the image into memory, decoding along the way.
1017 The result is the image in a simple one-byte-per-pixel
1020 bmp_file_header=(BITMAPFILEHEADER*)bytes;
1021 bmp_info = (BITMAPINFO*)(bytes + sizeof(BITMAPFILEHEADER));
1022 bmp_data = (Extbyte*)bytes + bmp_file_header->bfOffBits;
1023 bmp_bits = bmp_file_header->bfSize - bmp_file_header->bfOffBits;
1025 /* Now create the pixmap and set up the image instance */
1026 init_image_instance_from_dibitmap (ii, bmp_info, dest_mask,
1027 bmp_data, bmp_bits, 1, instantiator,
1032 /**********************************************************************
1034 **********************************************************************/
1037 mswindows_resource_validate (Lisp_Object instantiator)
1039 if ((NILP (find_keyword_in_vector (instantiator, Q_file))
1041 NILP (find_keyword_in_vector (instantiator, Q_resource_id)))
1043 NILP (find_keyword_in_vector (instantiator, Q_resource_type)))
1044 signal_simple_error ("Must supply :file, :resource-id and :resource-type",
1049 mswindows_resource_normalize (Lisp_Object inst, Lisp_Object console_type)
1051 /* This function can call lisp */
1052 Lisp_Object file = Qnil;
1053 struct gcpro gcpro1, gcpro2;
1054 Lisp_Object alist = Qnil;
1056 GCPRO2 (file, alist);
1058 file = potential_pixmap_file_instantiator (inst, Q_file, Q_data,
1061 if (CONSP (file)) /* failure locating filename */
1062 signal_double_file_error ("Opening pixmap file",
1063 "no such file or directory",
1066 if (NILP (file)) /* no conversion necessary */
1067 RETURN_UNGCPRO (inst);
1069 alist = tagged_vector_to_alist (inst);
1072 alist = remassq_no_quit (Q_file, alist);
1073 alist = Fcons (Fcons (Q_file, file), alist);
1077 Lisp_Object result = alist_to_tagged_vector (Qmswindows_resource, alist);
1079 RETURN_UNGCPRO (result);
1084 mswindows_resource_possible_dest_types (void)
1086 return IMAGE_POINTER_MASK | IMAGE_COLOR_PIXMAP_MASK;
1096 #define OCR_ICOCUR 32647
1097 #define OIC_SAMPLE 32512
1098 #define OIC_HAND 32513
1099 #define OIC_QUES 32514
1100 #define OIC_BANG 32515
1101 #define OIC_NOTE 32516
1102 #define OIC_WINLOGO 32517
1103 #define LR_SHARED 0x8000
1106 static CONST resource_t bitmap_table[] =
1109 { "close", OBM_CLOSE },
1110 { "uparrow", OBM_UPARROW },
1111 { "dnarrow", OBM_DNARROW },
1112 { "rgarrow", OBM_RGARROW },
1113 { "lfarrow", OBM_LFARROW },
1114 { "reduce", OBM_REDUCE },
1115 { "zoom", OBM_ZOOM },
1116 { "restore", OBM_RESTORE },
1117 { "reduced", OBM_REDUCED },
1118 { "zoomd", OBM_ZOOMD },
1119 { "restored", OBM_RESTORED },
1120 { "uparrowd", OBM_UPARROWD },
1121 { "dnarrowd", OBM_DNARROWD },
1122 { "rgarrowd", OBM_RGARROWD },
1123 { "lfarrowd", OBM_LFARROWD },
1124 { "mnarrow", OBM_MNARROW },
1125 { "combo", OBM_COMBO },
1126 { "uparrowi", OBM_UPARROWI },
1127 { "dnarrowi", OBM_DNARROWI },
1128 { "rgarrowi", OBM_RGARROWI },
1129 { "lfarrowi", OBM_LFARROWI },
1130 { "size", OBM_SIZE },
1131 { "btsize", OBM_BTSIZE },
1132 { "check", OBM_CHECK },
1133 { "checkboxes", OBM_CHECKBOXES },
1134 { "btncorners" , OBM_BTNCORNERS },
1138 static CONST resource_t cursor_table[] =
1141 { "normal", OCR_NORMAL },
1142 { "ibeam", OCR_IBEAM },
1143 { "wait", OCR_WAIT },
1144 { "cross", OCR_CROSS },
1146 /* { "icon", OCR_ICON }, */
1147 { "sizenwse", OCR_SIZENWSE },
1148 { "sizenesw", OCR_SIZENESW },
1149 { "sizewe", OCR_SIZEWE },
1150 { "sizens", OCR_SIZENS },
1151 { "sizeall", OCR_SIZEALL },
1152 /* { "icour", OCR_ICOCUR }, */
1157 static CONST resource_t icon_table[] =
1160 { "sample", OIC_SAMPLE },
1161 { "hand", OIC_HAND },
1162 { "ques", OIC_QUES },
1163 { "bang", OIC_BANG },
1164 { "note", OIC_NOTE },
1165 { "winlogo", OIC_WINLOGO },
1169 static int resource_name_to_resource (Lisp_Object name, int type)
1171 CONST resource_t* res = (type == IMAGE_CURSOR ? cursor_table
1172 : type == IMAGE_ICON ? icon_table
1179 else if (!STRINGP (name))
1181 signal_simple_error ("invalid resource identifier", name);
1186 GET_C_STRING_OS_DATA_ALLOCA (name, nm);
1187 if (!strcasecmp ((char*)res->name, nm))
1188 return res->resource_id;
1189 } while ((++res)->name);
1194 resource_symbol_to_type (Lisp_Object data)
1196 if (EQ (data, Qcursor))
1197 return IMAGE_CURSOR;
1198 else if (EQ (data, Qicon))
1200 else if (EQ (data, Qbitmap))
1201 return IMAGE_BITMAP;
1207 mswindows_resource_instantiate (Lisp_Object image_instance, Lisp_Object instantiator,
1208 Lisp_Object pointer_fg, Lisp_Object pointer_bg,
1209 int dest_mask, Lisp_Object domain)
1211 struct Lisp_Image_Instance *ii = XIMAGE_INSTANCE (image_instance);
1212 unsigned int type = 0;
1213 HANDLE himage = NULL;
1215 HINSTANCE hinst = NULL;
1219 Lisp_Object device = IMAGE_INSTANCE_DEVICE (ii);
1221 Lisp_Object file = find_keyword_in_vector (instantiator, Q_file);
1222 Lisp_Object resource_type = find_keyword_in_vector (instantiator,
1224 Lisp_Object resource_id = find_keyword_in_vector (instantiator,
1229 if (!DEVICE_MSWINDOWS_P (XDEVICE (device)))
1230 signal_simple_error ("Not an mswindows device", device);
1232 type = resource_symbol_to_type (resource_type);
1234 if (dest_mask & IMAGE_POINTER_MASK && type == IMAGE_CURSOR)
1235 iitype = IMAGE_POINTER;
1236 else if (dest_mask & IMAGE_COLOR_PIXMAP_MASK)
1237 iitype = IMAGE_COLOR_PIXMAP;
1239 incompatible_image_types (instantiator, dest_mask,
1240 IMAGE_COLOR_PIXMAP_MASK | IMAGE_POINTER_MASK);
1242 /* mess with the keyword info we were provided with */
1246 GET_C_STRING_FILENAME_DATA_ALLOCA (file, f);
1248 CYGWIN_WIN32_PATH (f, fname);
1253 if (NILP (resource_id))
1254 resid = (LPCTSTR)fname;
1257 hinst = LoadLibraryEx (fname, NULL,
1258 LOAD_LIBRARY_AS_DATAFILE);
1259 resid = MAKEINTRESOURCE (resource_name_to_resource (resource_id,
1263 GET_C_STRING_OS_DATA_ALLOCA (resource_id, resid);
1266 else if (!(resid = MAKEINTRESOURCE (resource_name_to_resource (resource_id,
1268 signal_simple_error ("Invalid resource identifier", resource_id);
1270 /* load the image */
1271 if (!(himage = LoadImage (hinst, resid, type, 0, 0,
1272 LR_CREATEDIBSECTION | LR_DEFAULTSIZE |
1274 (!NILP (file) ? LR_LOADFROMFILE : 0))))
1276 signal_simple_error ("Cannot load image", instantiator);
1280 FreeLibrary (hinst);
1282 mswindows_initialize_dibitmap_image_instance (ii, 1, iitype);
1284 IMAGE_INSTANCE_PIXMAP_FILENAME (ii) = file;
1285 IMAGE_INSTANCE_PIXMAP_WIDTH (ii) =
1286 GetSystemMetrics (type == IMAGE_CURSOR ? SM_CXCURSOR : SM_CXICON);
1287 IMAGE_INSTANCE_PIXMAP_HEIGHT (ii) =
1288 GetSystemMetrics (type == IMAGE_CURSOR ? SM_CYCURSOR : SM_CYICON);
1289 IMAGE_INSTANCE_PIXMAP_DEPTH (ii) = 1;
1291 /* hey, we've got an icon type thing so we can reverse engineer the
1293 if (type != IMAGE_BITMAP)
1295 GetIconInfo (himage, &iconinfo);
1296 IMAGE_INSTANCE_MSWINDOWS_BITMAP (ii) = iconinfo.hbmColor;
1297 IMAGE_INSTANCE_MSWINDOWS_MASK (ii) = iconinfo.hbmMask;
1298 XSETINT (IMAGE_INSTANCE_PIXMAP_HOTSPOT_X (ii), iconinfo.xHotspot);
1299 XSETINT (IMAGE_INSTANCE_PIXMAP_HOTSPOT_Y (ii), iconinfo.yHotspot);
1300 IMAGE_INSTANCE_MSWINDOWS_ICON (ii) = himage;
1304 IMAGE_INSTANCE_MSWINDOWS_ICON (ii) = NULL;
1305 IMAGE_INSTANCE_MSWINDOWS_BITMAP (ii) = himage;
1306 IMAGE_INSTANCE_MSWINDOWS_MASK (ii) = NULL;
1307 XSETINT (IMAGE_INSTANCE_PIXMAP_HOTSPOT_X (ii), 0);
1308 XSETINT (IMAGE_INSTANCE_PIXMAP_HOTSPOT_Y (ii), 0);
1313 check_valid_resource_symbol (Lisp_Object data)
1315 CHECK_SYMBOL (data);
1316 if (!resource_symbol_to_type (data))
1317 signal_simple_error ("invalid resource type", data);
1321 check_valid_resource_id (Lisp_Object data)
1323 if (!resource_name_to_resource (data, IMAGE_CURSOR)
1325 !resource_name_to_resource (data, IMAGE_ICON)
1327 !resource_name_to_resource (data, IMAGE_BITMAP))
1328 signal_simple_error ("invalid resource identifier", data);
1332 check_valid_string_or_int (Lisp_Object data)
1335 CHECK_STRING (data);
1340 /**********************************************************************
1342 **********************************************************************/
1343 #ifndef HAVE_X_WINDOWS
1344 /* $XConsortium: RdBitF.c,v 1.10 94/04/17 20:16:13 kaleb Exp $ */
1348 Copyright (c) 1988 X Consortium
1350 Permission is hereby granted, free of charge, to any person obtaining a copy
1351 of this software and associated documentation files (the "Software"), to deal
1352 in the Software without restriction, including without limitation the rights
1353 to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
1354 copies of the Software, and to permit persons to whom the Software is
1355 furnished to do so, subject to the following conditions:
1357 The above copyright notice and this permission notice shall be included in
1358 all copies or substantial portions of the Software.
1360 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
1361 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
1362 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
1363 X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
1364 AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
1365 CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
1367 Except as contained in this notice, the name of the X Consortium shall not be
1368 used in advertising or otherwise to promote the sale, use or other dealings
1369 in this Software without prior written authorization from the X Consortium.
1374 * This file contains miscellaneous utility routines and is not part of the
1377 * Public entry points:
1379 * XmuReadBitmapData read data from FILE descriptor
1380 * XmuReadBitmapDataFromFile read X10 or X11 format bitmap files
1383 * Note that this file and ../X/XRdBitF.c look very similar.... Keep them
1384 * that way (but don't use common source code so that people can have one
1385 * without the other).
1390 * Based on an optimized version provided by Jim Becker, August 5, 1988.
1392 #ifndef BitmapSuccess
1393 #define BitmapSuccess 0
1394 #define BitmapOpenFailed 1
1395 #define BitmapFileInvalid 2
1396 #define BitmapNoMemory 3
1398 #define MAX_SIZE 255
1400 /* shared data for the image read/parse logic */
1401 static short hexTable[256]; /* conversion value */
1402 static int initialized = FALSE; /* easier to fill in at run time */
1405 * Table index for the hex values. Initialized once, first time.
1406 * Used for translation value or delimiter significance lookup.
1408 static void initHexTable()
1411 * We build the table at run time for several reasons:
1413 * 1. portable to non-ASCII machines.
1414 * 2. still reentrant since we set the init flag after setting table.
1415 * 3. easier to extend.
1416 * 4. less prone to bugs.
1418 hexTable['0'] = 0; hexTable['1'] = 1;
1419 hexTable['2'] = 2; hexTable['3'] = 3;
1420 hexTable['4'] = 4; hexTable['5'] = 5;
1421 hexTable['6'] = 6; hexTable['7'] = 7;
1422 hexTable['8'] = 8; hexTable['9'] = 9;
1423 hexTable['A'] = 10; hexTable['B'] = 11;
1424 hexTable['C'] = 12; hexTable['D'] = 13;
1425 hexTable['E'] = 14; hexTable['F'] = 15;
1426 hexTable['a'] = 10; hexTable['b'] = 11;
1427 hexTable['c'] = 12; hexTable['d'] = 13;
1428 hexTable['e'] = 14; hexTable['f'] = 15;
1430 /* delimiters of significance are flagged w/ negative value */
1431 hexTable[' '] = -1; hexTable[','] = -1;
1432 hexTable['}'] = -1; hexTable['\n'] = -1;
1433 hexTable['\t'] = -1;
1439 * read next hex value in the input stream, return -1 if EOF
1441 static int NextInt ( FILE *fstream )
1448 /* loop, accumulate hex value until find delimiter */
1449 /* skip any initial delimiters found in read stream */
1457 /* trim high bits, check type and accumulate */
1459 if (isascii(ch) && isxdigit(ch)) {
1460 value = (value << 4) + hexTable[ch];
1462 } else if ((hexTable[ch]) < 0 && gotone)
1471 * The data returned by the following routine is always in left-most byte
1472 * first and left-most bit first. If it doesn't return BitmapSuccess then
1473 * its arguments won't have been touched. This routine should look as much
1474 * like the Xlib routine XReadBitmapfile as possible.
1476 int read_bitmap_data (fstream, width, height, datap, x_hot, y_hot)
1477 FILE *fstream; /* handle on file */
1478 unsigned int *width, *height; /* RETURNED */
1479 unsigned char **datap; /* RETURNED */
1480 int *x_hot, *y_hot; /* RETURNED */
1482 unsigned char *data = NULL; /* working variable */
1483 char line[MAX_SIZE]; /* input line from file */
1484 int size; /* number of bytes of data */
1485 char name_and_type[MAX_SIZE]; /* an input line */
1486 char *type; /* for parsing */
1487 int value; /* from an input line */
1488 int version10p; /* boolean, old format */
1489 int padding; /* to handle alignment */
1490 int bytes_per_line; /* per scanline of data */
1491 unsigned int ww = 0; /* width */
1492 unsigned int hh = 0; /* height */
1493 int hx = -1; /* x hotspot */
1494 int hy = -1; /* y hotspot */
1496 #define Xmalloc(size) malloc(size)
1498 /* first time initialization */
1499 if (initialized == FALSE) initHexTable();
1501 /* error cleanup and return macro */
1502 #define RETURN(code) { if (data) free (data); return code; }
1504 while (fgets(line, MAX_SIZE, fstream)) {
1505 if (strlen(line) == MAX_SIZE-1) {
1506 RETURN (BitmapFileInvalid);
1508 if (sscanf(line,"#define %s %d",name_and_type,&value) == 2) {
1509 if (!(type = strrchr(name_and_type, '_')))
1510 type = name_and_type;
1514 if (!strcmp("width", type))
1515 ww = (unsigned int) value;
1516 if (!strcmp("height", type))
1517 hh = (unsigned int) value;
1518 if (!strcmp("hot", type)) {
1519 if (type-- == name_and_type || type-- == name_and_type)
1521 if (!strcmp("x_hot", type))
1523 if (!strcmp("y_hot", type))
1529 if (sscanf(line, "static short %s = {", name_and_type) == 1)
1531 else if (sscanf(line,"static unsigned char %s = {",name_and_type) == 1)
1533 else if (sscanf(line, "static char %s = {", name_and_type) == 1)
1538 if (!(type = strrchr(name_and_type, '_')))
1539 type = name_and_type;
1543 if (strcmp("bits[]", type))
1547 RETURN (BitmapFileInvalid);
1549 if ((ww % 16) && ((ww % 16) < 9) && version10p)
1554 bytes_per_line = (ww+7)/8 + padding;
1556 size = bytes_per_line * hh;
1557 data = (unsigned char *) Xmalloc ((unsigned int) size);
1559 RETURN (BitmapNoMemory);
1565 for (bytes=0, ptr=data; bytes<size; (bytes += 2)) {
1566 if ((value = NextInt(fstream)) < 0)
1567 RETURN (BitmapFileInvalid);
1569 if (!padding || ((bytes+2) % bytes_per_line))
1570 *(ptr++) = value >> 8;
1576 for (bytes=0, ptr=data; bytes<size; bytes++, ptr++) {
1577 if ((value = NextInt(fstream)) < 0)
1578 RETURN (BitmapFileInvalid);
1586 RETURN (BitmapFileInvalid);
1593 if (x_hot) *x_hot = hx;
1594 if (y_hot) *y_hot = hy;
1596 RETURN (BitmapSuccess);
1600 int read_bitmap_data_from_file (CONST char *filename, unsigned int *width,
1601 unsigned int *height, unsigned char **datap,
1602 int *x_hot, int *y_hot)
1607 if ((fstream = fopen (filename, "r")) == NULL) {
1608 return BitmapOpenFailed;
1610 status = read_bitmap_data (fstream, width, height, datap, x_hot, y_hot);
1614 #endif /* HAVE_X_WINDOWS */
1616 /* this table flips four bits around. */
1617 static int flip_table[] =
1619 0, 8, 4, 12, 2, 10, 6, 14, 1, 9, 5, 13, 3, 11, 7, 15
1622 /* the bitmap data comes in the following format: Widths are padded to
1623 a multiple of 8. Scan lines are stored in increasing byte order
1624 from left to right, little-endian within a byte. 0 = white, 1 =
1625 black. It must be converted to the following format: Widths are
1626 padded to a multiple of 16. Scan lines are stored in increasing
1627 byte order from left to right, big-endian within a byte. 0 =
1628 black, 1 = white. */
1630 xbm_create_bitmap_from_data (HDC hdc, char *data,
1631 unsigned int width, unsigned int height,
1632 int mask, COLORREF fg, COLORREF bg)
1634 int old_width = (width + 7)/8;
1635 int new_width = BPLINE (2*((width + 15)/16));
1636 unsigned char *offset;
1638 unsigned char *new_data, *new_offset;
1640 BITMAPINFO* bmp_info =
1641 xmalloc_and_zero (sizeof(BITMAPINFO) + sizeof(RGBQUAD));
1647 new_data = (unsigned char *) xmalloc_and_zero (height * new_width);
1655 for (i=0; i<height; i++)
1657 offset = data + i*old_width;
1658 new_offset = new_data + i*new_width;
1660 for (j=0; j<old_width; j++)
1662 int byte = offset[j];
1663 new_offset[j] = ~ (unsigned char)
1664 ((flip_table[byte & 0xf] << 4) + flip_table[byte >> 4]);
1668 /* if we want a mask invert the bits */
1671 new_offset = &new_data[height * new_width];
1672 while (new_offset-- != new_data)
1674 *new_offset ^= 0xff;
1678 bmp_info->bmiHeader.biWidth=width;
1679 bmp_info->bmiHeader.biHeight=-(LONG)height;
1680 bmp_info->bmiHeader.biPlanes=1;
1681 bmp_info->bmiHeader.biSize=sizeof(BITMAPINFOHEADER);
1682 bmp_info->bmiHeader.biBitCount=1;
1683 bmp_info->bmiHeader.biCompression=BI_RGB;
1684 bmp_info->bmiHeader.biClrUsed = 2;
1685 bmp_info->bmiHeader.biClrImportant = 2;
1686 bmp_info->bmiHeader.biSizeImage = height * new_width;
1687 bmp_info->bmiColors[0].rgbRed = GetRValue (fg);
1688 bmp_info->bmiColors[0].rgbGreen = GetGValue (fg);
1689 bmp_info->bmiColors[0].rgbBlue = GetBValue (fg);
1690 bmp_info->bmiColors[0].rgbReserved = 0;
1691 bmp_info->bmiColors[1].rgbRed = GetRValue (bg);
1692 bmp_info->bmiColors[1].rgbGreen = GetGValue (bg);
1693 bmp_info->bmiColors[1].rgbBlue = GetBValue (bg);
1694 bmp_info->bmiColors[1].rgbReserved = 0;
1696 bitmap = CreateDIBSection (hdc,
1704 if (!bitmap || !bmp_buf)
1710 /* copy in the actual bitmap */
1711 memcpy (bmp_buf, new_data, height * new_width);
1717 /* Given inline data for a mono pixmap, initialize the given
1718 image instance accordingly. */
1721 init_image_instance_from_xbm_inline (struct Lisp_Image_Instance *ii,
1722 int width, int height,
1723 /* Note that data is in ext-format! */
1725 Lisp_Object instantiator,
1726 Lisp_Object pointer_fg,
1727 Lisp_Object pointer_bg,
1730 Lisp_Object mask_filename)
1732 Lisp_Object device = IMAGE_INSTANCE_DEVICE (ii);
1733 struct frame* f = XFRAME (DEVICE_SELECTED_FRAME (XDEVICE (device)));
1734 Lisp_Object foreground = find_keyword_in_vector (instantiator, Q_foreground);
1735 Lisp_Object background = find_keyword_in_vector (instantiator, Q_background);
1736 enum image_instance_type type;
1737 COLORREF black = PALETTERGB (0,0,0);
1738 COLORREF white = PALETTERGB (255,255,255);
1740 HDC hdc = FRAME_MSWINDOWS_CDC (f);
1742 if (!DEVICE_MSWINDOWS_P (XDEVICE (device)))
1743 signal_simple_error ("Not an MS-Windows device", device);
1745 if ((dest_mask & IMAGE_MONO_PIXMAP_MASK) &&
1746 (dest_mask & IMAGE_COLOR_PIXMAP_MASK))
1748 if (!NILP (foreground) || !NILP (background))
1749 type = IMAGE_COLOR_PIXMAP;
1751 type = IMAGE_MONO_PIXMAP;
1753 else if (dest_mask & IMAGE_MONO_PIXMAP_MASK)
1754 type = IMAGE_MONO_PIXMAP;
1755 else if (dest_mask & IMAGE_COLOR_PIXMAP_MASK)
1756 type = IMAGE_COLOR_PIXMAP;
1757 else if (dest_mask & IMAGE_POINTER_MASK)
1758 type = IMAGE_POINTER;
1760 incompatible_image_types (instantiator, dest_mask,
1761 IMAGE_MONO_PIXMAP_MASK | IMAGE_COLOR_PIXMAP_MASK
1762 | IMAGE_POINTER_MASK);
1764 mswindows_initialize_dibitmap_image_instance (ii, 1, type);
1766 IMAGE_INSTANCE_PIXMAP_FILENAME (ii) =
1767 find_keyword_in_vector (instantiator, Q_file);
1768 IMAGE_INSTANCE_PIXMAP_WIDTH (ii) = width;
1769 IMAGE_INSTANCE_PIXMAP_HEIGHT (ii) = height;
1770 IMAGE_INSTANCE_PIXMAP_DEPTH (ii) = 1;
1771 XSETINT (IMAGE_INSTANCE_PIXMAP_HOTSPOT_X (ii), 0);
1772 XSETINT (IMAGE_INSTANCE_PIXMAP_HOTSPOT_Y (ii), 0);
1773 IMAGE_INSTANCE_MSWINDOWS_MASK (ii) = mask ? mask :
1774 xbm_create_bitmap_from_data (hdc, (Extbyte *) bits, width, height,
1775 TRUE, black, white);
1779 case IMAGE_MONO_PIXMAP:
1780 IMAGE_INSTANCE_MSWINDOWS_BITMAP (ii) =
1781 xbm_create_bitmap_from_data (hdc, (Extbyte *) bits, width, height,
1782 FALSE, black, black);
1785 case IMAGE_COLOR_PIXMAP:
1787 COLORREF fg = black;
1788 COLORREF bg = white;
1790 if (!NILP (foreground) && !COLOR_INSTANCEP (foreground))
1792 Fmake_color_instance (foreground, device,
1793 encode_error_behavior_flag (ERROR_ME));
1795 if (COLOR_INSTANCEP (foreground))
1796 fg = COLOR_INSTANCE_MSWINDOWS_COLOR (XCOLOR_INSTANCE (foreground));
1798 if (!NILP (background) && !COLOR_INSTANCEP (background))
1800 Fmake_color_instance (background, device,
1801 encode_error_behavior_flag (ERROR_ME));
1803 if (COLOR_INSTANCEP (background))
1804 bg = COLOR_INSTANCE_MSWINDOWS_COLOR (XCOLOR_INSTANCE (background));
1806 IMAGE_INSTANCE_PIXMAP_FG (ii) = foreground;
1807 IMAGE_INSTANCE_PIXMAP_BG (ii) = background;
1809 IMAGE_INSTANCE_MSWINDOWS_BITMAP (ii) =
1810 xbm_create_bitmap_from_data (hdc, (Extbyte *) bits, width, height,
1817 COLORREF fg = black;
1818 COLORREF bg = white;
1820 if (NILP (foreground))
1821 foreground = pointer_fg;
1822 if (NILP (background))
1823 background = pointer_bg;
1825 IMAGE_INSTANCE_PIXMAP_HOTSPOT_X (ii) =
1826 find_keyword_in_vector (instantiator, Q_hotspot_x);
1827 IMAGE_INSTANCE_PIXMAP_HOTSPOT_Y (ii) =
1828 find_keyword_in_vector (instantiator, Q_hotspot_y);
1829 IMAGE_INSTANCE_PIXMAP_FG (ii) = foreground;
1830 IMAGE_INSTANCE_PIXMAP_BG (ii) = background;
1831 if (COLOR_INSTANCEP (foreground))
1832 fg = COLOR_INSTANCE_MSWINDOWS_COLOR (XCOLOR_INSTANCE (foreground));
1833 if (COLOR_INSTANCEP (background))
1834 bg = COLOR_INSTANCE_MSWINDOWS_COLOR (XCOLOR_INSTANCE (background));
1836 IMAGE_INSTANCE_MSWINDOWS_BITMAP (ii) =
1837 xbm_create_bitmap_from_data (hdc, (Extbyte *) bits, width, height,
1839 mswindows_initialize_image_instance_icon (ii, TRUE);
1849 xbm_instantiate_1 (Lisp_Object image_instance, Lisp_Object instantiator,
1850 Lisp_Object pointer_fg, Lisp_Object pointer_bg,
1851 int dest_mask, int width, int height,
1852 /* Note that data is in ext-format! */
1855 Lisp_Object mask_data = find_keyword_in_vector (instantiator, Q_mask_data);
1856 Lisp_Object mask_file = find_keyword_in_vector (instantiator, Q_mask_file);
1857 struct Lisp_Image_Instance *ii = XIMAGE_INSTANCE (image_instance);
1858 struct frame* f = XFRAME (DEVICE_SELECTED_FRAME
1859 (XDEVICE (IMAGE_INSTANCE_DEVICE (ii))));
1860 HDC hdc = FRAME_MSWINDOWS_CDC (f);
1862 CONST char *gcc_may_you_rot_in_hell;
1864 if (!NILP (mask_data))
1866 GET_C_STRING_BINARY_DATA_ALLOCA (XCAR (XCDR (XCDR (mask_data))),
1867 gcc_may_you_rot_in_hell);
1869 xbm_create_bitmap_from_data ( hdc,
1871 gcc_may_you_rot_in_hell,
1872 XINT (XCAR (mask_data)),
1873 XINT (XCAR (XCDR (mask_data))), FALSE,
1875 PALETTERGB (255,255,255));
1878 init_image_instance_from_xbm_inline (ii, width, height, bits,
1879 instantiator, pointer_fg, pointer_bg,
1880 dest_mask, mask, mask_file);
1883 /* Instantiate method for XBM's. */
1886 mswindows_xbm_instantiate (Lisp_Object image_instance,
1887 Lisp_Object instantiator,
1888 Lisp_Object pointer_fg, Lisp_Object pointer_bg,
1889 int dest_mask, Lisp_Object domain)
1891 Lisp_Object data = find_keyword_in_vector (instantiator, Q_data);
1892 CONST char *gcc_go_home;
1894 assert (!NILP (data));
1896 GET_C_STRING_BINARY_DATA_ALLOCA (XCAR (XCDR (XCDR (data))),
1899 xbm_instantiate_1 (image_instance, instantiator, pointer_fg,
1900 pointer_bg, dest_mask, XINT (XCAR (data)),
1901 XINT (XCAR (XCDR (data))), gcc_go_home);
1905 /**********************************************************************
1907 **********************************************************************/
1909 /* This is about to get redefined! */
1912 /* We have to define SYSV32 so that compface.h includes string.h
1913 instead of strings.h. */
1918 #include <compface.h>
1922 /* JMP_BUF cannot be used here because if it doesn't get defined
1923 to jmp_buf we end up with a conflicting type error with the
1924 definition in compface.h */
1925 extern jmp_buf comp_env;
1929 mswindows_xface_instantiate (Lisp_Object image_instance, Lisp_Object instantiator,
1930 Lisp_Object pointer_fg, Lisp_Object pointer_bg,
1931 int dest_mask, Lisp_Object domain)
1933 Lisp_Object data = find_keyword_in_vector (instantiator, Q_data);
1935 char *p, *bits, *bp;
1936 CONST char * volatile emsg = 0;
1937 CONST char * volatile dstring;
1939 assert (!NILP (data));
1941 GET_C_STRING_BINARY_DATA_ALLOCA (data, dstring);
1943 if ((p = strchr (dstring, ':')))
1948 /* Must use setjmp not SETJMP because we used jmp_buf above not JMP_BUF */
1949 if (!(stattis = setjmp (comp_env)))
1951 UnCompAll ((char *) dstring);
1958 emsg = "uncompface: internal error";
1961 emsg = "uncompface: insufficient or invalid data";
1964 emsg = "uncompface: excess data ignored";
1969 signal_simple_error_2 (emsg, data, Qimage);
1971 bp = bits = (char *) alloca (PIXELS / 8);
1973 /* the compface library exports char F[], which uses a single byte per
1974 pixel to represent a 48x48 bitmap. Yuck. */
1975 for (i = 0, p = F; i < (PIXELS / 8); ++i)
1978 /* reverse the bit order of each byte... */
1979 for (b = n = 0; b < 8; ++b)
1986 xbm_instantiate_1 (image_instance, instantiator, pointer_fg,
1987 pointer_bg, dest_mask, 48, 48, bits);
1989 #endif /* HAVE_XFACE */
1992 /************************************************************************/
1993 /* image instance methods */
1994 /************************************************************************/
1997 mswindows_print_image_instance (struct Lisp_Image_Instance *p,
1998 Lisp_Object printcharfun,
2003 switch (IMAGE_INSTANCE_TYPE (p))
2005 case IMAGE_MONO_PIXMAP:
2006 case IMAGE_COLOR_PIXMAP:
2008 sprintf (buf, " (0x%lx",
2009 (unsigned long) IMAGE_INSTANCE_MSWINDOWS_BITMAP (p));
2010 write_c_string (buf, printcharfun);
2011 if (IMAGE_INSTANCE_MSWINDOWS_MASK (p))
2013 sprintf (buf, "/0x%lx",
2014 (unsigned long) IMAGE_INSTANCE_MSWINDOWS_MASK (p));
2015 write_c_string (buf, printcharfun);
2017 write_c_string (")", printcharfun);
2025 #ifdef DEBUG_WIDGETS
2026 extern int debug_widget_instances;
2030 mswindows_finalize_image_instance (struct Lisp_Image_Instance *p)
2032 if (DEVICE_LIVE_P (XDEVICE (p->device)))
2034 if (IMAGE_INSTANCE_TYPE (p) == IMAGE_WIDGET
2036 IMAGE_INSTANCE_TYPE (p) == IMAGE_SUBWINDOW)
2038 #ifdef DEBUG_WIDGETS
2039 debug_widget_instances--;
2040 stderr_out ("widget destroyed, %d left\n", debug_widget_instances);
2042 if (IMAGE_INSTANCE_SUBWINDOW_ID (p))
2044 DestroyWindow (WIDGET_INSTANCE_MSWINDOWS_HANDLE (p));
2045 DestroyWindow (IMAGE_INSTANCE_MSWINDOWS_CLIPWINDOW (p));
2046 IMAGE_INSTANCE_SUBWINDOW_ID (p) = 0;
2052 if (IMAGE_INSTANCE_PIXMAP_TIMEOUT (p))
2053 disable_glyph_animated_timeout (IMAGE_INSTANCE_PIXMAP_TIMEOUT (p));
2055 if (IMAGE_INSTANCE_MSWINDOWS_BITMAP_SLICES (p))
2057 for (i = 0; i < IMAGE_INSTANCE_PIXMAP_MAXSLICE (p); i++)
2059 if (IMAGE_INSTANCE_MSWINDOWS_BITMAP_SLICE (p, i))
2060 DeleteObject (IMAGE_INSTANCE_MSWINDOWS_BITMAP_SLICE (p, i));
2061 IMAGE_INSTANCE_MSWINDOWS_BITMAP_SLICE (p, i) = 0;
2063 xfree (IMAGE_INSTANCE_MSWINDOWS_BITMAP_SLICES (p));
2064 IMAGE_INSTANCE_MSWINDOWS_BITMAP_SLICES (p) = 0;
2066 if (IMAGE_INSTANCE_MSWINDOWS_MASK (p))
2067 DeleteObject (IMAGE_INSTANCE_MSWINDOWS_MASK (p));
2068 IMAGE_INSTANCE_MSWINDOWS_MASK (p) = 0;
2069 if (IMAGE_INSTANCE_MSWINDOWS_ICON (p))
2070 DestroyIcon (IMAGE_INSTANCE_MSWINDOWS_ICON (p));
2071 IMAGE_INSTANCE_MSWINDOWS_ICON (p) = 0;
2082 /************************************************************************/
2083 /* subwindow and widget support */
2084 /************************************************************************/
2086 /* unmap the image if it is a widget. This is used by redisplay via
2087 redisplay_unmap_subwindows */
2089 mswindows_unmap_subwindow (struct Lisp_Image_Instance *p)
2091 if (IMAGE_INSTANCE_SUBWINDOW_ID (p))
2093 SetWindowPos (IMAGE_INSTANCE_MSWINDOWS_CLIPWINDOW (p),
2096 SWP_HIDEWINDOW | SWP_NOMOVE | SWP_NOSIZE
2097 | SWP_NOSENDCHANGING);
2101 /* map the subwindow. This is used by redisplay via
2102 redisplay_output_subwindow */
2104 mswindows_map_subwindow (struct Lisp_Image_Instance *p, int x, int y,
2105 struct display_glyph_area* dga)
2107 /* move the window before mapping it ... */
2108 SetWindowPos (IMAGE_INSTANCE_MSWINDOWS_CLIPWINDOW (p),
2110 x, y, dga->width, dga->height,
2112 | SWP_NOCOPYBITS | SWP_NOSENDCHANGING);
2113 /* ... adjust the child ... */
2114 SetWindowPos (WIDGET_INSTANCE_MSWINDOWS_HANDLE (p),
2116 -dga->xoffset, -dga->yoffset, 0, 0,
2117 SWP_NOZORDER | SWP_NOSIZE
2118 | SWP_NOCOPYBITS | SWP_NOSENDCHANGING);
2119 /* ... now map it - we are not allowed to move it at the same time. */
2120 SetWindowPos (IMAGE_INSTANCE_MSWINDOWS_CLIPWINDOW (p),
2123 SWP_NOZORDER | SWP_NOSIZE | SWP_NOMOVE
2124 | SWP_SHOWWINDOW | SWP_NOCOPYBITS
2125 | SWP_NOSENDCHANGING);
2128 /* resize the subwindow instance */
2130 mswindows_resize_subwindow (struct Lisp_Image_Instance* ii, int w, int h)
2132 /* Set the size of the control .... */
2133 SetWindowPos (WIDGET_INSTANCE_MSWINDOWS_HANDLE (ii),
2136 SWP_NOZORDER | SWP_NOMOVE
2137 | SWP_NOCOPYBITS | SWP_NOSENDCHANGING);
2140 /* when you click on a widget you may activate another widget this
2141 needs to be checked and all appropriate widgets updated */
2143 mswindows_update_subwindow (struct Lisp_Image_Instance *p)
2145 if (IMAGE_INSTANCE_TYPE (p) == IMAGE_WIDGET)
2147 /* buttons checked or otherwise */
2148 if ( EQ (IMAGE_INSTANCE_WIDGET_TYPE (p), Qbutton))
2150 if (gui_item_selected_p (IMAGE_INSTANCE_WIDGET_ITEM (p)))
2151 SendMessage (WIDGET_INSTANCE_MSWINDOWS_HANDLE (p),
2152 BM_SETCHECK, (WPARAM)BST_CHECKED, 0);
2154 SendMessage (WIDGET_INSTANCE_MSWINDOWS_HANDLE (p),
2155 BM_SETCHECK, (WPARAM)BST_UNCHECKED, 0);
2158 /* set the widget font from the widget face */
2159 SendMessage (WIDGET_INSTANCE_MSWINDOWS_HANDLE (p),
2161 (WPARAM)FONT_INSTANCE_MSWINDOWS_HFONT
2162 (XFONT_INSTANCE (widget_face_font_info
2163 (IMAGE_INSTANCE_SUBWINDOW_FRAME (p),
2164 IMAGE_INSTANCE_WIDGET_FACE (p),
2166 MAKELPARAM (TRUE, 0));
2170 /* register widgets into our hastable so that we can cope with the
2171 callbacks. The hashtable is weak so deregistration is handled
2174 mswindows_register_gui_item (Lisp_Object gui, Lisp_Object domain)
2176 Lisp_Object frame = FW_FRAME (domain);
2177 struct frame* f = XFRAME (frame);
2178 int id = gui_item_id_hash (FRAME_MSWINDOWS_WIDGET_HASH_TABLE (f),
2181 Fputhash (make_int (id),
2182 XGUI_ITEM (gui)->callback,
2183 FRAME_MSWINDOWS_WIDGET_HASH_TABLE (f));
2188 mswindows_register_widget_instance (Lisp_Object instance, Lisp_Object domain)
2190 return mswindows_register_gui_item (XIMAGE_INSTANCE_WIDGET_ITEM (instance),
2195 mswindows_subwindow_instantiate (Lisp_Object image_instance, Lisp_Object instantiator,
2196 Lisp_Object pointer_fg, Lisp_Object pointer_bg,
2197 int dest_mask, Lisp_Object domain)
2199 struct Lisp_Image_Instance *ii = XIMAGE_INSTANCE (image_instance);
2200 Lisp_Object device = IMAGE_INSTANCE_DEVICE (ii);
2201 struct device* d = XDEVICE (device);
2202 Lisp_Object frame = FW_FRAME (domain);
2205 if (!DEVICE_MSWINDOWS_P (d))
2206 signal_simple_error ("Not an mswindows device", device);
2208 /* have to set the type this late in case there is no device
2209 instantiation for a widget */
2210 IMAGE_INSTANCE_TYPE (ii) = IMAGE_SUBWINDOW;
2211 /* Allocate space for the clip window */
2212 ii->data = xnew_and_zero (struct mswindows_subwindow_data);
2214 if ((IMAGE_INSTANCE_MSWINDOWS_CLIPWINDOW (ii)
2217 XEMACS_CONTROL_CLASS,
2219 WS_CLIPCHILDREN | WS_CLIPSIBLINGS | WS_CHILD,
2220 0, /* starting x position */
2221 0, /* starting y position */
2222 IMAGE_INSTANCE_WIDGET_WIDTH (ii),
2223 IMAGE_INSTANCE_WIDGET_HEIGHT (ii),
2225 FRAME_MSWINDOWS_HANDLE (XFRAME (frame)),
2227 NULL, /* must be null for this class */
2229 signal_simple_error ("window creation failed with code",
2230 make_int (GetLastError()));
2232 wnd = CreateWindow( "STATIC",
2235 0, /* starting x position */
2236 0, /* starting y position */
2237 IMAGE_INSTANCE_WIDGET_WIDTH (ii),
2238 IMAGE_INSTANCE_WIDGET_HEIGHT (ii),
2239 IMAGE_INSTANCE_MSWINDOWS_CLIPWINDOW (ii),
2242 GetWindowLong (FRAME_MSWINDOWS_HANDLE (XFRAME (frame)),
2246 SetWindowLong (wnd, GWL_USERDATA, (LONG)LISP_TO_VOID(image_instance));
2247 IMAGE_INSTANCE_SUBWINDOW_ID (ii) = wnd;
2251 mswindows_image_instance_equal (struct Lisp_Image_Instance *p1,
2252 struct Lisp_Image_Instance *p2, int depth)
2254 switch (IMAGE_INSTANCE_TYPE (p1))
2256 case IMAGE_MONO_PIXMAP:
2257 case IMAGE_COLOR_PIXMAP:
2259 if (IMAGE_INSTANCE_MSWINDOWS_BITMAP (p1)
2260 != IMAGE_INSTANCE_MSWINDOWS_BITMAP (p2))
2271 static unsigned long
2272 mswindows_image_instance_hash (struct Lisp_Image_Instance *p, int depth)
2274 switch (IMAGE_INSTANCE_TYPE (p))
2276 case IMAGE_MONO_PIXMAP:
2277 case IMAGE_COLOR_PIXMAP:
2279 return (unsigned long) IMAGE_INSTANCE_MSWINDOWS_BITMAP (p);
2286 /* Set all the slots in an image instance structure to reasonable
2287 default values. This is used somewhere within an instantiate
2288 method. It is assumed that the device slot within the image
2289 instance is already set -- this is the case when instantiate
2290 methods are called. */
2293 mswindows_initialize_dibitmap_image_instance (struct Lisp_Image_Instance *ii,
2295 enum image_instance_type type)
2297 ii->data = xnew_and_zero (struct mswindows_image_instance_data);
2298 IMAGE_INSTANCE_TYPE (ii) = type;
2299 IMAGE_INSTANCE_PIXMAP_FILENAME (ii) = Qnil;
2300 IMAGE_INSTANCE_PIXMAP_MASK_FILENAME (ii) = Qnil;
2301 IMAGE_INSTANCE_PIXMAP_HOTSPOT_X (ii) = Qnil;
2302 IMAGE_INSTANCE_PIXMAP_HOTSPOT_Y (ii) = Qnil;
2303 IMAGE_INSTANCE_PIXMAP_FG (ii) = Qnil;
2304 IMAGE_INSTANCE_PIXMAP_BG (ii) = Qnil;
2305 IMAGE_INSTANCE_PIXMAP_MAXSLICE (ii) = slices;
2306 IMAGE_INSTANCE_MSWINDOWS_BITMAP_SLICES (ii) =
2307 xnew_array_and_zero (HBITMAP, slices);
2313 /************************************************************************/
2315 /************************************************************************/
2317 mswindows_widget_instantiate (Lisp_Object image_instance, Lisp_Object instantiator,
2318 Lisp_Object pointer_fg, Lisp_Object pointer_bg,
2319 int dest_mask, Lisp_Object domain,
2320 CONST char* class, int flags, int exflags)
2322 /* this function can call lisp */
2323 struct Lisp_Image_Instance *ii = XIMAGE_INSTANCE (image_instance);
2324 Lisp_Object device = IMAGE_INSTANCE_DEVICE (ii), style;
2325 struct device* d = XDEVICE (device);
2326 Lisp_Object frame = FW_FRAME (domain);
2330 Lisp_Object gui = IMAGE_INSTANCE_WIDGET_ITEM (ii);
2331 struct Lisp_Gui_Item* pgui = XGUI_ITEM (gui);
2333 if (!DEVICE_MSWINDOWS_P (d))
2334 signal_simple_error ("Not an mswindows device", device);
2336 if (!gui_item_active_p (gui))
2337 flags |= WS_DISABLED;
2339 style = pgui->style;
2341 if (!NILP (pgui->callback))
2343 id = mswindows_register_widget_instance (image_instance, domain);
2345 /* have to set the type this late in case there is no device
2346 instantiation for a widget */
2347 IMAGE_INSTANCE_TYPE (ii) = IMAGE_WIDGET;
2348 if (!NILP (IMAGE_INSTANCE_WIDGET_TEXT (ii)))
2349 GET_C_STRING_OS_DATA_ALLOCA (IMAGE_INSTANCE_WIDGET_TEXT (ii), nm);
2351 /* allocate space for the clip window and then allocate the clip window */
2352 ii->data = xnew_and_zero (struct mswindows_subwindow_data);
2354 if ((IMAGE_INSTANCE_MSWINDOWS_CLIPWINDOW (ii)
2357 XEMACS_CONTROL_CLASS,
2359 WS_CLIPCHILDREN | WS_CLIPSIBLINGS | WS_CHILD,
2360 0, /* starting x position */
2361 0, /* starting y position */
2362 IMAGE_INSTANCE_WIDGET_WIDTH (ii),
2363 IMAGE_INSTANCE_WIDGET_HEIGHT (ii),
2365 FRAME_MSWINDOWS_HANDLE (XFRAME (frame)),
2366 (HMENU)id, /* No menu */
2367 NULL, /* must be null for this class */
2369 signal_simple_error ("window creation failed with code",
2370 make_int (GetLastError()));
2372 if ((wnd = CreateWindowEx(
2373 exflags /* | WS_EX_NOPARENTNOTIFY*/,
2376 flags | WS_CHILD | WS_VISIBLE,
2377 0, /* starting x position */
2378 0, /* starting y position */
2379 IMAGE_INSTANCE_WIDGET_WIDTH (ii),
2380 IMAGE_INSTANCE_WIDGET_HEIGHT (ii),
2382 IMAGE_INSTANCE_MSWINDOWS_CLIPWINDOW (ii),
2383 (HMENU)id, /* No menu */
2386 (FRAME_MSWINDOWS_HANDLE (XFRAME (frame)),
2389 signal_simple_error ("window creation failed with code",
2390 make_int (GetLastError()));
2392 IMAGE_INSTANCE_SUBWINDOW_ID (ii) = wnd;
2393 SetWindowLong (wnd, GWL_USERDATA, (LONG)LISP_TO_VOID(image_instance));
2394 /* set the widget font from the widget face */
2395 SendMessage (wnd, WM_SETFONT,
2396 (WPARAM)FONT_INSTANCE_MSWINDOWS_HFONT
2397 (XFONT_INSTANCE (widget_face_font_info
2399 IMAGE_INSTANCE_WIDGET_FACE (ii),
2401 MAKELPARAM (TRUE, 0));
2404 /* Instantiate a button widget. Unfortunately instantiated widgets are
2405 particular to a frame since they need to have a parent. It's not
2406 like images where you just select the image into the context you
2407 want to display it in and BitBlt it. So images instances can have a
2408 many-to-one relationship with things you see, whereas widgets can
2409 only be one-to-one (i.e. per frame) */
2411 mswindows_button_instantiate (Lisp_Object image_instance, Lisp_Object instantiator,
2412 Lisp_Object pointer_fg, Lisp_Object pointer_bg,
2413 int dest_mask, Lisp_Object domain)
2415 /* this function can call lisp */
2416 struct Lisp_Image_Instance *ii = XIMAGE_INSTANCE (image_instance);
2418 int flags = BS_NOTIFY;
2420 Lisp_Object gui = IMAGE_INSTANCE_WIDGET_ITEM (ii);
2421 struct Lisp_Gui_Item* pgui = XGUI_ITEM (gui);
2422 Lisp_Object glyph = find_keyword_in_vector (instantiator, Q_image);
2424 if (!gui_item_active_p (gui))
2425 flags |= WS_DISABLED;
2429 if (!IMAGE_INSTANCEP (glyph))
2430 glyph = glyph_image_instance (glyph, domain, ERROR_ME, 1);
2432 if (IMAGE_INSTANCEP (glyph))
2433 flags |= XIMAGE_INSTANCE_MSWINDOWS_BITMAP (glyph) ?
2434 BS_BITMAP : BS_ICON;
2437 style = pgui->style;
2439 if (EQ (style, Qradio))
2441 flags |= BS_RADIOBUTTON;
2443 else if (EQ (style, Qtoggle))
2445 flags |= BS_AUTOCHECKBOX;
2448 flags |= BS_DEFPUSHBUTTON;
2450 mswindows_widget_instantiate (image_instance, instantiator, pointer_fg,
2451 pointer_bg, dest_mask, domain, "BUTTON", flags,
2452 WS_EX_CONTROLPARENT);
2454 wnd = WIDGET_INSTANCE_MSWINDOWS_HANDLE (ii);
2455 /* set the checked state */
2456 if (gui_item_selected_p (gui))
2457 SendMessage (wnd, BM_SETCHECK, (WPARAM)BST_CHECKED, 0);
2459 SendMessage (wnd, BM_SETCHECK, (WPARAM)BST_UNCHECKED, 0);
2460 /* add the image if one was given */
2461 if (!NILP (glyph) && IMAGE_INSTANCEP (glyph))
2463 SendMessage (wnd, BM_SETIMAGE,
2464 (WPARAM) (XIMAGE_INSTANCE_MSWINDOWS_BITMAP (glyph) ?
2465 IMAGE_BITMAP : IMAGE_ICON),
2466 (LPARAM) (XIMAGE_INSTANCE_MSWINDOWS_BITMAP (glyph) ?
2467 XIMAGE_INSTANCE_MSWINDOWS_BITMAP (glyph) :
2468 XIMAGE_INSTANCE_MSWINDOWS_ICON (glyph)));
2472 /* instantiate an edit control */
2474 mswindows_edit_field_instantiate (Lisp_Object image_instance, Lisp_Object instantiator,
2475 Lisp_Object pointer_fg, Lisp_Object pointer_bg,
2476 int dest_mask, Lisp_Object domain)
2478 mswindows_widget_instantiate (image_instance, instantiator, pointer_fg,
2479 pointer_bg, dest_mask, domain, "EDIT",
2480 ES_LEFT | ES_AUTOHSCROLL | WS_TABSTOP
2482 WS_EX_CLIENTEDGE | WS_EX_CONTROLPARENT);
2485 /* instantiate a progress gauge */
2487 mswindows_progress_gauge_instantiate (Lisp_Object image_instance, Lisp_Object instantiator,
2488 Lisp_Object pointer_fg, Lisp_Object pointer_bg,
2489 int dest_mask, Lisp_Object domain)
2492 struct Lisp_Image_Instance *ii = XIMAGE_INSTANCE (image_instance);
2493 mswindows_widget_instantiate (image_instance, instantiator, pointer_fg,
2494 pointer_bg, dest_mask, domain, PROGRESS_CLASS,
2495 WS_TABSTOP | WS_BORDER | PBS_SMOOTH,
2496 WS_EX_CLIENTEDGE | WS_EX_CONTROLPARENT);
2497 wnd = WIDGET_INSTANCE_MSWINDOWS_HANDLE (ii);
2498 /* set the colors */
2499 #ifdef PBS_SETBKCOLOR
2500 SendMessage (wnd, PBS_SETBKCOLOR, 0,
2501 (LPARAM) (COLOR_INSTANCE_MSWINDOWS_COLOR
2504 (XIMAGE_INSTANCE_WIDGET_FACE (ii),
2505 XIMAGE_INSTANCE_SUBWINDOW_FRAME (ii))))));
2507 #ifdef PBS_SETBARCOLOR
2508 SendMessage (wnd, PBS_SETBARCOLOR, 0,
2509 (L:PARAM) (COLOR_INSTANCE_MSWINDOWS_COLOR
2512 (XIMAGE_INSTANCE_WIDGET_FACE (ii),
2513 XIMAGE_INSTANCE_SUBWINDOW_FRAME (ii))))));
2517 /* instantiate a tree view widget */
2518 static HTREEITEM add_tree_item (Lisp_Object image_instance,
2519 HWND wnd, HTREEITEM parent, Lisp_Object item,
2520 int children, Lisp_Object domain)
2522 TV_INSERTSTRUCT tvitem;
2525 tvitem.hParent = parent;
2526 tvitem.hInsertAfter = TVI_LAST;
2527 tvitem.item.mask = TVIF_TEXT | TVIF_CHILDREN;
2528 tvitem.item.cChildren = children;
2530 if (GUI_ITEMP (item))
2532 tvitem.item.lParam = mswindows_register_gui_item (item, domain);
2533 tvitem.item.mask |= TVIF_PARAM;
2534 GET_C_STRING_OS_DATA_ALLOCA (XGUI_ITEM (item)->name,
2535 tvitem.item.pszText);
2538 GET_C_STRING_OS_DATA_ALLOCA (item, tvitem.item.pszText);
2540 tvitem.item.cchTextMax = strlen (tvitem.item.pszText);
2542 if ((ret = (HTREEITEM)SendMessage (wnd, TVM_INSERTITEM,
2543 0, (LPARAM)&tvitem)) == 0)
2544 signal_simple_error ("error adding tree view entry", item);
2549 static void add_tree_item_list (Lisp_Object image_instance,
2550 HWND wnd, HTREEITEM parent, Lisp_Object list,
2555 /* get the first item */
2556 parent = add_tree_item (image_instance, wnd, parent, XCAR (list), TRUE, domain);
2557 /* recursively add items to the tree view */
2558 LIST_LOOP (rest, XCDR (list))
2560 if (LISTP (XCAR (rest)))
2561 add_tree_item_list (image_instance, wnd, parent, XCAR (rest), domain);
2563 add_tree_item (image_instance, wnd, parent, XCAR (rest), FALSE, domain);
2568 mswindows_tree_view_instantiate (Lisp_Object image_instance, Lisp_Object instantiator,
2569 Lisp_Object pointer_fg, Lisp_Object pointer_bg,
2570 int dest_mask, Lisp_Object domain)
2575 struct Lisp_Image_Instance *ii = XIMAGE_INSTANCE (image_instance);
2576 mswindows_widget_instantiate (image_instance, instantiator, pointer_fg,
2577 pointer_bg, dest_mask, domain, WC_TREEVIEW,
2578 WS_TABSTOP | WS_BORDER | PBS_SMOOTH
2579 | TVS_HASLINES | TVS_HASBUTTONS,
2580 WS_EX_CLIENTEDGE | WS_EX_CONTROLPARENT);
2582 wnd = WIDGET_INSTANCE_MSWINDOWS_HANDLE (ii);
2585 parent = add_tree_item (image_instance, wnd, NULL,
2586 XCAR (IMAGE_INSTANCE_WIDGET_ITEMS (ii)),
2589 /* recursively add items to the tree view */
2590 /* add items to the tab */
2591 LIST_LOOP (rest, XCDR (IMAGE_INSTANCE_WIDGET_ITEMS (ii)))
2593 if (LISTP (XCAR (rest)))
2594 add_tree_item_list (image_instance, wnd, parent, XCAR (rest), domain);
2596 add_tree_item (image_instance, wnd, parent, XCAR (rest), FALSE, domain);
2600 /* instantiate a tab control */
2601 static TC_ITEM* add_tab_item (Lisp_Object image_instance,
2602 HWND wnd, Lisp_Object item,
2603 Lisp_Object domain, int index)
2605 TC_ITEM tvitem, *ret;
2607 tvitem.mask = TCIF_TEXT;
2609 if (GUI_ITEMP (item))
2611 tvitem.lParam = mswindows_register_gui_item (item, domain);
2612 tvitem.mask |= TCIF_PARAM;
2613 GET_C_STRING_OS_DATA_ALLOCA (XGUI_ITEM (item)->name,
2618 CHECK_STRING (item);
2619 GET_C_STRING_OS_DATA_ALLOCA (item, tvitem.pszText);
2622 tvitem.cchTextMax = strlen (tvitem.pszText);
2624 if ((ret = (TC_ITEM*)SendMessage (wnd, TCM_INSERTITEM,
2625 index, (LPARAM)&tvitem)) < 0)
2626 signal_simple_error ("error adding tab entry", item);
2632 mswindows_tab_control_instantiate (Lisp_Object image_instance, Lisp_Object instantiator,
2633 Lisp_Object pointer_fg, Lisp_Object pointer_bg,
2634 int dest_mask, Lisp_Object domain)
2639 struct Lisp_Image_Instance *ii = XIMAGE_INSTANCE (image_instance);
2640 mswindows_widget_instantiate (image_instance, instantiator, pointer_fg,
2641 pointer_bg, dest_mask, domain, WC_TABCONTROL,
2642 /* borders don't suit tabs so well */
2644 WS_EX_CONTROLPARENT);
2646 wnd = WIDGET_INSTANCE_MSWINDOWS_HANDLE (ii);
2647 /* add items to the tab */
2648 LIST_LOOP (rest, XCDR (IMAGE_INSTANCE_WIDGET_ITEMS (ii)))
2650 add_tab_item (image_instance, wnd, XCAR (rest), domain, index);
2655 /* set the properties of a tab control */
2657 mswindows_tab_control_set_property (Lisp_Object image_instance, Lisp_Object prop,
2660 struct Lisp_Image_Instance *ii = XIMAGE_INSTANCE (image_instance);
2662 if (EQ (prop, Q_items))
2664 HWND wnd = WIDGET_INSTANCE_MSWINDOWS_HANDLE (ii);
2667 check_valid_item_list_1 (val);
2669 /* delete the pre-existing items */
2670 SendMessage (wnd, TCM_DELETEALLITEMS, 0, 0);
2672 IMAGE_INSTANCE_WIDGET_ITEMS (ii) =
2673 Fcons (XCAR (IMAGE_INSTANCE_WIDGET_ITEMS (ii)),
2674 parse_gui_item_tree_children (val));
2676 /* add items to the tab */
2677 LIST_LOOP (rest, XCDR (IMAGE_INSTANCE_WIDGET_ITEMS (ii)))
2679 add_tab_item (image_instance, wnd, XCAR (rest),
2680 IMAGE_INSTANCE_SUBWINDOW_FRAME (ii), index);
2689 /* instantiate a static control possible for putting other things in */
2691 mswindows_label_instantiate (Lisp_Object image_instance, Lisp_Object instantiator,
2692 Lisp_Object pointer_fg, Lisp_Object pointer_bg,
2693 int dest_mask, Lisp_Object domain)
2695 mswindows_widget_instantiate (image_instance, instantiator, pointer_fg,
2696 pointer_bg, dest_mask, domain, "STATIC",
2697 0, WS_EX_STATICEDGE);
2700 /* instantiate a scrollbar control */
2702 mswindows_scrollbar_instantiate (Lisp_Object image_instance, Lisp_Object instantiator,
2703 Lisp_Object pointer_fg, Lisp_Object pointer_bg,
2704 int dest_mask, Lisp_Object domain)
2706 mswindows_widget_instantiate (image_instance, instantiator, pointer_fg,
2707 pointer_bg, dest_mask, domain, "SCROLLBAR",
2712 /* instantiate a combo control */
2714 mswindows_combo_box_instantiate (Lisp_Object image_instance, Lisp_Object instantiator,
2715 Lisp_Object pointer_fg, Lisp_Object pointer_bg,
2716 int dest_mask, Lisp_Object domain)
2718 struct Lisp_Image_Instance *ii = XIMAGE_INSTANCE (image_instance);
2721 Lisp_Object data = Fplist_get (find_keyword_in_vector (instantiator, Q_properties),
2724 GET_LIST_LENGTH (data, len);
2726 /* Maybe ought to generalise this more but it may be very windows
2727 specific. In windows the window height of a combo box is the
2728 height when the combo box is open. Thus we need to set the height
2729 before creating the window and then reset it to a single line
2730 after the window is created so that redisplay does the right
2732 widget_instantiate_1 (image_instance, instantiator, pointer_fg,
2733 pointer_bg, dest_mask, domain, len + 1, 0, 0);
2735 mswindows_widget_instantiate (image_instance, instantiator, pointer_fg,
2736 pointer_bg, dest_mask, domain, "COMBOBOX",
2737 WS_BORDER | WS_TABSTOP | CBS_DROPDOWN
2739 | CBS_HASSTRINGS | WS_VSCROLL,
2740 WS_EX_CLIENTEDGE | WS_EX_CONTROLPARENT);
2741 /* reset the height */
2742 widget_text_to_pixel_conversion (domain,
2743 IMAGE_INSTANCE_WIDGET_FACE (ii), 1, 0,
2744 &IMAGE_INSTANCE_SUBWINDOW_HEIGHT (ii), 0);
2745 wnd = WIDGET_INSTANCE_MSWINDOWS_HANDLE (ii);
2746 /* add items to the combo box */
2747 SendMessage (wnd, CB_RESETCONTENT, 0, 0);
2748 LIST_LOOP (rest, Fplist_get (IMAGE_INSTANCE_WIDGET_PROPS (ii), Q_items, Qnil))
2751 GET_C_STRING_OS_DATA_ALLOCA (XCAR (rest), lparam);
2752 if (SendMessage (wnd, CB_ADDSTRING, 0, (LPARAM)lparam) == CB_ERR)
2753 signal_simple_error ("error adding combo entries", instantiator);
2757 /* get properties of a control */
2759 mswindows_widget_property (Lisp_Object image_instance, Lisp_Object prop)
2761 struct Lisp_Image_Instance *ii = XIMAGE_INSTANCE (image_instance);
2762 HANDLE wnd = WIDGET_INSTANCE_MSWINDOWS_HANDLE (ii);
2763 /* get the text from a control */
2764 if (EQ (prop, Q_text))
2766 Extcount len = SendMessage (wnd, WM_GETTEXTLENGTH, 0, 0);
2767 Extbyte* buf =alloca (len+1);
2769 SendMessage (wnd, WM_GETTEXT, (WPARAM)len+1, (LPARAM) buf);
2770 return build_ext_string (buf, FORMAT_OS);
2775 /* get properties of a button */
2777 mswindows_button_property (Lisp_Object image_instance, Lisp_Object prop)
2779 struct Lisp_Image_Instance *ii = XIMAGE_INSTANCE (image_instance);
2780 HANDLE wnd = WIDGET_INSTANCE_MSWINDOWS_HANDLE (ii);
2781 /* check the state of a button */
2782 if (EQ (prop, Q_selected))
2784 if (SendMessage (wnd, BM_GETSTATE, 0, 0) & BST_CHECKED)
2792 /* get properties of a combo box */
2794 mswindows_combo_box_property (Lisp_Object image_instance, Lisp_Object prop)
2796 struct Lisp_Image_Instance *ii = XIMAGE_INSTANCE (image_instance);
2797 HANDLE wnd = WIDGET_INSTANCE_MSWINDOWS_HANDLE (ii);
2798 /* get the text from a control */
2799 if (EQ (prop, Q_text))
2801 long item = SendMessage (wnd, CB_GETCURSEL, 0, 0);
2802 Extcount len = SendMessage (wnd, CB_GETLBTEXTLEN, (WPARAM)item, 0);
2803 Extbyte* buf = alloca (len+1);
2804 SendMessage (wnd, CB_GETLBTEXT, (WPARAM)item, (LPARAM)buf);
2805 return build_ext_string (buf, FORMAT_OS);
2810 /* set the properties of a control */
2812 mswindows_widget_set_property (Lisp_Object image_instance, Lisp_Object prop,
2815 struct Lisp_Image_Instance *ii = XIMAGE_INSTANCE (image_instance);
2817 if (EQ (prop, Q_text))
2821 GET_C_STRING_OS_DATA_ALLOCA (val, lparam);
2822 SendMessage (WIDGET_INSTANCE_MSWINDOWS_HANDLE (ii),
2823 WM_SETTEXT, 0, (LPARAM)lparam);
2829 /* set the properties of a progres guage */
2831 mswindows_progress_gauge_set_property (Lisp_Object image_instance, Lisp_Object prop,
2834 struct Lisp_Image_Instance *ii = XIMAGE_INSTANCE (image_instance);
2836 if (EQ (prop, Q_percent))
2839 SendMessage (WIDGET_INSTANCE_MSWINDOWS_HANDLE (ii),
2840 PBM_SETPOS, (WPARAM)XINT (val), 0);
2847 mswindows_control_wnd_proc (HWND hwnd, UINT message,
2848 WPARAM wParam, LPARAM lParam)
2854 case WM_CTLCOLORBTN:
2855 case WM_CTLCOLORLISTBOX:
2856 case WM_CTLCOLOREDIT:
2857 case WM_CTLCOLORSTATIC:
2858 case WM_CTLCOLORSCROLLBAR:
2860 return mswindows_wnd_proc (GetParent (hwnd), message, wParam, lParam);
2862 return DefWindowProc (hwnd, message, wParam, lParam);
2866 #endif /* HAVE_WIDGETS */
2869 /************************************************************************/
2870 /* initialization */
2871 /************************************************************************/
2874 syms_of_glyphs_mswindows (void)
2876 defkeyword (&Q_resource_id, ":resource-id");
2877 defkeyword (&Q_resource_type, ":resource-type");
2881 console_type_create_glyphs_mswindows (void)
2885 CONSOLE_HAS_METHOD (mswindows, print_image_instance);
2886 CONSOLE_HAS_METHOD (mswindows, finalize_image_instance);
2887 CONSOLE_HAS_METHOD (mswindows, unmap_subwindow);
2888 CONSOLE_HAS_METHOD (mswindows, map_subwindow);
2889 CONSOLE_HAS_METHOD (mswindows, update_subwindow);
2890 CONSOLE_HAS_METHOD (mswindows, image_instance_equal);
2891 CONSOLE_HAS_METHOD (mswindows, image_instance_hash);
2892 CONSOLE_HAS_METHOD (mswindows, init_image_instance_from_eimage);
2893 CONSOLE_HAS_METHOD (mswindows, locate_pixmap_file);
2894 CONSOLE_HAS_METHOD (mswindows, resize_subwindow);
2898 image_instantiator_format_create_glyphs_mswindows (void)
2900 IIFORMAT_VALID_CONSOLE (mswindows, nothing);
2901 IIFORMAT_VALID_CONSOLE (mswindows, string);
2902 IIFORMAT_VALID_CONSOLE (mswindows, layout);
2903 IIFORMAT_VALID_CONSOLE (mswindows, formatted_string);
2904 IIFORMAT_VALID_CONSOLE (mswindows, inherit);
2905 /* image-instantiator types */
2907 INITIALIZE_DEVICE_IIFORMAT (mswindows, xpm);
2908 IIFORMAT_HAS_DEVMETHOD (mswindows, xpm, instantiate);
2910 INITIALIZE_DEVICE_IIFORMAT (mswindows, xbm);
2911 IIFORMAT_HAS_DEVMETHOD (mswindows, xbm, instantiate);
2913 INITIALIZE_DEVICE_IIFORMAT (mswindows, xface);
2914 IIFORMAT_HAS_DEVMETHOD (mswindows, xface, instantiate);
2917 IIFORMAT_VALID_CONSOLE (mswindows, jpeg);
2920 IIFORMAT_VALID_CONSOLE (mswindows, tiff);
2923 IIFORMAT_VALID_CONSOLE (mswindows, png);
2926 IIFORMAT_VALID_CONSOLE (mswindows, gif);
2930 INITIALIZE_DEVICE_IIFORMAT (mswindows, button);
2931 IIFORMAT_HAS_DEVMETHOD (mswindows, button, property);
2932 IIFORMAT_HAS_DEVMETHOD (mswindows, button, instantiate);
2934 INITIALIZE_DEVICE_IIFORMAT (mswindows, edit_field);
2935 IIFORMAT_HAS_DEVMETHOD (mswindows, edit_field, instantiate);
2937 INITIALIZE_DEVICE_IIFORMAT (mswindows, subwindow);
2938 IIFORMAT_HAS_DEVMETHOD (mswindows, subwindow, instantiate);
2940 INITIALIZE_DEVICE_IIFORMAT (mswindows, widget);
2941 IIFORMAT_HAS_DEVMETHOD (mswindows, widget, property);
2942 IIFORMAT_HAS_DEVMETHOD (mswindows, widget, set_property);
2945 INITIALIZE_DEVICE_IIFORMAT (mswindows, label);
2946 IIFORMAT_HAS_DEVMETHOD (mswindows, label, instantiate);
2949 INITIALIZE_DEVICE_IIFORMAT (mswindows, combo_box);
2950 IIFORMAT_HAS_DEVMETHOD (mswindows, combo_box, property);
2951 IIFORMAT_HAS_DEVMETHOD (mswindows, combo_box, instantiate);
2954 INITIALIZE_DEVICE_IIFORMAT (mswindows, scrollbar);
2955 IIFORMAT_HAS_DEVMETHOD (mswindows, scrollbar, instantiate);
2957 /* progress gauge */
2958 INITIALIZE_DEVICE_IIFORMAT (mswindows, progress_gauge);
2959 IIFORMAT_HAS_DEVMETHOD (mswindows, progress_gauge, set_property);
2960 IIFORMAT_HAS_DEVMETHOD (mswindows, progress_gauge, instantiate);
2962 /* tree view widget */
2963 INITIALIZE_DEVICE_IIFORMAT (mswindows, tree_view);
2964 /* IIFORMAT_HAS_DEVMETHOD (mswindows, progress, set_property);*/
2965 IIFORMAT_HAS_DEVMETHOD (mswindows, tree_view, instantiate);
2967 /* tab control widget */
2968 INITIALIZE_DEVICE_IIFORMAT (mswindows, tab_control);
2969 IIFORMAT_HAS_DEVMETHOD (mswindows, tab_control, instantiate);
2970 IIFORMAT_HAS_DEVMETHOD (mswindows, tab_control, set_property);
2972 /* windows bitmap format */
2973 INITIALIZE_IMAGE_INSTANTIATOR_FORMAT (bmp, "bmp");
2974 IIFORMAT_HAS_METHOD (bmp, validate);
2975 IIFORMAT_HAS_METHOD (bmp, normalize);
2976 IIFORMAT_HAS_METHOD (bmp, possible_dest_types);
2977 IIFORMAT_HAS_METHOD (bmp, instantiate);
2979 IIFORMAT_VALID_KEYWORD (bmp, Q_data, check_valid_string);
2980 IIFORMAT_VALID_KEYWORD (bmp, Q_file, check_valid_string);
2981 IIFORMAT_VALID_CONSOLE (mswindows, bmp);
2983 /* mswindows resources */
2984 INITIALIZE_IMAGE_INSTANTIATOR_FORMAT (mswindows_resource,
2985 "mswindows-resource");
2987 IIFORMAT_HAS_METHOD (mswindows_resource, validate);
2988 IIFORMAT_HAS_METHOD (mswindows_resource, normalize);
2989 IIFORMAT_HAS_METHOD (mswindows_resource, possible_dest_types);
2990 IIFORMAT_HAS_METHOD (mswindows_resource, instantiate);
2992 IIFORMAT_VALID_KEYWORD (mswindows_resource, Q_resource_type,
2993 check_valid_resource_symbol);
2994 IIFORMAT_VALID_KEYWORD (mswindows_resource, Q_resource_id, check_valid_resource_id);
2995 IIFORMAT_VALID_KEYWORD (mswindows_resource, Q_file, check_valid_string);
2996 IIFORMAT_VALID_CONSOLE (mswindows, mswindows_resource);
3000 vars_of_glyphs_mswindows (void)
3002 DEFVAR_LISP ("mswindows-bitmap-file-path", &Vmswindows_bitmap_file_path /*
3003 A list of the directories in which mswindows bitmap files may be found.
3004 This is used by the `make-image-instance' function.
3006 Vmswindows_bitmap_file_path = Qnil;
3010 complex_vars_of_glyphs_mswindows (void)