X-Git-Url: http://git.chise.org/gitweb/?a=blobdiff_plain;f=src%2Fglyphs-msw.c;h=72902aa3ea00d669311306feb43284b66251cce5;hb=bbf3133177a15f214e3d0060e168ed86dbeed8a2;hp=34e4130486d18a6c3cd3ff9642c45d2d0001626d;hpb=35adcaaeafb1fe93eaf00c39b48619e8f188ff3f;p=chise%2Fxemacs-chise.git.1 diff --git a/src/glyphs-msw.c b/src/glyphs-msw.c index 34e4130..72902aa 100644 --- a/src/glyphs-msw.c +++ b/src/glyphs-msw.c @@ -1,6 +1,6 @@ -/* mswindows-specific Lisp objects. - Copyright (C) 1998 Andy Piper. - +/* mswindows-specific glyph objects. + Copyright (C) 1998, 1999, 2000 Andy Piper. + This file is part of XEmacs. XEmacs is free software; you can redistribute it and/or modify it @@ -20,7 +20,7 @@ Boston, MA 02111-1307, USA. */ /* Synched up with: Not in FSF. */ -/* written by Andy Piper plagerising buts from +/* written by Andy Piper plagiarising bits from glyphs-x.c */ #include @@ -32,6 +32,8 @@ Boston, MA 02111-1307, USA. */ #include "glyphs-msw.h" #include "objects-msw.h" +#include "window.h" +#include "elhash.h" #include "buffer.h" #include "frame.h" #include "insdel.h" @@ -45,7 +47,50 @@ Boston, MA 02111-1307, USA. */ #endif #include #include +#ifdef HAVE_XFACE +#include +#endif +#define WIDGET_GLYPH_SLOT 0 + +DECLARE_IMAGE_INSTANTIATOR_FORMAT (nothing); +DECLARE_IMAGE_INSTANTIATOR_FORMAT (string); +DECLARE_IMAGE_INSTANTIATOR_FORMAT (formatted_string); +DECLARE_IMAGE_INSTANTIATOR_FORMAT (inherit); +#ifdef HAVE_JPEG +DECLARE_IMAGE_INSTANTIATOR_FORMAT (jpeg); +#endif +#ifdef HAVE_TIFF +DECLARE_IMAGE_INSTANTIATOR_FORMAT (tiff); +#endif +#ifdef HAVE_PNG +DECLARE_IMAGE_INSTANTIATOR_FORMAT (png); +#endif +#ifdef HAVE_GIF +DECLARE_IMAGE_INSTANTIATOR_FORMAT (gif); +#endif +#ifdef HAVE_XPM +DEFINE_DEVICE_IIFORMAT (mswindows, xpm); +DEFINE_DEVICE_IIFORMAT (msprinter, xpm); +#endif +DEFINE_DEVICE_IIFORMAT (mswindows, xbm); +DEFINE_DEVICE_IIFORMAT (msprinter, xbm); +#ifdef HAVE_XFACE +DEFINE_DEVICE_IIFORMAT (mswindows, xface); +DEFINE_DEVICE_IIFORMAT (msprinter, xface); +#endif +DECLARE_IMAGE_INSTANTIATOR_FORMAT (layout); +DEFINE_DEVICE_IIFORMAT (mswindows, native_layout); +DEFINE_DEVICE_IIFORMAT (mswindows, button); +DEFINE_DEVICE_IIFORMAT (mswindows, edit_field); +DEFINE_DEVICE_IIFORMAT (mswindows, subwindow); +DEFINE_DEVICE_IIFORMAT (mswindows, widget); +DEFINE_DEVICE_IIFORMAT (mswindows, label); +DEFINE_DEVICE_IIFORMAT (mswindows, scrollbar); +DEFINE_DEVICE_IIFORMAT (mswindows, combo_box); +DEFINE_DEVICE_IIFORMAT (mswindows, progress_gauge); +DEFINE_DEVICE_IIFORMAT (mswindows, tree_view); +DEFINE_DEVICE_IIFORMAT (mswindows, tab_control); DEFINE_IMAGE_INSTANTIATOR_FORMAT (bmp); Lisp_Object Qbmp; @@ -57,13 +102,60 @@ Lisp_Object Q_resource_type, Q_resource_id; Lisp_Object Qmswindows_resource; static void -mswindows_initialize_dibitmap_image_instance (struct Lisp_Image_Instance *ii, - enum image_instance_type type); +mswindows_initialize_dibitmap_image_instance (Lisp_Image_Instance *ii, + int slices, + enum image_instance_type type); static void -mswindows_initialize_image_instance_mask (struct Lisp_Image_Instance* image, - struct frame* f); +mswindows_initialize_image_instance_mask (Lisp_Image_Instance* image, + HDC hcdc); + +/* + * Given device D, retrieve compatible device context. D can be either + * mswindows or an msprinter device. + */ +inline static HDC +get_device_compdc (struct device *d) +{ + if (DEVICE_MSWINDOWS_P (d)) + return DEVICE_MSWINDOWS_HCDC (d); + else + return DEVICE_MSPRINTER_HCDC (d); +} -COLORREF mswindows_string_to_color (CONST char *name); +/* + * Initialize image instance pixel sizes in II. For a display bitmap, + * these will be same as real bitmap sizes. For a printer bitmap, + * these will be scaled up so that the bitmap is proportionally enlarged + * when output to printer. Redisplay code takes care of scaling, to + * conserve memory we do not really scale bitmaps. Set the watermark + * only here. + * #### Add support for unscalable bitmaps. + */ +static void init_image_instance_geometry (Lisp_Image_Instance *ii) +{ + struct device *d = DOMAIN_XDEVICE (ii->domain); + + if (/* #### Scaleable && */ DEVICE_MSPRINTER_P (d)) + { + HDC printer_dc = DEVICE_MSPRINTER_HCDC (d); + HDC display_dc = CreateCompatibleDC (NULL); + IMAGE_INSTANCE_PIXMAP_WIDTH (ii) = + MulDiv (IMAGE_INSTANCE_MSWINDOWS_BITMAP_REAL_WIDTH (ii), + GetDeviceCaps (printer_dc, LOGPIXELSX), + GetDeviceCaps (display_dc, LOGPIXELSX)); + IMAGE_INSTANCE_PIXMAP_HEIGHT (ii) = + MulDiv (IMAGE_INSTANCE_MSWINDOWS_BITMAP_REAL_HEIGHT (ii), + GetDeviceCaps (printer_dc, LOGPIXELSY), + GetDeviceCaps (display_dc, LOGPIXELSY)); + } + else + { + IMAGE_INSTANCE_PIXMAP_WIDTH (ii) = + IMAGE_INSTANCE_MSWINDOWS_BITMAP_REAL_WIDTH (ii); + IMAGE_INSTANCE_PIXMAP_HEIGHT (ii) = + IMAGE_INSTANCE_MSWINDOWS_BITMAP_REAL_HEIGHT (ii); + } +} #define BPLINE(width) ((int)(~3UL & (unsigned long)((width) +3))) @@ -84,7 +176,7 @@ static BITMAPINFO* convert_EImage_to_DIBitmap (Lisp_Object device, BITMAPINFO* bmp_info; unsigned char *ip, *dp; - if (DEVICE_MSWINDOWS_BITSPIXEL (d) > 0) + if (GetDeviceCaps (get_device_compdc (d), BITSPIXEL) > 0) { int bpline = BPLINE(width * 3); /* FIXME: we can do this because 24bpp implies no color table, once @@ -95,7 +187,7 @@ static BITMAPINFO* convert_EImage_to_DIBitmap (Lisp_Object device, * structure - unless it has memory / color allocation implications * .... */ bmp_info=xnew_and_zero (BITMAPINFO); - + if (!bmp_info) { return NULL; @@ -103,7 +195,7 @@ static BITMAPINFO* convert_EImage_to_DIBitmap (Lisp_Object device, bmp_info->bmiHeader.biBitCount=24; /* just RGB triples for now */ bmp_info->bmiHeader.biCompression=BI_RGB; /* just RGB triples for now */ - bmp_info->bmiHeader.biSizeImage=width*height*3; + bmp_info->bmiHeader.biSizeImage=width*height*3; /* bitmap data needs to be in blue, green, red triples - in that order, eimage is in RGB format so we need to convert */ @@ -139,7 +231,7 @@ static BITMAPINFO* convert_EImage_to_DIBitmap (Lisp_Object device, /* use our quantize table to allocate the colors */ ncolors = qtable->num_active_colors; - bmp_info=(BITMAPINFO*)xmalloc_and_zero (sizeof(BITMAPINFOHEADER) + + bmp_info=(BITMAPINFO*)xmalloc_and_zero (sizeof(BITMAPINFOHEADER) + sizeof(RGBQUAD) * ncolors); if (!bmp_info) { @@ -149,12 +241,12 @@ static BITMAPINFO* convert_EImage_to_DIBitmap (Lisp_Object device, colortbl=(RGBQUAD*)(((unsigned char*)bmp_info)+sizeof(BITMAPINFOHEADER)); - bmp_info->bmiHeader.biBitCount=8; - bmp_info->bmiHeader.biCompression=BI_RGB; + bmp_info->bmiHeader.biBitCount=8; + bmp_info->bmiHeader.biCompression=BI_RGB; bmp_info->bmiHeader.biSizeImage=bpline*height; - bmp_info->bmiHeader.biClrUsed=ncolors; - bmp_info->bmiHeader.biClrImportant=ncolors; - + bmp_info->bmiHeader.biClrUsed=ncolors; + bmp_info->bmiHeader.biClrImportant=ncolors; + *bmp_data = (unsigned char *) xmalloc_and_zero (bpline * height); *bit_count = bpline * height; @@ -164,36 +256,39 @@ static BITMAPINFO* convert_EImage_to_DIBitmap (Lisp_Object device, xfree (bmp_info); return NULL; } - + /* build up an RGBQUAD colortable */ - for (i = 0; i < qtable->num_active_colors; i++) { - colortbl[i].rgbRed = (BYTE) qtable->rm[i]; - colortbl[i].rgbGreen = (BYTE) qtable->gm[i]; - colortbl[i].rgbBlue = (BYTE) qtable->bm[i]; - colortbl[i].rgbReserved = 0; - } + for (i = 0; i < qtable->num_active_colors; i++) + { + colortbl[i].rgbRed = (BYTE) qtable->rm[i]; + colortbl[i].rgbGreen = (BYTE) qtable->gm[i]; + colortbl[i].rgbBlue = (BYTE) qtable->bm[i]; + colortbl[i].rgbReserved = 0; + } /* now build up the data. picture has to be upside-down and back-to-front for msw bitmaps */ ip = pic; - for (i = height-1; i >= 0; i--) { - dp = (*bmp_data) + (i * bpline); - for (j = 0; j < width; j++) { - rd = *ip++; - gr = *ip++; - bl = *ip++; - *dp++ = QUANT_GET_COLOR (qtable,rd,gr,bl); + for (i = height-1; i >= 0; i--) + { + dp = (*bmp_data) + (i * bpline); + for (j = 0; j < width; j++) + { + rd = *ip++; + gr = *ip++; + bl = *ip++; + *dp++ = QUANT_GET_COLOR (qtable,rd,gr,bl); + } } - } xfree (qtable); - } + } /* fix up the standard stuff */ bmp_info->bmiHeader.biWidth=width; bmp_info->bmiHeader.biHeight=height; bmp_info->bmiHeader.biPlanes=1; bmp_info->bmiHeader.biSize=sizeof(BITMAPINFOHEADER); bmp_info->bmiHeader.biXPelsPerMeter=0; /* unless you know better */ - bmp_info->bmiHeader.biYPelsPerMeter=0; + bmp_info->bmiHeader.biYPelsPerMeter=0; return bmp_info; } @@ -217,21 +312,21 @@ mswindows_locate_pixmap_file (Lisp_Object name) (IS_DIRECTORY_SEP(XSTRING_BYTE (name, 2))))))) { if (!NILP (Ffile_readable_p (name))) - return name; + return Fexpand_file_name (name, Qnil); else return Qnil; } - if (locate_file (Vmswindows_bitmap_file_path, name, "", &found, R_OK) < 0) + if (locate_file (Vmswindows_bitmap_file_path, name, Qnil, &found, R_OK) < 0) { Lisp_Object temp = list1 (Vdata_directory); struct gcpro gcpro1; GCPRO1 (temp); - locate_file (temp, name, "", &found, R_OK); + locate_file (temp, name, Qnil, &found, R_OK); UNGCPRO; } - + return found; } @@ -244,45 +339,36 @@ mswindows_locate_pixmap_file (Lisp_Object name) in the error message. */ static void -init_image_instance_from_dibitmap (struct Lisp_Image_Instance *ii, +init_image_instance_from_dibitmap (Lisp_Image_Instance *ii, BITMAPINFO *bmp_info, int dest_mask, void *bmp_data, int bmp_bits, - Lisp_Object instantiator, + int slices, + Lisp_Object instantiator, int x_hot, int y_hot, int create_mask) { - Lisp_Object device = IMAGE_INSTANCE_DEVICE (ii); - struct device *d = XDEVICE (device); - struct frame *f; + struct device *d = XDEVICE (IMAGE_INSTANCE_DEVICE (ii)); void* bmp_buf=0; - int type; + enum image_instance_type type; HBITMAP bitmap; HDC hdc; - if (!DEVICE_MSWINDOWS_P (d)) - signal_simple_error ("Not an mswindows device", device); - - if (NILP (DEVICE_SELECTED_FRAME (d))) - signal_simple_error ("No selected frame on mswindows device", device); - - f = XFRAME (DEVICE_SELECTED_FRAME (d)); - if (dest_mask & IMAGE_COLOR_PIXMAP_MASK) type = IMAGE_COLOR_PIXMAP; else if (dest_mask & IMAGE_POINTER_MASK) type = IMAGE_POINTER; - else + else incompatible_image_types (instantiator, dest_mask, IMAGE_COLOR_PIXMAP_MASK | IMAGE_POINTER_MASK); - hdc = FRAME_MSWINDOWS_CDC (f); - bitmap=CreateDIBSection (hdc, - bmp_info, - DIB_RGB_COLORS, - &bmp_buf, - 0,0); + hdc = get_device_compdc (d); + bitmap = CreateDIBSection (hdc, + bmp_info, + DIB_RGB_COLORS, + &bmp_buf, + 0, 0); if (!bitmap || !bmp_buf) signal_simple_error ("Unable to create bitmap", instantiator); @@ -290,24 +376,29 @@ init_image_instance_from_dibitmap (struct Lisp_Image_Instance *ii, /* copy in the actual bitmap */ memcpy (bmp_buf, bmp_data, bmp_bits); - mswindows_initialize_dibitmap_image_instance (ii, type); + mswindows_initialize_dibitmap_image_instance (ii, slices, type); IMAGE_INSTANCE_PIXMAP_FILENAME (ii) = find_keyword_in_vector (instantiator, Q_file); + /* Fixup a set of bitmaps. */ IMAGE_INSTANCE_MSWINDOWS_BITMAP (ii) = bitmap; + IMAGE_INSTANCE_MSWINDOWS_MASK (ii) = NULL; - IMAGE_INSTANCE_PIXMAP_WIDTH (ii) = bmp_info->bmiHeader.biWidth; - IMAGE_INSTANCE_PIXMAP_HEIGHT (ii) = bmp_info->bmiHeader.biHeight; - IMAGE_INSTANCE_PIXMAP_DEPTH (ii) = bmp_info->bmiHeader.biBitCount; + IMAGE_INSTANCE_MSWINDOWS_BITMAP_REAL_WIDTH (ii) = + bmp_info->bmiHeader.biWidth; + IMAGE_INSTANCE_MSWINDOWS_BITMAP_REAL_HEIGHT (ii) = + bmp_info->bmiHeader.biHeight; + IMAGE_INSTANCE_PIXMAP_DEPTH (ii) = bmp_info->bmiHeader.biBitCount; XSETINT (IMAGE_INSTANCE_PIXMAP_HOTSPOT_X (ii), x_hot); XSETINT (IMAGE_INSTANCE_PIXMAP_HOTSPOT_Y (ii), y_hot); + init_image_instance_geometry (ii); if (create_mask) { - mswindows_initialize_image_instance_mask (ii, f); + mswindows_initialize_image_instance_mask (ii, hdc); } - + if (type == IMAGE_POINTER) { mswindows_initialize_image_instance_icon(ii, TRUE); @@ -315,9 +406,35 @@ init_image_instance_from_dibitmap (struct Lisp_Image_Instance *ii, } static void -mswindows_init_image_instance_from_eimage (struct Lisp_Image_Instance *ii, +image_instance_add_dibitmap (Lisp_Image_Instance *ii, + BITMAPINFO *bmp_info, + void *bmp_data, + int bmp_bits, + int slice, + Lisp_Object instantiator) +{ + struct device *d = XDEVICE (IMAGE_INSTANCE_DEVICE (ii)); + void* bmp_buf=0; + + HBITMAP bitmap = CreateDIBSection (get_device_compdc (d), + bmp_info, + DIB_RGB_COLORS, + &bmp_buf, + 0,0); + + if (!bitmap || !bmp_buf) + signal_simple_error ("Unable to create bitmap", instantiator); + + /* copy in the actual bitmap */ + memcpy (bmp_buf, bmp_data, bmp_bits); + IMAGE_INSTANCE_MSWINDOWS_BITMAP_SLICE (ii, slice) = bitmap; +} + +static void +mswindows_init_image_instance_from_eimage (Lisp_Image_Instance *ii, int width, int height, - unsigned char *eimage, + int slices, + unsigned char *eimage, int dest_mask, Lisp_Object instantiator, Lisp_Object domain) @@ -327,79 +444,86 @@ mswindows_init_image_instance_from_eimage (struct Lisp_Image_Instance *ii, unsigned char* bmp_data; int bmp_bits; COLORREF bkcolor; - - if (!DEVICE_MSWINDOWS_P (XDEVICE (device))) - signal_simple_error ("Not an mswindows device", device); + int slice; + + CHECK_MSGDI_DEVICE (device); /* this is a hack but MaskBlt and TransparentBlt are not supported on most windows variants */ - bkcolor = COLOR_INSTANCE_MSWINDOWS_COLOR + bkcolor = COLOR_INSTANCE_MSWINDOWS_COLOR (XCOLOR_INSTANCE (FACE_BACKGROUND (Vdefault_face, domain))); - /* build a bitmap from the eimage */ - if (!(bmp_info=convert_EImage_to_DIBitmap (device, width, height, eimage, - &bmp_bits, &bmp_data))) + for (slice = 0; slice < slices; slice++) { - signal_simple_error ("EImage to DIBitmap conversion failed", - instantiator); - } + /* build a bitmap from the eimage */ + if (!(bmp_info=convert_EImage_to_DIBitmap (device, width, height, + eimage + (width * height * 3 * slice), + &bmp_bits, &bmp_data))) + { + signal_simple_error ("EImage to DIBitmap conversion failed", + instantiator); + } - /* Now create the pixmap and set up the image instance */ - init_image_instance_from_dibitmap (ii, bmp_info, dest_mask, - bmp_data, bmp_bits, instantiator, - 0, 0, 0); + /* Now create the pixmap and set up the image instance */ + if (slice == 0) + init_image_instance_from_dibitmap (ii, bmp_info, dest_mask, + bmp_data, bmp_bits, slices, instantiator, + 0, 0, 0); + else + image_instance_add_dibitmap (ii, bmp_info, bmp_data, bmp_bits, slice, + instantiator); - xfree (bmp_info); - xfree (bmp_data); + xfree (bmp_info); + xfree (bmp_data); + } } -static void set_mono_pixel ( unsigned char* bits, - int bpline, int height, - int x, int y, int white ) -{ - int index; - unsigned char bitnum; +inline static void +set_mono_pixel (unsigned char* bits, + int bpline, int height, + int x, int y, int white) +{ + int i; + unsigned char bitnum; /* Find the byte on which this scanline begins */ - index = (height - y - 1) * bpline; + i = (height - y - 1) * bpline; /* Find the byte containing this pixel */ - index += (x >> 3); + i += (x >> 3); /* Which bit is it? */ - bitnum = (unsigned char)( 7 - (x % 8) ); - if( white ) /* Turn it on */ - bits[index] |= (1<bmiHeader.biWidth=IMAGE_INSTANCE_PIXMAP_WIDTH (image); + bmp_info->bmiHeader.biWidth=IMAGE_INSTANCE_MSWINDOWS_BITMAP_REAL_WIDTH (image); bmp_info->bmiHeader.biHeight = height; - bmp_info->bmiHeader.biPlanes=1; + bmp_info->bmiHeader.biPlanes = 1; bmp_info->bmiHeader.biSize=sizeof(BITMAPINFOHEADER); - bmp_info->bmiHeader.biBitCount=1; - bmp_info->bmiHeader.biCompression=BI_RGB; - bmp_info->bmiHeader.biClrUsed = 2; - bmp_info->bmiHeader.biClrImportant = 2; - bmp_info->bmiHeader.biSizeImage = height * maskbpline; + bmp_info->bmiHeader.biBitCount = 1; + bmp_info->bmiHeader.biCompression = BI_RGB; + bmp_info->bmiHeader.biClrUsed = 2; + bmp_info->bmiHeader.biClrImportant = 2; + bmp_info->bmiHeader.biSizeImage = height * maskbpline; bmp_info->bmiColors[0].rgbRed = 0; bmp_info->bmiColors[0].rgbGreen = 0; bmp_info->bmiColors[0].rgbBlue = 0; @@ -408,11 +532,11 @@ mswindows_initialize_image_instance_mask (struct Lisp_Image_Instance* image, bmp_info->bmiColors[1].rgbGreen = 255; bmp_info->bmiColors[1].rgbBlue = 255; bmp_info->bmiColors[0].rgbReserved = 0; - - if (!(mask = CreateDIBSection (hcdc, + + if (!(mask = CreateDIBSection (hcdc, bmp_info, DIB_RGB_COLORS, - &and_bits, + (void**)&and_bits, 0,0))) { xfree (bmp_info); @@ -423,17 +547,17 @@ mswindows_initialize_image_instance_mask (struct Lisp_Image_Instance* image, /* build up an in-memory set of bits to mess with */ xzero (*bmp_info); - bmp_info->bmiHeader.biWidth=IMAGE_INSTANCE_PIXMAP_WIDTH (image); + bmp_info->bmiHeader.biWidth = IMAGE_INSTANCE_MSWINDOWS_BITMAP_REAL_WIDTH (image); bmp_info->bmiHeader.biHeight = -height; - bmp_info->bmiHeader.biPlanes=1; - bmp_info->bmiHeader.biSize=sizeof(BITMAPINFOHEADER); - bmp_info->bmiHeader.biBitCount=24; - bmp_info->bmiHeader.biCompression=BI_RGB; - bmp_info->bmiHeader.biClrUsed = 0; - bmp_info->bmiHeader.biClrImportant = 0; + bmp_info->bmiHeader.biPlanes = 1; + bmp_info->bmiHeader.biSize = sizeof(BITMAPINFOHEADER); + bmp_info->bmiHeader.biBitCount = 24; + bmp_info->bmiHeader.biCompression = BI_RGB; + bmp_info->bmiHeader.biClrUsed = 0; + bmp_info->bmiHeader.biClrImportant = 0; bmp_info->bmiHeader.biSizeImage = height * bpline; - dibits = xmalloc_and_zero (bpline * height); + dibits = (unsigned char*) xmalloc_and_zero (bpline * height); if (GetDIBits (hcdc, IMAGE_INSTANCE_MSWINDOWS_BITMAP (image), 0, @@ -448,20 +572,20 @@ mswindows_initialize_image_instance_mask (struct Lisp_Image_Instance* image, /* now set the colored bits in the mask and transparent ones to black in the original */ - for(i=0; ibfOffBits; @@ -935,7 +1065,7 @@ bmp_instantiate (Lisp_Object image_instance, Lisp_Object instantiator, /* Now create the pixmap and set up the image instance */ init_image_instance_from_dibitmap (ii, bmp_info, dest_mask, - bmp_data, bmp_bits, instantiator, + bmp_data, bmp_bits, 1, instantiator, 0, 0, 0); } @@ -947,9 +1077,9 @@ bmp_instantiate (Lisp_Object image_instance, Lisp_Object instantiator, static void mswindows_resource_validate (Lisp_Object instantiator) { - if ((NILP (find_keyword_in_vector (instantiator, Q_file)) + if ((NILP (find_keyword_in_vector (instantiator, Q_file)) && - NILP (find_keyword_in_vector (instantiator, Q_resource_id))) + NILP (find_keyword_in_vector (instantiator, Q_resource_id))) || NILP (find_keyword_in_vector (instantiator, Q_resource_type))) signal_simple_error ("Must supply :file, :resource-id and :resource-type", @@ -957,7 +1087,8 @@ mswindows_resource_validate (Lisp_Object instantiator) } static Lisp_Object -mswindows_resource_normalize (Lisp_Object inst, Lisp_Object console_type) +mswindows_resource_normalize (Lisp_Object inst, Lisp_Object console_type, + Lisp_Object dest_mask) { /* This function can call lisp */ Lisp_Object file = Qnil; @@ -966,7 +1097,7 @@ mswindows_resource_normalize (Lisp_Object inst, Lisp_Object console_type) GCPRO2 (file, alist); - file = potential_pixmap_file_instantiator (inst, Q_file, Q_data, + file = potential_pixmap_file_instantiator (inst, Q_file, Q_data, console_type); if (CONSP (file)) /* failure locating filename */ @@ -997,7 +1128,7 @@ mswindows_resource_possible_dest_types (void) return IMAGE_POINTER_MASK | IMAGE_COLOR_PIXMAP_MASK; } -typedef struct +typedef struct { char *name; int resource_id; @@ -1011,10 +1142,12 @@ typedef struct #define OIC_BANG 32515 #define OIC_NOTE 32516 #define OIC_WINLOGO 32517 +#if defined (CYGWIN) && CYGWIN_VERSION_DLL_MAJOR < 21 #define LR_SHARED 0x8000 #endif +#endif -static CONST resource_t bitmap_table[] = +static const resource_t bitmap_table[] = { /* bitmaps */ { "close", OBM_CLOSE }, @@ -1046,7 +1179,7 @@ static CONST resource_t bitmap_table[] = {0} }; -static CONST resource_t cursor_table[] = +static const resource_t cursor_table[] = { /* cursors */ { "normal", OCR_NORMAL }, @@ -1065,7 +1198,7 @@ static CONST resource_t cursor_table[] = { 0 } }; -static CONST resource_t icon_table[] = +static const resource_t icon_table[] = { /* icons */ { "sample", OIC_SAMPLE }, @@ -1079,8 +1212,8 @@ static CONST resource_t icon_table[] = static int resource_name_to_resource (Lisp_Object name, int type) { - CONST resource_t* res = (type == IMAGE_CURSOR ? cursor_table - : type == IMAGE_ICON ? icon_table + const resource_t* res = (type == IMAGE_CURSOR ? cursor_table + : type == IMAGE_ICON ? icon_table : bitmap_table); if (INTP (name)) @@ -1091,9 +1224,13 @@ static int resource_name_to_resource (Lisp_Object name, int type) { signal_simple_error ("invalid resource identifier", name); } - + do { - if (!strcasecmp ((char*)res->name, XSTRING_DATA (name))) + Extbyte* nm=0; + TO_EXTERNAL_FORMAT (LISP_STRING, name, + C_STRING_ALLOCA, nm, + Qnative); + if (!strcasecmp ((char*)res->name, nm)) return res->resource_id; } while ((++res)->name); return 0; @@ -1117,26 +1254,25 @@ mswindows_resource_instantiate (Lisp_Object image_instance, Lisp_Object instanti Lisp_Object pointer_fg, Lisp_Object pointer_bg, int dest_mask, Lisp_Object domain) { - struct Lisp_Image_Instance *ii = XIMAGE_INSTANCE (image_instance); + Lisp_Image_Instance *ii = XIMAGE_INSTANCE (image_instance); unsigned int type = 0; HANDLE himage = NULL; LPCTSTR resid=0; HINSTANCE hinst = NULL; ICONINFO iconinfo; - int iitype=0; + enum image_instance_type iitype; char* fname=0; Lisp_Object device = IMAGE_INSTANCE_DEVICE (ii); Lisp_Object file = find_keyword_in_vector (instantiator, Q_file); - Lisp_Object resource_type = find_keyword_in_vector (instantiator, + Lisp_Object resource_type = find_keyword_in_vector (instantiator, Q_resource_type); - Lisp_Object resource_id = find_keyword_in_vector (instantiator, + Lisp_Object resource_id = find_keyword_in_vector (instantiator, Q_resource_id); xzero (iconinfo); - if (!DEVICE_MSWINDOWS_P (XDEVICE (device))) - signal_simple_error ("Not an mswindows device", device); + CHECK_MSGDI_DEVICE (device); type = resource_symbol_to_type (resource_type); @@ -1144,20 +1280,23 @@ mswindows_resource_instantiate (Lisp_Object image_instance, Lisp_Object instanti iitype = IMAGE_POINTER; else if (dest_mask & IMAGE_COLOR_PIXMAP_MASK) iitype = IMAGE_COLOR_PIXMAP; - else + else incompatible_image_types (instantiator, dest_mask, IMAGE_COLOR_PIXMAP_MASK | IMAGE_POINTER_MASK); /* mess with the keyword info we were provided with */ if (!NILP (file)) { -#ifdef __CYGWIN32__ - CYGWIN_WIN32_PATH (XSTRING_DATA (file), fname); + Extbyte* f=0; + TO_EXTERNAL_FORMAT (LISP_STRING, file, + C_STRING_ALLOCA, f, + Qfile_name); +#ifdef CYGWIN + CYGWIN_WIN32_PATH (f, fname); #else - /* #### FIXME someone who knows ... */ - fname = XSTRING_DATA (file); + fname = f; #endif - + if (NILP (resource_id)) resid = (LPCTSTR)fname; else @@ -1166,51 +1305,74 @@ mswindows_resource_instantiate (Lisp_Object image_instance, Lisp_Object instanti LOAD_LIBRARY_AS_DATAFILE); resid = MAKEINTRESOURCE (resource_name_to_resource (resource_id, type)); - + if (!resid) - resid = XSTRING_DATA (resource_id); + TO_EXTERNAL_FORMAT (LISP_STRING, resource_id, + C_STRING_ALLOCA, resid, + Qnative); } } else if (!(resid = MAKEINTRESOURCE (resource_name_to_resource (resource_id, type)))) signal_simple_error ("Invalid resource identifier", resource_id); - + /* load the image */ - if (!(himage = LoadImage (hinst, resid, type, 0, 0, - LR_CREATEDIBSECTION | LR_DEFAULTSIZE | - LR_SHARED | - (!NILP (file) ? LR_LOADFROMFILE : 0)))) + if (xLoadImageA) /* not in NT 3.5 */ { - signal_simple_error ("Cannot load image", instantiator); + if (!(himage = xLoadImageA (hinst, resid, type, 0, 0, + LR_CREATEDIBSECTION | LR_DEFAULTSIZE | + LR_SHARED | + (!NILP (file) ? LR_LOADFROMFILE : 0)))) + signal_simple_error ("Cannot load image", instantiator); + } + else + { + /* Is this correct? I don't really care. */ + switch (type) + { + case IMAGE_BITMAP: + himage = LoadBitmap (hinst, resid); + break; + case IMAGE_CURSOR: + himage = LoadCursor (hinst, resid); + break; + case IMAGE_ICON: + himage = LoadIcon (hinst, resid); + break; + } + + if (!himage) + signal_simple_error ("Cannot load image", instantiator); } if (hinst) FreeLibrary (hinst); - mswindows_initialize_dibitmap_image_instance (ii, iitype); + mswindows_initialize_dibitmap_image_instance (ii, 1, iitype); IMAGE_INSTANCE_PIXMAP_FILENAME (ii) = file; - IMAGE_INSTANCE_PIXMAP_WIDTH (ii) = + IMAGE_INSTANCE_MSWINDOWS_BITMAP_REAL_WIDTH (ii) = GetSystemMetrics (type == IMAGE_CURSOR ? SM_CXCURSOR : SM_CXICON); - IMAGE_INSTANCE_PIXMAP_HEIGHT (ii) = + IMAGE_INSTANCE_MSWINDOWS_BITMAP_REAL_HEIGHT (ii) = GetSystemMetrics (type == IMAGE_CURSOR ? SM_CYCURSOR : SM_CYICON); IMAGE_INSTANCE_PIXMAP_DEPTH (ii) = 1; + init_image_instance_geometry (ii); /* hey, we've got an icon type thing so we can reverse engineer the bitmap and mask */ if (type != IMAGE_BITMAP) { - GetIconInfo (himage, &iconinfo); + GetIconInfo ((HICON)himage, &iconinfo); IMAGE_INSTANCE_MSWINDOWS_BITMAP (ii) = iconinfo.hbmColor; IMAGE_INSTANCE_MSWINDOWS_MASK (ii) = iconinfo.hbmMask; XSETINT (IMAGE_INSTANCE_PIXMAP_HOTSPOT_X (ii), iconinfo.xHotspot); XSETINT (IMAGE_INSTANCE_PIXMAP_HOTSPOT_Y (ii), iconinfo.yHotspot); - IMAGE_INSTANCE_MSWINDOWS_ICON (ii) = himage; + IMAGE_INSTANCE_MSWINDOWS_ICON (ii) = (HICON) himage; } else { IMAGE_INSTANCE_MSWINDOWS_ICON (ii) = NULL; - IMAGE_INSTANCE_MSWINDOWS_BITMAP (ii) = himage; + IMAGE_INSTANCE_MSWINDOWS_BITMAP (ii) = (HBITMAP) himage; IMAGE_INSTANCE_MSWINDOWS_MASK (ii) = NULL; XSETINT (IMAGE_INSTANCE_PIXMAP_HOTSPOT_X (ii), 0); XSETINT (IMAGE_INSTANCE_PIXMAP_HOTSPOT_Y (ii), 0); @@ -1236,15 +1398,6 @@ check_valid_resource_id (Lisp_Object data) signal_simple_error ("invalid resource identifier", data); } -void -check_valid_string_or_int (Lisp_Object data) -{ - if (!INTP (data)) - CHECK_STRING (data); - else - CHECK_INT (data); -} - /********************************************************************** * XBM * **********************************************************************/ @@ -1289,7 +1442,7 @@ in this Software without prior written authorization from the X Consortium. * and return data * * Note that this file and ../X/XRdBitF.c look very similar.... Keep them - * that way (but don't use common source code so that people can have one + * that way (but don't use common source code so that people can have one * without the other). */ @@ -1307,13 +1460,14 @@ in this Software without prior written authorization from the X Consortium. /* shared data for the image read/parse logic */ static short hexTable[256]; /* conversion value */ -static int initialized = FALSE; /* easier to fill in at run time */ +static int hex_initialized = FALSE; /* easier to fill in at run time */ /* * Table index for the hex values. Initialized once, first time. * Used for translation value or delimiter significance lookup. */ -static void initHexTable() +static void +initHexTable (void) { /* * We build the table at run time for several reasons: @@ -1339,20 +1493,21 @@ static void initHexTable() hexTable[' '] = -1; hexTable[','] = -1; hexTable['}'] = -1; hexTable['\n'] = -1; hexTable['\t'] = -1; - - initialized = TRUE; + + hex_initialized = TRUE; } /* * read next hex value in the input stream, return -1 if EOF */ -static int NextInt ( FILE *fstream ) +static int +NextInt (FILE *fstream) { int ch; int value = 0; int gotone = 0; int done = 0; - + /* loop, accumulate hex value until find delimiter */ /* skip any initial delimiters found in read stream */ @@ -1381,11 +1536,9 @@ static int NextInt ( FILE *fstream ) * its arguments won't have been touched. This routine should look as much * like the Xlib routine XReadBitmapfile as possible. */ -int read_bitmap_data (fstream, width, height, datap, x_hot, y_hot) - FILE *fstream; /* handle on file */ - unsigned int *width, *height; /* RETURNED */ - unsigned char **datap; /* RETURNED */ - int *x_hot, *y_hot; /* RETURNED */ +int read_bitmap_data (FILE* fstream, unsigned int *width, + unsigned int *height, unsigned char **datap, + int *x_hot, int *y_hot) { unsigned char *data = NULL; /* working variable */ char line[MAX_SIZE]; /* input line from file */ @@ -1404,7 +1557,7 @@ int read_bitmap_data (fstream, width, height, datap, x_hot, y_hot) #define Xmalloc(size) malloc(size) /* first time initialization */ - if (initialized == FALSE) initHexTable(); + if (hex_initialized == FALSE) initHexTable(); /* error cleanup and return macro */ #define RETURN(code) { if (data) free (data); return code; } @@ -1433,7 +1586,7 @@ int read_bitmap_data (fstream, width, height, datap, x_hot, y_hot) } continue; } - + if (sscanf(line, "static short %s = {", name_and_type) == 1) version10p = 1; else if (sscanf(line,"static unsigned char %s = {",name_and_type) == 1) @@ -1450,7 +1603,7 @@ int read_bitmap_data (fstream, width, height, datap, x_hot, y_hot) if (strcmp("bits[]", type)) continue; - + if (!ww || !hh) RETURN (BitmapFileInvalid); @@ -1463,7 +1616,7 @@ int read_bitmap_data (fstream, width, height, datap, x_hot, y_hot) size = bytes_per_line * hh; data = (unsigned char *) Xmalloc ((unsigned int) size); - if (!data) + if (!data) RETURN (BitmapNoMemory); if (version10p) { @@ -1482,7 +1635,7 @@ int read_bitmap_data (fstream, width, height, datap, x_hot, y_hot) int bytes; for (bytes=0, ptr=data; bytes> 4]); + ((flip_table[bite & 0xf] << 4) + flip_table[bite >> 4]); } } @@ -1586,14 +1737,14 @@ xbm_create_bitmap_from_data (HDC hdc, char *data, } bmp_info->bmiHeader.biWidth=width; - bmp_info->bmiHeader.biHeight=-height; + bmp_info->bmiHeader.biHeight=-(LONG)height; bmp_info->bmiHeader.biPlanes=1; bmp_info->bmiHeader.biSize=sizeof(BITMAPINFOHEADER); - bmp_info->bmiHeader.biBitCount=1; + bmp_info->bmiHeader.biBitCount=1; bmp_info->bmiHeader.biCompression=BI_RGB; - bmp_info->bmiHeader.biClrUsed = 2; - bmp_info->bmiHeader.biClrImportant = 2; - bmp_info->bmiHeader.biSizeImage = height * new_width; + bmp_info->bmiHeader.biClrUsed = 2; + bmp_info->bmiHeader.biClrImportant = 2; + bmp_info->bmiHeader.biSizeImage = height * new_width; bmp_info->bmiColors[0].rgbRed = GetRValue (fg); bmp_info->bmiColors[0].rgbGreen = GetGValue (fg); bmp_info->bmiColors[0].rgbBlue = GetBValue (fg); @@ -1602,21 +1753,21 @@ xbm_create_bitmap_from_data (HDC hdc, char *data, bmp_info->bmiColors[1].rgbGreen = GetGValue (bg); bmp_info->bmiColors[1].rgbBlue = GetBValue (bg); bmp_info->bmiColors[1].rgbReserved = 0; - - bitmap = CreateDIBSection (hdc, + + bitmap = CreateDIBSection (hdc, bmp_info, DIB_RGB_COLORS, - &bmp_buf, + &bmp_buf, 0,0); xfree (bmp_info); - + if (!bitmap || !bmp_buf) { xfree (new_data); return NULL; } - + /* copy in the actual bitmap */ memcpy (bmp_buf, new_data, height * new_width); xfree (new_data); @@ -1628,10 +1779,10 @@ xbm_create_bitmap_from_data (HDC hdc, char *data, image instance accordingly. */ static void -init_image_instance_from_xbm_inline (struct Lisp_Image_Instance *ii, +init_image_instance_from_xbm_inline (Lisp_Image_Instance *ii, int width, int height, /* Note that data is in ext-format! */ - CONST char *bits, + const char *bits, Lisp_Object instantiator, Lisp_Object pointer_fg, Lisp_Object pointer_bg, @@ -1640,17 +1791,16 @@ init_image_instance_from_xbm_inline (struct Lisp_Image_Instance *ii, Lisp_Object mask_filename) { Lisp_Object device = IMAGE_INSTANCE_DEVICE (ii); - struct frame* f = XFRAME (DEVICE_SELECTED_FRAME (XDEVICE (device))); Lisp_Object foreground = find_keyword_in_vector (instantiator, Q_foreground); Lisp_Object background = find_keyword_in_vector (instantiator, Q_background); enum image_instance_type type; COLORREF black = PALETTERGB (0,0,0); COLORREF white = PALETTERGB (255,255,255); + HDC hdc; - HDC hdc = FRAME_MSWINDOWS_CDC (f); + CHECK_MSGDI_DEVICE (device); - if (!DEVICE_MSWINDOWS_P (XDEVICE (device))) - signal_simple_error ("Not an MS-Windows device", device); + hdc = get_device_compdc (XDEVICE (device)); if ((dest_mask & IMAGE_MONO_PIXMAP_MASK) && (dest_mask & IMAGE_COLOR_PIXMAP_MASK)) @@ -1671,24 +1821,26 @@ init_image_instance_from_xbm_inline (struct Lisp_Image_Instance *ii, IMAGE_MONO_PIXMAP_MASK | IMAGE_COLOR_PIXMAP_MASK | IMAGE_POINTER_MASK); - mswindows_initialize_dibitmap_image_instance (ii, type); - + mswindows_initialize_dibitmap_image_instance (ii, 1, type); + IMAGE_INSTANCE_PIXMAP_FILENAME (ii) = find_keyword_in_vector (instantiator, Q_file); - IMAGE_INSTANCE_PIXMAP_WIDTH (ii) = width; - IMAGE_INSTANCE_PIXMAP_HEIGHT (ii) = height; + IMAGE_INSTANCE_MSWINDOWS_BITMAP_REAL_WIDTH (ii) = width; + IMAGE_INSTANCE_MSWINDOWS_BITMAP_REAL_HEIGHT (ii) = height; IMAGE_INSTANCE_PIXMAP_DEPTH (ii) = 1; XSETINT (IMAGE_INSTANCE_PIXMAP_HOTSPOT_X (ii), 0); XSETINT (IMAGE_INSTANCE_PIXMAP_HOTSPOT_Y (ii), 0); + init_image_instance_geometry (ii); + IMAGE_INSTANCE_MSWINDOWS_MASK (ii) = mask ? mask : - xbm_create_bitmap_from_data (hdc, (Extbyte *) bits, width, height, + xbm_create_bitmap_from_data (hdc, (Extbyte *) bits, width, height, TRUE, black, white); switch (type) { case IMAGE_MONO_PIXMAP: - IMAGE_INSTANCE_MSWINDOWS_BITMAP (ii) = - xbm_create_bitmap_from_data (hdc, (Extbyte *) bits, width, height, + IMAGE_INSTANCE_MSWINDOWS_BITMAP (ii) = + xbm_create_bitmap_from_data (hdc, (Extbyte *) bits, width, height, FALSE, black, black); break; @@ -1716,8 +1868,8 @@ init_image_instance_from_xbm_inline (struct Lisp_Image_Instance *ii, IMAGE_INSTANCE_PIXMAP_FG (ii) = foreground; IMAGE_INSTANCE_PIXMAP_BG (ii) = background; - IMAGE_INSTANCE_MSWINDOWS_BITMAP (ii) = - xbm_create_bitmap_from_data (hdc, (Extbyte *) bits, width, height, + IMAGE_INSTANCE_MSWINDOWS_BITMAP (ii) = + xbm_create_bitmap_from_data (hdc, (Extbyte *) bits, width, height, FALSE, fg, black); } break; @@ -1732,9 +1884,9 @@ init_image_instance_from_xbm_inline (struct Lisp_Image_Instance *ii, if (NILP (background)) background = pointer_bg; - IMAGE_INSTANCE_PIXMAP_HOTSPOT_X (ii) = + IMAGE_INSTANCE_PIXMAP_HOTSPOT_X (ii) = find_keyword_in_vector (instantiator, Q_hotspot_x); - IMAGE_INSTANCE_PIXMAP_HOTSPOT_Y (ii) = + IMAGE_INSTANCE_PIXMAP_HOTSPOT_Y (ii) = find_keyword_in_vector (instantiator, Q_hotspot_y); IMAGE_INSTANCE_PIXMAP_FG (ii) = foreground; IMAGE_INSTANCE_PIXMAP_BG (ii) = background; @@ -1743,15 +1895,15 @@ init_image_instance_from_xbm_inline (struct Lisp_Image_Instance *ii, if (COLOR_INSTANCEP (background)) bg = COLOR_INSTANCE_MSWINDOWS_COLOR (XCOLOR_INSTANCE (background)); - IMAGE_INSTANCE_MSWINDOWS_BITMAP (ii) = - xbm_create_bitmap_from_data (hdc, (Extbyte *) bits, width, height, + IMAGE_INSTANCE_MSWINDOWS_BITMAP (ii) = + xbm_create_bitmap_from_data (hdc, (Extbyte *) bits, width, height, TRUE, fg, black); mswindows_initialize_image_instance_icon (ii, TRUE); } break; default: - abort (); + ABORT (); } } @@ -1760,29 +1912,28 @@ xbm_instantiate_1 (Lisp_Object image_instance, Lisp_Object instantiator, Lisp_Object pointer_fg, Lisp_Object pointer_bg, int dest_mask, int width, int height, /* Note that data is in ext-format! */ - CONST char *bits) + const char *bits) { Lisp_Object mask_data = find_keyword_in_vector (instantiator, Q_mask_data); Lisp_Object mask_file = find_keyword_in_vector (instantiator, Q_mask_file); - struct Lisp_Image_Instance *ii = XIMAGE_INSTANCE (image_instance); - struct frame* f = XFRAME (DEVICE_SELECTED_FRAME - (XDEVICE (IMAGE_INSTANCE_DEVICE (ii)))); - HDC hdc = FRAME_MSWINDOWS_CDC (f); + Lisp_Image_Instance *ii = XIMAGE_INSTANCE (image_instance); + HDC hdc = get_device_compdc (XDEVICE (IMAGE_INSTANCE_DEVICE (ii))); HBITMAP mask = 0; - CONST char *gcc_may_you_rot_in_hell; if (!NILP (mask_data)) { - GET_C_STRING_BINARY_DATA_ALLOCA (XCAR (XCDR (XCDR (mask_data))), - gcc_may_you_rot_in_hell); - mask = - xbm_create_bitmap_from_data ( hdc, - (unsigned char *) - gcc_may_you_rot_in_hell, - XINT (XCAR (mask_data)), - XINT (XCAR (XCDR (mask_data))), FALSE, - PALETTERGB (0,0,0), - PALETTERGB (255,255,255)); + const char *ext_data; + + TO_EXTERNAL_FORMAT (LISP_STRING, XCAR (XCDR (XCDR (mask_data))), + C_STRING_ALLOCA, ext_data, + Qbinary); + mask = xbm_create_bitmap_from_data (hdc, + (unsigned char *) ext_data, + XINT (XCAR (mask_data)), + XINT (XCAR (XCDR (mask_data))), + FALSE, + PALETTERGB (0,0,0), + PALETTERGB (255,255,255)); } init_image_instance_from_xbm_inline (ii, width, height, bits, @@ -1793,23 +1944,116 @@ xbm_instantiate_1 (Lisp_Object image_instance, Lisp_Object instantiator, /* Instantiate method for XBM's. */ static void -mswindows_xbm_instantiate (Lisp_Object image_instance, +mswindows_xbm_instantiate (Lisp_Object image_instance, Lisp_Object instantiator, Lisp_Object pointer_fg, Lisp_Object pointer_bg, int dest_mask, Lisp_Object domain) { Lisp_Object data = find_keyword_in_vector (instantiator, Q_data); - CONST char *gcc_go_home; + const char *ext_data; assert (!NILP (data)); - GET_C_STRING_BINARY_DATA_ALLOCA (XCAR (XCDR (XCDR (data))), - gcc_go_home); + TO_EXTERNAL_FORMAT (LISP_STRING, XCAR (XCDR (XCDR (data))), + C_STRING_ALLOCA, ext_data, + Qbinary); xbm_instantiate_1 (image_instance, instantiator, pointer_fg, pointer_bg, dest_mask, XINT (XCAR (data)), - XINT (XCAR (XCDR (data))), gcc_go_home); + XINT (XCAR (XCDR (data))), ext_data); +} + +#ifdef HAVE_XFACE +/********************************************************************** + * X-Face * + **********************************************************************/ +#if defined(EXTERN) +/* This is about to get redefined! */ +#undef EXTERN +#endif +/* We have to define SYSV32 so that compface.h includes string.h + instead of strings.h. */ +#define SYSV32 +#ifdef __cplusplus +extern "C" { +#endif +#ifndef __STDC__ /* Needed to avoid prototype warnings */ +#define __STDC__ +#endif +#include +#ifdef __cplusplus } +#endif +/* JMP_BUF cannot be used here because if it doesn't get defined + to jmp_buf we end up with a conflicting type error with the + definition in compface.h */ +extern jmp_buf comp_env; +#undef SYSV32 + +static void +mswindows_xface_instantiate (Lisp_Object image_instance, Lisp_Object instantiator, + Lisp_Object pointer_fg, Lisp_Object pointer_bg, + int dest_mask, Lisp_Object domain) +{ + Lisp_Object data = find_keyword_in_vector (instantiator, Q_data); + int i, stattis; + char *p, *bits, *bp; + const char * volatile emsg = 0; + const char * volatile dstring; + + assert (!NILP (data)); + + TO_EXTERNAL_FORMAT (LISP_STRING, data, + C_STRING_ALLOCA, dstring, + Qbinary); + + if ((p = strchr (dstring, ':'))) + { + dstring = p + 1; + } + + /* Must use setjmp not SETJMP because we used jmp_buf above not JMP_BUF */ + if (!(stattis = setjmp (comp_env))) + { + UnCompAll ((char *) dstring); + UnGenFace (); + } + + switch (stattis) + { + case -2: + emsg = "uncompface: internal error"; + break; + case -1: + emsg = "uncompface: insufficient or invalid data"; + break; + case 1: + emsg = "uncompface: excess data ignored"; + break; + } + + if (emsg) + signal_simple_error_2 (emsg, data, Qimage); + + bp = bits = (char *) alloca (PIXELS / 8); + + /* the compface library exports char F[], which uses a single byte per + pixel to represent a 48x48 bitmap. Yuck. */ + for (i = 0, p = F; i < (PIXELS / 8); ++i) + { + int n, b; + /* reverse the bit order of each byte... */ + for (b = n = 0; b < 8; ++b) + { + n |= ((*p++) << b); + } + *bp++ = (char) n; + } + + xbm_instantiate_1 (image_instance, instantiator, pointer_fg, + pointer_bg, dest_mask, 48, 48, bits); +} +#endif /* HAVE_XFACE */ /************************************************************************/ @@ -1817,7 +2061,7 @@ mswindows_xbm_instantiate (Lisp_Object image_instance, /************************************************************************/ static void -mswindows_print_image_instance (struct Lisp_Image_Instance *p, +mswindows_print_image_instance (Lisp_Image_Instance *p, Lisp_Object printcharfun, int escapeflag) { @@ -1828,58 +2072,409 @@ mswindows_print_image_instance (struct Lisp_Image_Instance *p, case IMAGE_MONO_PIXMAP: case IMAGE_COLOR_PIXMAP: case IMAGE_POINTER: - sprintf (buf, " (0x%lx", + sprintf (buf, " (0x%lx", (unsigned long) IMAGE_INSTANCE_MSWINDOWS_BITMAP (p)); write_c_string (buf, printcharfun); if (IMAGE_INSTANCE_MSWINDOWS_MASK (p)) { - sprintf (buf, "/0x%lx", + sprintf (buf, "/0x%lx", (unsigned long) IMAGE_INSTANCE_MSWINDOWS_MASK (p)); write_c_string (buf, printcharfun); } write_c_string (")", printcharfun); break; + default: break; } } +#ifdef DEBUG_WIDGETS +extern int debug_widget_instances; +#endif + +static void +finalize_destroy_window (void *win) +{ + DestroyWindow ((HWND) win); +} + static void -mswindows_finalize_image_instance (struct Lisp_Image_Instance *p) +mswindows_finalize_image_instance (Lisp_Image_Instance *p) { if (!p->data) return; - if (DEVICE_LIVE_P (XDEVICE (p->device))) + if (DEVICE_LIVE_P (XDEVICE (IMAGE_INSTANCE_DEVICE (p)))) { - if (IMAGE_INSTANCE_MSWINDOWS_BITMAP (p)) - DeleteObject (IMAGE_INSTANCE_MSWINDOWS_BITMAP (p)); - IMAGE_INSTANCE_MSWINDOWS_BITMAP (p) = 0; - if (IMAGE_INSTANCE_MSWINDOWS_MASK (p)) - DeleteObject (IMAGE_INSTANCE_MSWINDOWS_MASK (p)); - IMAGE_INSTANCE_MSWINDOWS_MASK (p) = 0; - if (IMAGE_INSTANCE_MSWINDOWS_ICON (p)) - DestroyIcon (IMAGE_INSTANCE_MSWINDOWS_ICON (p)); - IMAGE_INSTANCE_MSWINDOWS_ICON (p) = 0; + if (image_instance_type_to_mask (IMAGE_INSTANCE_TYPE (p)) + & (IMAGE_WIDGET_MASK | IMAGE_SUBWINDOW_MASK)) + { +#ifdef DEBUG_WIDGETS + debug_widget_instances--; + stderr_out ("widget destroyed, %d left\n", debug_widget_instances); +#endif + if (IMAGE_INSTANCE_SUBWINDOW_ID (p)) + { + /* DestroyWindow is not safe here, as it will send messages + to our window proc. */ + register_post_gc_action + (finalize_destroy_window, + (void *) (WIDGET_INSTANCE_MSWINDOWS_HANDLE (p))); + register_post_gc_action + (finalize_destroy_window, + (void *) (IMAGE_INSTANCE_MSWINDOWS_CLIPWINDOW (p))); + IMAGE_INSTANCE_SUBWINDOW_ID (p) = 0; + } + } + else if (p->data) + { + int i; + if (IMAGE_INSTANCE_PIXMAP_TIMEOUT (p)) + disable_glyph_animated_timeout (IMAGE_INSTANCE_PIXMAP_TIMEOUT (p)); + + if (IMAGE_INSTANCE_MSWINDOWS_BITMAP_SLICES (p)) + { + for (i = 0; i < IMAGE_INSTANCE_PIXMAP_MAXSLICE (p); i++) + { + if (IMAGE_INSTANCE_MSWINDOWS_BITMAP_SLICE (p, i)) + DeleteObject (IMAGE_INSTANCE_MSWINDOWS_BITMAP_SLICE (p, i)); + IMAGE_INSTANCE_MSWINDOWS_BITMAP_SLICE (p, i) = 0; + } + xfree (IMAGE_INSTANCE_MSWINDOWS_BITMAP_SLICES (p)); + IMAGE_INSTANCE_MSWINDOWS_BITMAP_SLICES (p) = 0; + } + if (IMAGE_INSTANCE_MSWINDOWS_MASK (p)) + DeleteObject (IMAGE_INSTANCE_MSWINDOWS_MASK (p)); + IMAGE_INSTANCE_MSWINDOWS_MASK (p) = 0; + if (IMAGE_INSTANCE_MSWINDOWS_ICON (p)) + DestroyIcon (IMAGE_INSTANCE_MSWINDOWS_ICON (p)); + IMAGE_INSTANCE_MSWINDOWS_ICON (p) = 0; + } + } + + if (p->data) + { + xfree (p->data); + p->data = 0; + } +} + +/************************************************************************/ +/* subwindow and widget support */ +/************************************************************************/ + +static HFONT +mswindows_widget_hfont (Lisp_Image_Instance *p, + Lisp_Object domain) +{ + Lisp_Object face = IMAGE_INSTANCE_WIDGET_FACE (p); + int under = FACE_UNDERLINE_P (face, domain); + int strike = FACE_STRIKETHRU_P (face, domain); + Lisp_Object font = query_string_font (IMAGE_INSTANCE_WIDGET_TEXT (p), + face, domain); + + return mswindows_get_hfont (XFONT_INSTANCE (font), under, strike); +} + +static HDWP +begin_defer_window_pos (struct frame *f) +{ +#ifdef DEFER_WINDOW_POS + if (FRAME_MSWINDOWS_DATA (f)->hdwp == 0) + FRAME_MSWINDOWS_DATA (f)->hdwp = BeginDeferWindowPos (10); +#endif + return FRAME_MSWINDOWS_DATA (f)->hdwp; +} + +/* unmap the image if it is a widget. This is used by redisplay via + redisplay_unmap_subwindows */ +static void +mswindows_unmap_subwindow (Lisp_Image_Instance *p) +{ + if (IMAGE_INSTANCE_SUBWINDOW_ID (p)) + { +#ifdef DEFER_WINDOW_POS + struct frame *f = XFRAME (IMAGE_INSTANCE_FRAME (p)); + HDWP hdwp = begin_defer_window_pos (f); + HDWP new_hdwp; + new_hdwp = DeferWindowPos (hdwp, IMAGE_INSTANCE_MSWINDOWS_CLIPWINDOW (p), + NULL, + 0, 0, 0, 0, + SWP_HIDEWINDOW | SWP_NOACTIVATE | + SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER + /* Setting this flag causes the call to + DeferWindowPos to fail with + "Invalid parameter". I don't understand + why we bother to try and set this + anyway. -- ben */ + /* | SWP_NOSENDCHANGING */ + ); + if (!new_hdwp) + mswindows_output_last_error ("unmapping"); + else + hdwp = new_hdwp; + FRAME_MSWINDOWS_DATA (f)->hdwp = hdwp; +#else + SetWindowPos (IMAGE_INSTANCE_MSWINDOWS_CLIPWINDOW (p), + NULL, + 0, 0, 0, 0, + SWP_HIDEWINDOW | SWP_NOACTIVATE | + SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER ); +#endif + if (GetFocus() == WIDGET_INSTANCE_MSWINDOWS_HANDLE (p)) + SetFocus (GetParent (IMAGE_INSTANCE_MSWINDOWS_CLIPWINDOW (p))); + } +} + +/* map the subwindow. This is used by redisplay via + redisplay_output_subwindow */ +static void +mswindows_map_subwindow (Lisp_Image_Instance *p, int x, int y, + struct display_glyph_area* dga) +{ +#ifdef DEFER_WINDOW_POS + struct frame *f = XFRAME (IMAGE_INSTANCE_FRAME (p)); + HDWP hdwp = begin_defer_window_pos (f); + HDWP new_hdwp; +#endif + /* move the window before mapping it ... */ + SetWindowPos (IMAGE_INSTANCE_MSWINDOWS_CLIPWINDOW (p), + NULL, + x, y, dga->width, dga->height, + SWP_NOZORDER + | SWP_NOCOPYBITS | SWP_NOSENDCHANGING); + /* ... adjust the child ... */ + SetWindowPos (WIDGET_INSTANCE_MSWINDOWS_HANDLE (p), + NULL, + -dga->xoffset, -dga->yoffset, 0, 0, + SWP_NOZORDER | SWP_NOSIZE + | SWP_NOCOPYBITS | SWP_NOSENDCHANGING); + /* ... now map it - we are not allowed to move it at the same time. */ + if (!IMAGE_INSTANCE_SUBWINDOW_DISPLAYEDP (p)) + { +#ifdef DEFER_WINDOW_POS + new_hdwp = DeferWindowPos + (hdwp, + IMAGE_INSTANCE_MSWINDOWS_CLIPWINDOW (p), + NULL, 0, 0, 0, 0, + SWP_NOZORDER | SWP_NOSIZE | SWP_NOMOVE + | SWP_SHOWWINDOW + /* | SWP_NOCOPYBITS */ + /* Setting this flag causes the call to + DeferWindowPos to fail with + "Invalid parameter". I don't understand + why we bother to try and set this + anyway. -- ben */ + /* | SWP_NOSENDCHANGING */ + | SWP_NOACTIVATE); + if (!new_hdwp) + mswindows_output_last_error ("mapping"); + else + hdwp = new_hdwp; + FRAME_MSWINDOWS_DATA (f)->hdwp = hdwp; +#else + SetWindowPos (IMAGE_INSTANCE_MSWINDOWS_CLIPWINDOW (p), + NULL, + 0, 0, 0, 0, + SWP_NOZORDER | SWP_NOSIZE | SWP_NOMOVE + | SWP_SHOWWINDOW | SWP_NOCOPYBITS | SWP_NOACTIVATE); + + /* Doing this once does not seem to be enough, for instance when + mapping the search dialog this gets called four times. If we + only set on the first time through then the subwindow never + gets focus as intended. However, doing this everytime doesn't + seem so bad, after all we only need to redo this after the + focus changes - and if that happens resetting the initial + focus doesn't seem so bad. */ + if (IMAGE_INSTANCE_WANTS_INITIAL_FOCUS (p)) + SetFocus (WIDGET_INSTANCE_MSWINDOWS_HANDLE (p)); +#endif + } +} + +/* resize the subwindow instance */ +static void +mswindows_resize_subwindow (Lisp_Image_Instance* ii, int w, int h) +{ + /* Set the size of the control .... */ + if (!SetWindowPos (WIDGET_INSTANCE_MSWINDOWS_HANDLE (ii), + NULL, + 0, 0, w, h, + SWP_NOZORDER | SWP_NOMOVE + | SWP_NOCOPYBITS | SWP_NOSENDCHANGING)) + mswindows_output_last_error ("resizing"); +} + +/* Simply resize the window here. */ +static void +mswindows_redisplay_subwindow (Lisp_Image_Instance *p) +{ + mswindows_resize_subwindow (p, + IMAGE_INSTANCE_WIDTH (p), + IMAGE_INSTANCE_HEIGHT (p)); +} + +/* when you click on a widget you may activate another widget this + needs to be checked and all appropriate widgets updated */ +static void +mswindows_redisplay_widget (Lisp_Image_Instance *p) +{ + /* Possibly update the face font and colors. */ + if (!NILP (IMAGE_INSTANCE_WIDGET_TEXT (p)) + && (IMAGE_INSTANCE_WIDGET_FACE_CHANGED (p) + || XFRAME (IMAGE_INSTANCE_FRAME (p))->faces_changed + || IMAGE_INSTANCE_WIDGET_ITEMS_CHANGED (p))) + { + /* set the widget font from the widget face */ + SendMessage (WIDGET_INSTANCE_MSWINDOWS_HANDLE (p), + WM_SETFONT, + (WPARAM) mswindows_widget_hfont + (p, IMAGE_INSTANCE_FRAME (p)), + MAKELPARAM (TRUE, 0)); + } + /* Possibly update the dimensions. */ + if (IMAGE_INSTANCE_SIZE_CHANGED (p)) + { + mswindows_resize_subwindow (p, + IMAGE_INSTANCE_WIDTH (p), + IMAGE_INSTANCE_HEIGHT (p)); + } + /* Possibly update the text in the widget. */ + if (IMAGE_INSTANCE_TEXT_CHANGED (p) + && !NILP (IMAGE_INSTANCE_WIDGET_TEXT (p))) + { + Extbyte* lparam=0; + TO_EXTERNAL_FORMAT (LISP_STRING, IMAGE_INSTANCE_WIDGET_TEXT (p), + C_STRING_ALLOCA, lparam, + Qnative); + SendMessage (WIDGET_INSTANCE_MSWINDOWS_HANDLE (p), + WM_SETTEXT, 0, (LPARAM)lparam); + } + /* Set active state. */ + if (IMAGE_INSTANCE_WIDGET_ITEMS_CHANGED (p)) + { + Lisp_Object item = IMAGE_INSTANCE_WIDGET_PENDING_ITEMS (p); + LONG style = GetWindowLong + (WIDGET_INSTANCE_MSWINDOWS_HANDLE (p), + GWL_STYLE); + + if (CONSP (item)) + item = XCAR (item); + + if (gui_item_active_p (item)) + SetWindowLong (WIDGET_INSTANCE_MSWINDOWS_HANDLE (p), + GWL_STYLE, style & ~WS_DISABLED); + else + SetWindowLong (WIDGET_INSTANCE_MSWINDOWS_HANDLE (p), + GWL_STYLE, style | WS_DISABLED); } +} + +/* Account for some of the limitations with widget images. */ +static int +mswindows_widget_border_width (void) +{ + return DEFAULT_WIDGET_BORDER_WIDTH; +} + +/* register widgets into our hashtable so that we can cope with the + callbacks. The hashtable is weak so deregistration is handled + automatically */ +static int +mswindows_register_gui_item (Lisp_Object image_instance, + Lisp_Object gui, Lisp_Object domain) +{ + Lisp_Object frame = DOMAIN_FRAME (domain); + struct frame* f = XFRAME (frame); + int id = gui_item_id_hash (FRAME_MSWINDOWS_WIDGET_HASH_TABLE2 (f), + gui, + WIDGET_GLYPH_SLOT); + Fputhash (make_int (id), image_instance, + FRAME_MSWINDOWS_WIDGET_HASH_TABLE1 (f)); + Fputhash (make_int (id), XGUI_ITEM (gui)->callback, + FRAME_MSWINDOWS_WIDGET_HASH_TABLE2 (f)); + Fputhash (make_int (id), XGUI_ITEM (gui)->callback_ex, + FRAME_MSWINDOWS_WIDGET_HASH_TABLE3 (f)); + return id; +} + +static int +mswindows_register_widget_instance (Lisp_Object instance, Lisp_Object domain) +{ + return mswindows_register_gui_item (instance, + XIMAGE_INSTANCE_WIDGET_ITEM (instance), + domain); +} - xfree (p->data); - p->data = 0; +static void +mswindows_subwindow_instantiate (Lisp_Object image_instance, Lisp_Object instantiator, + Lisp_Object pointer_fg, Lisp_Object pointer_bg, + int dest_mask, Lisp_Object domain) +{ + Lisp_Image_Instance *ii = XIMAGE_INSTANCE (image_instance); + Lisp_Object device = IMAGE_INSTANCE_DEVICE (ii); + Lisp_Object frame = DOMAIN_FRAME (domain); + HWND wnd; + + CHECK_MSWINDOWS_DEVICE (device); + + /* have to set the type this late in case there is no device + instantiation for a widget */ + IMAGE_INSTANCE_TYPE (ii) = IMAGE_SUBWINDOW; + /* Allocate space for the clip window */ + ii->data = xnew_and_zero (struct mswindows_subwindow_data); + + if ((IMAGE_INSTANCE_MSWINDOWS_CLIPWINDOW (ii) + = CreateWindowEx( + 0, /* EX flags */ + XEMACS_CONTROL_CLASS, + 0, /* text */ + WS_CLIPCHILDREN | WS_CLIPSIBLINGS | WS_CHILD, + 0, /* starting x position */ + 0, /* starting y position */ + IMAGE_INSTANCE_WIDGET_WIDTH (ii), + IMAGE_INSTANCE_WIDGET_HEIGHT (ii), + /* parent window */ + FRAME_MSWINDOWS_HANDLE (XFRAME (frame)), + NULL, /* No menu */ + NULL, /* must be null for this class */ + NULL)) == NULL) + signal_simple_error ("window creation failed with code", + make_int (GetLastError())); + + wnd = CreateWindow( "STATIC", + "", + WS_CHILD, + 0, /* starting x position */ + 0, /* starting y position */ + IMAGE_INSTANCE_WIDGET_WIDTH (ii), + IMAGE_INSTANCE_WIDGET_HEIGHT (ii), + IMAGE_INSTANCE_MSWINDOWS_CLIPWINDOW (ii), + 0, + (HINSTANCE) + GetWindowLong (FRAME_MSWINDOWS_HANDLE (XFRAME (frame)), + GWL_HINSTANCE), + NULL); + + SetWindowLong (wnd, GWL_USERDATA, (LONG)LISP_TO_VOID(image_instance)); + IMAGE_INSTANCE_SUBWINDOW_ID (ii) = wnd; } static int -mswindows_image_instance_equal (struct Lisp_Image_Instance *p1, - struct Lisp_Image_Instance *p2, int depth) +mswindows_image_instance_equal (Lisp_Image_Instance *p1, + Lisp_Image_Instance *p2, int depth) { switch (IMAGE_INSTANCE_TYPE (p1)) { case IMAGE_MONO_PIXMAP: case IMAGE_COLOR_PIXMAP: case IMAGE_POINTER: - if (IMAGE_INSTANCE_MSWINDOWS_BITMAP (p1) + if (IMAGE_INSTANCE_MSWINDOWS_BITMAP (p1) != IMAGE_INSTANCE_MSWINDOWS_BITMAP (p2)) return 0; break; + default: break; } @@ -1888,7 +2483,7 @@ mswindows_image_instance_equal (struct Lisp_Image_Instance *p1, } static unsigned long -mswindows_image_instance_hash (struct Lisp_Image_Instance *p, int depth) +mswindows_image_instance_hash (Lisp_Image_Instance *p, int depth) { switch (IMAGE_INSTANCE_TYPE (p)) { @@ -1896,6 +2491,7 @@ mswindows_image_instance_hash (struct Lisp_Image_Instance *p, int depth) case IMAGE_COLOR_PIXMAP: case IMAGE_POINTER: return (unsigned long) IMAGE_INSTANCE_MSWINDOWS_BITMAP (p); + default: return 0; } @@ -1908,8 +2504,9 @@ mswindows_image_instance_hash (struct Lisp_Image_Instance *p, int depth) methods are called. */ static void -mswindows_initialize_dibitmap_image_instance (struct Lisp_Image_Instance *ii, - enum image_instance_type type) +mswindows_initialize_dibitmap_image_instance (Lisp_Image_Instance *ii, + int slices, + enum image_instance_type type) { ii->data = xnew_and_zero (struct mswindows_image_instance_data); IMAGE_INSTANCE_TYPE (ii) = type; @@ -1919,9 +2516,710 @@ mswindows_initialize_dibitmap_image_instance (struct Lisp_Image_Instance *ii, IMAGE_INSTANCE_PIXMAP_HOTSPOT_Y (ii) = Qnil; IMAGE_INSTANCE_PIXMAP_FG (ii) = Qnil; IMAGE_INSTANCE_PIXMAP_BG (ii) = Qnil; + IMAGE_INSTANCE_PIXMAP_MAXSLICE (ii) = slices; + IMAGE_INSTANCE_MSWINDOWS_BITMAP_SLICES (ii) = + xnew_array_and_zero (HBITMAP, slices); } +#ifdef HAVE_WIDGETS + +/************************************************************************/ +/* widgets */ +/************************************************************************/ +static void +mswindows_widget_instantiate (Lisp_Object image_instance, Lisp_Object instantiator, + Lisp_Object pointer_fg, Lisp_Object pointer_bg, + int dest_mask, Lisp_Object domain, + const char* class, int flags, int exflags) +{ + /* this function can call lisp */ + Lisp_Image_Instance *ii = XIMAGE_INSTANCE (image_instance); + Lisp_Object device = IMAGE_INSTANCE_DEVICE (ii), style; + Lisp_Object frame = DOMAIN_FRAME (domain); + Extbyte* nm=0; + HWND wnd; + int id = 0xffff; + Lisp_Object gui = IMAGE_INSTANCE_WIDGET_ITEM (ii); + Lisp_Gui_Item* pgui = XGUI_ITEM (gui); + + CHECK_MSWINDOWS_DEVICE (device); + + if (!gui_item_active_p (gui)) + flags |= WS_DISABLED; + + style = pgui->style; + + if (!NILP (pgui->callback) || !NILP (pgui->callback_ex)) + { + id = mswindows_register_widget_instance (image_instance, domain); + } + + if (!NILP (IMAGE_INSTANCE_WIDGET_TEXT (ii))) + TO_EXTERNAL_FORMAT (LISP_STRING, IMAGE_INSTANCE_WIDGET_TEXT (ii), + C_STRING_ALLOCA, nm, + Qnative); + + /* allocate space for the clip window and then allocate the clip window */ + ii->data = xnew_and_zero (struct mswindows_subwindow_data); + + if ((IMAGE_INSTANCE_MSWINDOWS_CLIPWINDOW (ii) + = CreateWindowEx( + WS_EX_CONTROLPARENT, /* EX flags */ + XEMACS_CONTROL_CLASS, + 0, /* text */ + WS_CLIPCHILDREN | WS_CLIPSIBLINGS | WS_CHILD, + 0, /* starting x position */ + 0, /* starting y position */ + IMAGE_INSTANCE_WIDGET_WIDTH (ii), + IMAGE_INSTANCE_WIDGET_HEIGHT (ii), + /* parent window */ + DOMAIN_MSWINDOWS_HANDLE (domain), + (HMENU)id, /* No menu */ + NULL, /* must be null for this class */ + NULL)) == NULL) + signal_simple_error ("window creation failed with code", + make_int (GetLastError())); + + if ((wnd = CreateWindowEx( + exflags /* | WS_EX_NOPARENTNOTIFY*/, + class, + nm, + flags | WS_CHILD | WS_VISIBLE, + 0, /* starting x position */ + 0, /* starting y position */ + IMAGE_INSTANCE_WIDGET_WIDTH (ii), + IMAGE_INSTANCE_WIDGET_HEIGHT (ii), + /* parent window */ + IMAGE_INSTANCE_MSWINDOWS_CLIPWINDOW (ii), + (HMENU)id, /* No menu */ + (HINSTANCE) + GetWindowLong + (FRAME_MSWINDOWS_HANDLE (XFRAME (frame)), + GWL_HINSTANCE), + NULL)) == NULL) + signal_simple_error ("window creation failed with code", + make_int (GetLastError())); + + IMAGE_INSTANCE_SUBWINDOW_ID (ii) = wnd; + SetWindowLong (wnd, GWL_USERDATA, (LONG)LISP_TO_VOID(image_instance)); + /* set the widget font from the widget face */ + if (!NILP (IMAGE_INSTANCE_WIDGET_TEXT (ii))) + SendMessage (wnd, WM_SETFONT, + (WPARAM) mswindows_widget_hfont (ii, domain), + MAKELPARAM (TRUE, 0)); +} + +/* Instantiate a native layout widget. */ +static void +mswindows_native_layout_instantiate (Lisp_Object image_instance, + Lisp_Object instantiator, + Lisp_Object pointer_fg, Lisp_Object pointer_bg, + int dest_mask, Lisp_Object domain) +{ + Lisp_Image_Instance *ii = XIMAGE_INSTANCE (image_instance); + + mswindows_widget_instantiate (image_instance, instantiator, pointer_fg, + pointer_bg, dest_mask, domain, "STATIC", + /* Approximation to styles available with + an XEmacs layout. */ + (EQ (IMAGE_INSTANCE_LAYOUT_BORDER (ii), + Qetched_in) || + EQ (IMAGE_INSTANCE_LAYOUT_BORDER (ii), + Qetched_out) || + GLYPHP (IMAGE_INSTANCE_LAYOUT_BORDER (ii)) + ? SS_ETCHEDFRAME : SS_SUNKEN) | DS_CONTROL, + 0); +} + +/* Instantiate a button widget. Unfortunately instantiated widgets are + particular to a frame since they need to have a parent. It's not + like images where you just select the image into the context you + want to display it in and BitBlt it. So image instances can have a + many-to-one relationship with things you see, whereas widgets can + only be one-to-one (i.e. per frame) */ +static void +mswindows_button_instantiate (Lisp_Object image_instance, Lisp_Object instantiator, + Lisp_Object pointer_fg, Lisp_Object pointer_bg, + int dest_mask, Lisp_Object domain) +{ + /* This function can call lisp */ + Lisp_Image_Instance *ii = XIMAGE_INSTANCE (image_instance); + HWND wnd; + int flags = WS_TABSTOP | BS_NOTIFY; + /* BS_NOTIFY #### is needed to get exotic feedback only. Since we + seem to want nothing beyond BN_CLICK, the style is perhaps not + necessary -- kkm */ + Lisp_Object style; + Lisp_Object gui = IMAGE_INSTANCE_WIDGET_ITEM (ii); + Lisp_Gui_Item* pgui = XGUI_ITEM (gui); + Lisp_Object glyph = find_keyword_in_vector (instantiator, Q_image); + + if (!NILP (glyph)) + { + if (!IMAGE_INSTANCEP (glyph)) + glyph = glyph_image_instance (glyph, domain, ERROR_ME, 1); + + if (IMAGE_INSTANCEP (glyph)) + flags |= XIMAGE_INSTANCE_MSWINDOWS_BITMAP (glyph) ? + BS_BITMAP : BS_ICON; + } + + style = pgui->style; + + /* #### consider using the default face for radio and toggle + buttons. */ + if (EQ (style, Qradio)) + { + flags |= BS_RADIOBUTTON; + } + else if (EQ (style, Qtoggle)) + { + flags |= BS_AUTOCHECKBOX; + } + else + { + flags |= BS_DEFPUSHBUTTON; + } + + mswindows_widget_instantiate (image_instance, instantiator, pointer_fg, + pointer_bg, dest_mask, domain, "BUTTON", + flags, 0); + + wnd = WIDGET_INSTANCE_MSWINDOWS_HANDLE (ii); + /* set the checked state */ + if (gui_item_selected_p (gui)) + SendMessage (wnd, BM_SETCHECK, (WPARAM)BST_CHECKED, 0); + else + SendMessage (wnd, BM_SETCHECK, (WPARAM)BST_UNCHECKED, 0); + /* add the image if one was given */ + if (!NILP (glyph) && IMAGE_INSTANCEP (glyph) + && + IMAGE_INSTANCE_PIXMAP_TYPE_P (XIMAGE_INSTANCE (glyph))) + { + SendMessage (wnd, BM_SETIMAGE, + (WPARAM) (XIMAGE_INSTANCE_MSWINDOWS_BITMAP (glyph) ? + IMAGE_BITMAP : IMAGE_ICON), + (XIMAGE_INSTANCE_MSWINDOWS_BITMAP (glyph) ? + (LPARAM) XIMAGE_INSTANCE_MSWINDOWS_BITMAP (glyph) : + (LPARAM) XIMAGE_INSTANCE_MSWINDOWS_ICON (glyph))); + } +} + +/* Update the state of a button. */ +static void +mswindows_button_redisplay (Lisp_Object image_instance) +{ + /* This function can GC if IN_REDISPLAY is false. */ + Lisp_Image_Instance *ii = XIMAGE_INSTANCE (image_instance); + + /* buttons checked or otherwise */ + if (gui_item_selected_p (IMAGE_INSTANCE_WIDGET_ITEM (ii))) + SendMessage (WIDGET_INSTANCE_MSWINDOWS_HANDLE (ii), + BM_SETCHECK, (WPARAM)BST_CHECKED, 0); + else + SendMessage (WIDGET_INSTANCE_MSWINDOWS_HANDLE (ii), + BM_SETCHECK, (WPARAM)BST_UNCHECKED, 0); +} + +/* instantiate an edit control */ +static void +mswindows_edit_field_instantiate (Lisp_Object image_instance, Lisp_Object instantiator, + Lisp_Object pointer_fg, Lisp_Object pointer_bg, + int dest_mask, Lisp_Object domain) +{ + mswindows_widget_instantiate (image_instance, instantiator, pointer_fg, + pointer_bg, dest_mask, domain, "EDIT", + ES_LEFT | ES_AUTOHSCROLL | WS_TABSTOP + | WS_BORDER, WS_EX_CLIENTEDGE); +} + +/* instantiate a progress gauge */ +static void +mswindows_progress_gauge_instantiate (Lisp_Object image_instance, Lisp_Object instantiator, + Lisp_Object pointer_fg, Lisp_Object pointer_bg, + int dest_mask, Lisp_Object domain) +{ + HWND wnd; + Lisp_Image_Instance *ii = XIMAGE_INSTANCE (image_instance); + Lisp_Object val; + mswindows_widget_instantiate (image_instance, instantiator, pointer_fg, + pointer_bg, dest_mask, domain, PROGRESS_CLASS, + WS_BORDER | PBS_SMOOTH, WS_EX_CLIENTEDGE); + wnd = WIDGET_INSTANCE_MSWINDOWS_HANDLE (ii); + /* set the colors */ +#ifdef PBS_SETBKCOLOR + SendMessage (wnd, PBS_SETBKCOLOR, 0, + (LPARAM) (COLOR_INSTANCE_MSWINDOWS_COLOR + (XCOLOR_INSTANCE + (FACE_BACKGROUND + (XIMAGE_INSTANCE_WIDGET_FACE (ii), + XIMAGE_INSTANCE_FRAME (ii)))))); +#endif +#ifdef PBS_SETBARCOLOR + SendMessage (wnd, PBS_SETBARCOLOR, 0, + (L:PARAM) (COLOR_INSTANCE_MSWINDOWS_COLOR + (XCOLOR_INSTANCE + (FACE_FOREGROUND + (XIMAGE_INSTANCE_WIDGET_FACE (ii), + XIMAGE_INSTANCE_FRAME (ii)))))); +#endif + val = XGUI_ITEM (IMAGE_INSTANCE_WIDGET_ITEMS (ii))->value; + CHECK_INT (val); + SendMessage (WIDGET_INSTANCE_MSWINDOWS_HANDLE (ii), + PBM_SETPOS, (WPARAM)XINT (val), 0); +} + +/* instantiate a tree view widget */ +static HTREEITEM add_tree_item (Lisp_Object image_instance, + HWND wnd, HTREEITEM parent, Lisp_Object item, + int children, Lisp_Object domain) +{ + TV_INSERTSTRUCT tvitem; + HTREEITEM ret; + + tvitem.hParent = parent; + tvitem.hInsertAfter = TVI_LAST; + tvitem.item.mask = TVIF_TEXT | TVIF_CHILDREN; + tvitem.item.cChildren = children; + + if (GUI_ITEMP (item)) + { + tvitem.item.lParam = mswindows_register_gui_item (image_instance, + item, domain); + tvitem.item.mask |= TVIF_PARAM; + TO_EXTERNAL_FORMAT (LISP_STRING, XGUI_ITEM (item)->name, + C_STRING_ALLOCA, tvitem.item.pszText, + Qnative); + } + else + TO_EXTERNAL_FORMAT (LISP_STRING, item, + C_STRING_ALLOCA, tvitem.item.pszText, + Qnative); + + tvitem.item.cchTextMax = strlen (tvitem.item.pszText); + + if ((ret = (HTREEITEM)SendMessage (wnd, TVM_INSERTITEM, + 0, (LPARAM)&tvitem)) == 0) + signal_simple_error ("error adding tree view entry", item); + + return ret; +} + +static void add_tree_item_list (Lisp_Object image_instance, + HWND wnd, HTREEITEM parent, Lisp_Object list, + Lisp_Object domain) +{ + Lisp_Object rest; + + /* get the first item */ + parent = add_tree_item (image_instance, wnd, parent, XCAR (list), TRUE, domain); + /* recursively add items to the tree view */ + LIST_LOOP (rest, XCDR (list)) + { + if (LISTP (XCAR (rest))) + add_tree_item_list (image_instance, wnd, parent, XCAR (rest), domain); + else + add_tree_item (image_instance, wnd, parent, XCAR (rest), FALSE, domain); + } +} + +static void +mswindows_tree_view_instantiate (Lisp_Object image_instance, Lisp_Object instantiator, + Lisp_Object pointer_fg, Lisp_Object pointer_bg, + int dest_mask, Lisp_Object domain) +{ + Lisp_Object rest; + HWND wnd; + HTREEITEM parent; + Lisp_Image_Instance *ii = XIMAGE_INSTANCE (image_instance); + mswindows_widget_instantiate (image_instance, instantiator, pointer_fg, + pointer_bg, dest_mask, domain, WC_TREEVIEW, + WS_TABSTOP | WS_BORDER | PBS_SMOOTH + | TVS_HASLINES | TVS_HASBUTTONS, + WS_EX_CLIENTEDGE); + + wnd = WIDGET_INSTANCE_MSWINDOWS_HANDLE (ii); + + /* define a root */ + parent = add_tree_item (image_instance, wnd, NULL, + XCAR (IMAGE_INSTANCE_WIDGET_ITEMS (ii)), + TRUE, domain); + + /* recursively add items to the tree view */ + /* add items to the tab */ + LIST_LOOP (rest, XCDR (IMAGE_INSTANCE_WIDGET_ITEMS (ii))) + { + if (LISTP (XCAR (rest))) + add_tree_item_list (image_instance, wnd, parent, XCAR (rest), domain); + else + add_tree_item (image_instance, wnd, parent, XCAR (rest), FALSE, domain); + } +} + +/* Set the properties of a tree view. */ +static void +mswindows_tree_view_redisplay (Lisp_Object image_instance) +{ + /* This function can GC if IN_REDISPLAY is false. */ + Lisp_Image_Instance *ii = XIMAGE_INSTANCE (image_instance); + + if (IMAGE_INSTANCE_WIDGET_ITEMS_CHANGED (ii)) + { + HWND wnd = WIDGET_INSTANCE_MSWINDOWS_HANDLE (ii); + Lisp_Object rest; + HTREEITEM parent; + /* Delete previous items. */ + SendMessage (wnd, TVM_DELETEITEM, 0, (LPARAM)TVI_ROOT); + /* define a root */ + parent = add_tree_item (image_instance, wnd, NULL, + XCAR (IMAGE_INSTANCE_WIDGET_PENDING_ITEMS (ii)), + TRUE, IMAGE_INSTANCE_DOMAIN (ii)); + + /* recursively add items to the tree view */ + /* add items to the tab */ + LIST_LOOP (rest, XCDR (IMAGE_INSTANCE_WIDGET_PENDING_ITEMS (ii))) + { + if (LISTP (XCAR (rest))) + add_tree_item_list (image_instance, wnd, parent, XCAR (rest), + IMAGE_INSTANCE_DOMAIN (ii)); + else + add_tree_item (image_instance, wnd, parent, XCAR (rest), FALSE, + IMAGE_INSTANCE_DOMAIN (ii)); + } + } +} + +/* instantiate a tab control */ +static int +add_tab_item (Lisp_Object image_instance, + HWND wnd, Lisp_Object item, + Lisp_Object domain, int i) +{ + TC_ITEM tvitem; + int ret = 0; + + tvitem.mask = TCIF_TEXT; + + if (GUI_ITEMP (item)) + { + tvitem.lParam = mswindows_register_gui_item (image_instance, + item, domain); + tvitem.mask |= TCIF_PARAM; + TO_EXTERNAL_FORMAT (LISP_STRING, XGUI_ITEM (item)->name, + C_STRING_ALLOCA, tvitem.pszText, + Qnative); + } + else + { + CHECK_STRING (item); + TO_EXTERNAL_FORMAT (LISP_STRING, item, + C_STRING_ALLOCA, tvitem.pszText, + Qnative); + } + + tvitem.cchTextMax = strlen (tvitem.pszText); + + if ((ret = SendMessage (wnd, TCM_INSERTITEM, + i, (LPARAM)&tvitem)) < 0) + signal_simple_error ("error adding tab entry", item); + + return ret; +} + +static void +mswindows_tab_control_instantiate (Lisp_Object image_instance, Lisp_Object instantiator, + Lisp_Object pointer_fg, Lisp_Object pointer_bg, + int dest_mask, Lisp_Object domain) +{ + /* This function can call lisp */ + Lisp_Object rest; + HWND wnd; + int i = 0, selected = 0; + Lisp_Image_Instance *ii = XIMAGE_INSTANCE (image_instance); + Lisp_Object orient = find_keyword_in_vector (instantiator, Q_orientation); + unsigned int flags = WS_TABSTOP; + + if (EQ (orient, Qleft) || EQ (orient, Qright)) + { + flags |= TCS_VERTICAL | TCS_MULTILINE; + } + if (EQ (orient, Qright) || EQ (orient, Qbottom)) + { + flags |= TCS_BOTTOM; + } + + mswindows_widget_instantiate (image_instance, instantiator, pointer_fg, + pointer_bg, dest_mask, domain, WC_TABCONTROL, + /* borders don't suit tabs so well */ + flags, 0); + wnd = WIDGET_INSTANCE_MSWINDOWS_HANDLE (ii); + /* add items to the tab */ + LIST_LOOP (rest, XCDR (IMAGE_INSTANCE_WIDGET_ITEMS (ii))) + { + int idx = add_tab_item (image_instance, wnd, XCAR (rest), domain, i); + assert (idx == i); + if (gui_item_selected_p (XCAR (rest))) + selected = i; + i++; + } + SendMessage (wnd, TCM_SETCURSEL, selected, 0); +} + +/* Set the properties of a tab control. */ +static void +mswindows_tab_control_redisplay (Lisp_Object image_instance) +{ + /* This function can GC if IN_REDISPLAY is false. */ + Lisp_Image_Instance *ii = XIMAGE_INSTANCE (image_instance); +#ifdef DEBUG_WIDGET_OUTPUT + stderr_out ("tab control %p redisplayed\n", IMAGE_INSTANCE_SUBWINDOW_ID (ii)); +#endif + if (IMAGE_INSTANCE_WIDGET_ITEMS_CHANGED (ii) + || + IMAGE_INSTANCE_WIDGET_ACTION_OCCURRED (ii)) + { + HWND wnd = WIDGET_INSTANCE_MSWINDOWS_HANDLE (ii); + int i = 0, selected_idx = 0; + Lisp_Object rest; + + assert (!NILP (IMAGE_INSTANCE_WIDGET_ITEMS (ii))); + + /* If only the order has changed then simply select the first + one. This stops horrendous rebuilding of the tabs each time + you click on one. */ + if (tab_control_order_only_changed (image_instance)) + { + Lisp_Object selected = + gui_item_list_find_selected + (NILP (IMAGE_INSTANCE_WIDGET_PENDING_ITEMS (ii)) ? + XCDR (IMAGE_INSTANCE_WIDGET_ITEMS (ii)) : + XCDR (IMAGE_INSTANCE_WIDGET_PENDING_ITEMS (ii))); + + LIST_LOOP (rest, XCDR (IMAGE_INSTANCE_WIDGET_ITEMS (ii))) + { + if (gui_item_equal_sans_selected (XCAR (rest), selected, 0)) + { + Lisp_Object old_selected = gui_item_list_find_selected + (XCDR (IMAGE_INSTANCE_WIDGET_ITEMS (ii))); + + /* Pick up the new selected item. */ + XGUI_ITEM (old_selected)->selected = + XGUI_ITEM (XCAR (rest))->selected; + XGUI_ITEM (XCAR (rest))->selected = + XGUI_ITEM (selected)->selected; + /* We're not actually changing the items. */ + IMAGE_INSTANCE_WIDGET_ITEMS_CHANGED (ii) = 0; + IMAGE_INSTANCE_WIDGET_PENDING_ITEMS (ii) = Qnil; + + SendMessage (wnd, TCM_SETCURSEL, i, 0); +#ifdef DEBUG_WIDGET_OUTPUT + stderr_out ("tab control %p selected item %d\n", + IMAGE_INSTANCE_SUBWINDOW_ID (ii), i); +#endif + break; + } + i++; + } + } + else + { + /* delete the pre-existing items */ + SendMessage (wnd, TCM_DELETEALLITEMS, 0, 0); + + /* add items to the tab */ + LIST_LOOP (rest, XCDR (IMAGE_INSTANCE_WIDGET_PENDING_ITEMS (ii))) + { + add_tab_item (image_instance, wnd, XCAR (rest), + IMAGE_INSTANCE_FRAME (ii), i); + if (gui_item_selected_p (XCAR (rest))) + selected_idx = i; + i++; + } + SendMessage (wnd, TCM_SETCURSEL, selected_idx, 0); + } + } +} + +/* instantiate a static control possible for putting other things in */ +static void +mswindows_label_instantiate (Lisp_Object image_instance, Lisp_Object instantiator, + Lisp_Object pointer_fg, Lisp_Object pointer_bg, + int dest_mask, Lisp_Object domain) +{ + mswindows_widget_instantiate (image_instance, instantiator, pointer_fg, + pointer_bg, dest_mask, domain, "STATIC", + 0, WS_EX_STATICEDGE); +} + +/* instantiate a scrollbar control */ +static void +mswindows_scrollbar_instantiate (Lisp_Object image_instance, Lisp_Object instantiator, + Lisp_Object pointer_fg, Lisp_Object pointer_bg, + int dest_mask, Lisp_Object domain) +{ + mswindows_widget_instantiate (image_instance, instantiator, pointer_fg, + pointer_bg, dest_mask, domain, "SCROLLBAR", + WS_TABSTOP, WS_EX_CLIENTEDGE); +} + +/* instantiate a combo control */ +static void +mswindows_combo_box_instantiate (Lisp_Object image_instance, Lisp_Object instantiator, + Lisp_Object pointer_fg, Lisp_Object pointer_bg, + int dest_mask, Lisp_Object domain) +{ + Lisp_Image_Instance *ii = XIMAGE_INSTANCE (image_instance); + HWND wnd; + Lisp_Object rest; + Lisp_Object items = find_keyword_in_vector (instantiator, Q_items); + int len, height; + + /* Maybe ought to generalise this more but it may be very windows + specific. In windows the window height of a combo box is the + height when the combo box is open. Thus we need to set the height + before creating the window and then reset it to a single line + after the window is created so that redisplay does the right + thing. */ + widget_instantiate (image_instance, instantiator, pointer_fg, + pointer_bg, dest_mask, domain); + + /* We now have everything right apart from the height. */ + default_face_font_info (domain, 0, 0, &height, 0, 0); + GET_LIST_LENGTH (items, len); + + height = (height + DEFAULT_WIDGET_BORDER_WIDTH * 2 ) * len; + IMAGE_INSTANCE_HEIGHT (ii) = height; + + /* Now create the widget. */ + mswindows_widget_instantiate (image_instance, instantiator, pointer_fg, + pointer_bg, dest_mask, domain, "COMBOBOX", + WS_BORDER | WS_TABSTOP | CBS_DROPDOWN + | CBS_AUTOHSCROLL + | CBS_HASSTRINGS | WS_VSCROLL, + WS_EX_CLIENTEDGE); + /* Reset the height. layout will probably do this safely, but better make sure. */ + image_instance_layout (image_instance, + IMAGE_UNSPECIFIED_GEOMETRY, + IMAGE_UNSPECIFIED_GEOMETRY, + IMAGE_UNCHANGED_GEOMETRY, + IMAGE_UNCHANGED_GEOMETRY, + domain); + + wnd = WIDGET_INSTANCE_MSWINDOWS_HANDLE (ii); + /* add items to the combo box */ + SendMessage (wnd, CB_RESETCONTENT, 0, 0); + LIST_LOOP (rest, items) + { + Extbyte* lparam; + TO_EXTERNAL_FORMAT (LISP_STRING, XCAR (rest), + C_STRING_ALLOCA, lparam, + Qnative); + if (SendMessage (wnd, CB_ADDSTRING, 0, (LPARAM)lparam) == CB_ERR) + signal_simple_error ("error adding combo entries", instantiator); + } +} + +/* get properties of a control */ +static Lisp_Object +mswindows_widget_property (Lisp_Object image_instance, Lisp_Object prop) +{ + Lisp_Image_Instance *ii = XIMAGE_INSTANCE (image_instance); + HWND wnd = WIDGET_INSTANCE_MSWINDOWS_HANDLE (ii); + /* get the text from a control */ + if (EQ (prop, Q_text)) + { + Extcount len = SendMessage (wnd, WM_GETTEXTLENGTH, 0, 0); + Extbyte *buf = (Extbyte*) alloca (len+1); + + SendMessage (wnd, WM_GETTEXT, (WPARAM)len+1, (LPARAM) buf); + return build_ext_string (buf, Qnative); + } + return Qunbound; +} + +/* get properties of a button */ +static Lisp_Object +mswindows_button_property (Lisp_Object image_instance, Lisp_Object prop) +{ + Lisp_Image_Instance *ii = XIMAGE_INSTANCE (image_instance); + HWND wnd = WIDGET_INSTANCE_MSWINDOWS_HANDLE (ii); + /* check the state of a button */ + if (EQ (prop, Q_selected)) + { + if (SendMessage (wnd, BM_GETSTATE, 0, 0) & BST_CHECKED) + return Qt; + else + return Qnil; + } + return Qunbound; +} + +/* get properties of a combo box */ +static Lisp_Object +mswindows_combo_box_property (Lisp_Object image_instance, Lisp_Object prop) +{ + Lisp_Image_Instance *ii = XIMAGE_INSTANCE (image_instance); + HWND wnd = WIDGET_INSTANCE_MSWINDOWS_HANDLE (ii); + /* get the text from a control */ + if (EQ (prop, Q_text)) + { + long item = SendMessage (wnd, CB_GETCURSEL, 0, 0); + Extcount len = SendMessage (wnd, CB_GETLBTEXTLEN, (WPARAM)item, 0); + Extbyte* buf = (Extbyte*) alloca (len+1); + SendMessage (wnd, CB_GETLBTEXT, (WPARAM)item, (LPARAM)buf); + return build_ext_string (buf, Qnative); + } + return Qunbound; +} + +/* set the properties of a progress gauge */ +static void +mswindows_progress_gauge_redisplay (Lisp_Object image_instance) +{ + Lisp_Image_Instance *ii = XIMAGE_INSTANCE (image_instance); + + if (IMAGE_INSTANCE_WIDGET_ITEMS_CHANGED (ii)) + { + Lisp_Object val; +#ifdef ERROR_CHECK_GLYPHS + assert (GUI_ITEMP (IMAGE_INSTANCE_WIDGET_PENDING_ITEMS (ii))); +#endif + val = XGUI_ITEM (IMAGE_INSTANCE_WIDGET_PENDING_ITEMS (ii))->value; +#ifdef DEBUG_WIDGET_OUTPUT + stderr_out ("progress gauge displayed value on %p updated to %ld\n", + WIDGET_INSTANCE_MSWINDOWS_HANDLE (ii), + XINT(val)); +#endif + CHECK_INT (val); + SendMessage (WIDGET_INSTANCE_MSWINDOWS_HANDLE (ii), + PBM_SETPOS, (WPARAM)XINT (val), 0); + } +} + +LRESULT WINAPI +mswindows_control_wnd_proc (HWND hwnd, UINT msg, + WPARAM wParam, LPARAM lParam) +{ + switch (msg) + { + case WM_NOTIFY: + case WM_COMMAND: + case WM_CTLCOLORBTN: + case WM_CTLCOLORLISTBOX: + case WM_CTLCOLOREDIT: + case WM_CTLCOLORSTATIC: + case WM_CTLCOLORSCROLLBAR: + + return mswindows_wnd_proc (GetParent (hwnd), msg, wParam, lParam); + default: + return DefWindowProc (hwnd, msg, wParam, lParam); + } +} + +#endif /* HAVE_WIDGETS */ + + /************************************************************************/ /* initialization */ /************************************************************************/ @@ -1936,27 +3234,108 @@ syms_of_glyphs_mswindows (void) void console_type_create_glyphs_mswindows (void) { - /* image methods */ - + /* image methods - display */ CONSOLE_HAS_METHOD (mswindows, print_image_instance); CONSOLE_HAS_METHOD (mswindows, finalize_image_instance); + CONSOLE_HAS_METHOD (mswindows, unmap_subwindow); + CONSOLE_HAS_METHOD (mswindows, map_subwindow); + CONSOLE_HAS_METHOD (mswindows, redisplay_subwindow); + CONSOLE_HAS_METHOD (mswindows, resize_subwindow); + CONSOLE_HAS_METHOD (mswindows, redisplay_widget); CONSOLE_HAS_METHOD (mswindows, image_instance_equal); CONSOLE_HAS_METHOD (mswindows, image_instance_hash); CONSOLE_HAS_METHOD (mswindows, init_image_instance_from_eimage); CONSOLE_HAS_METHOD (mswindows, locate_pixmap_file); -#ifdef HAVE_XPM - CONSOLE_HAS_METHOD (mswindows, xpm_instantiate); -#endif - CONSOLE_HAS_METHOD (mswindows, xbm_instantiate); + CONSOLE_HAS_METHOD (mswindows, widget_border_width); + + /* image methods - printer */ + CONSOLE_INHERITS_METHOD (msprinter, mswindows, print_image_instance); + CONSOLE_INHERITS_METHOD (msprinter, mswindows, finalize_image_instance); + CONSOLE_INHERITS_METHOD (msprinter, mswindows, image_instance_equal); + CONSOLE_INHERITS_METHOD (msprinter, mswindows, image_instance_hash); + CONSOLE_INHERITS_METHOD (msprinter, mswindows, init_image_instance_from_eimage); + CONSOLE_INHERITS_METHOD (msprinter, mswindows, locate_pixmap_file); } void image_instantiator_format_create_glyphs_mswindows (void) { + IIFORMAT_VALID_CONSOLE2 (mswindows, msprinter, nothing); + IIFORMAT_VALID_CONSOLE2 (mswindows, msprinter, string); + IIFORMAT_VALID_CONSOLE2 (mswindows, msprinter, formatted_string); + IIFORMAT_VALID_CONSOLE2 (mswindows, msprinter, inherit); /* image-instantiator types */ - + INITIALIZE_DEVICE_IIFORMAT (mswindows, xbm); + INITIALIZE_DEVICE_IIFORMAT (msprinter, xbm); + IIFORMAT_HAS_DEVMETHOD (mswindows, xbm, instantiate); + IIFORMAT_INHERITS_DEVMETHOD (msprinter, mswindows, xbm, instantiate); +#ifdef HAVE_XPM + INITIALIZE_DEVICE_IIFORMAT (mswindows, xpm); + INITIALIZE_DEVICE_IIFORMAT (msprinter, xpm); + IIFORMAT_HAS_DEVMETHOD (mswindows, xpm, instantiate); + IIFORMAT_INHERITS_DEVMETHOD (msprinter, mswindows, xpm, instantiate); +#endif +#ifdef HAVE_XFACE + INITIALIZE_DEVICE_IIFORMAT (mswindows, xface); + INITIALIZE_DEVICE_IIFORMAT (msprinter, xface); + IIFORMAT_HAS_DEVMETHOD (mswindows, xface, instantiate); + IIFORMAT_INHERITS_DEVMETHOD (msprinter, mswindows, xface, instantiate); +#endif +#ifdef HAVE_JPEG + IIFORMAT_VALID_CONSOLE2 (mswindows, msprinter, jpeg); +#endif +#ifdef HAVE_TIFF + IIFORMAT_VALID_CONSOLE2 (mswindows, msprinter, tiff); +#endif +#ifdef HAVE_PNG + IIFORMAT_VALID_CONSOLE2 (mswindows, msprinter, png); +#endif +#ifdef HAVE_GIF + IIFORMAT_VALID_CONSOLE2 (mswindows, msprinter, gif); +#endif +#ifdef HAVE_WIDGETS + INITIALIZE_DEVICE_IIFORMAT (mswindows, widget); + IIFORMAT_HAS_DEVMETHOD (mswindows, widget, property); + /* layout widget */ + IIFORMAT_VALID_CONSOLE (mswindows, layout); + INITIALIZE_DEVICE_IIFORMAT (mswindows, native_layout); + IIFORMAT_HAS_DEVMETHOD (mswindows, native_layout, instantiate); + /* button widget */ + INITIALIZE_DEVICE_IIFORMAT (mswindows, button); + IIFORMAT_HAS_DEVMETHOD (mswindows, button, property); + IIFORMAT_HAS_DEVMETHOD (mswindows, button, instantiate); + IIFORMAT_HAS_DEVMETHOD (mswindows, button, redisplay); + /* edit-field widget */ + INITIALIZE_DEVICE_IIFORMAT (mswindows, edit_field); + IIFORMAT_HAS_DEVMETHOD (mswindows, edit_field, instantiate); + /* subwindow */ + INITIALIZE_DEVICE_IIFORMAT (mswindows, subwindow); + IIFORMAT_HAS_DEVMETHOD (mswindows, subwindow, instantiate); + /* label */ + INITIALIZE_DEVICE_IIFORMAT (mswindows, label); + IIFORMAT_HAS_DEVMETHOD (mswindows, label, instantiate); + /* combo box */ + INITIALIZE_DEVICE_IIFORMAT (mswindows, combo_box); + IIFORMAT_HAS_DEVMETHOD (mswindows, combo_box, property); + IIFORMAT_HAS_DEVMETHOD (mswindows, combo_box, instantiate); + /* scrollbar */ + INITIALIZE_DEVICE_IIFORMAT (mswindows, scrollbar); + IIFORMAT_HAS_DEVMETHOD (mswindows, scrollbar, instantiate); + /* progress gauge */ + INITIALIZE_DEVICE_IIFORMAT (mswindows, progress_gauge); + IIFORMAT_HAS_DEVMETHOD (mswindows, progress_gauge, redisplay); + IIFORMAT_HAS_DEVMETHOD (mswindows, progress_gauge, instantiate); + /* tree view widget */ + INITIALIZE_DEVICE_IIFORMAT (mswindows, tree_view); + IIFORMAT_HAS_DEVMETHOD (mswindows, tree_view, instantiate); + IIFORMAT_HAS_DEVMETHOD (mswindows, tree_view, redisplay); + /* tab control widget */ + INITIALIZE_DEVICE_IIFORMAT (mswindows, tab_control); + IIFORMAT_HAS_DEVMETHOD (mswindows, tab_control, instantiate); + IIFORMAT_HAS_DEVMETHOD (mswindows, tab_control, redisplay); +#endif + /* windows bitmap format */ INITIALIZE_IMAGE_INSTANTIATOR_FORMAT (bmp, "bmp"); - IIFORMAT_HAS_METHOD (bmp, validate); IIFORMAT_HAS_METHOD (bmp, normalize); IIFORMAT_HAS_METHOD (bmp, possible_dest_types); @@ -1964,7 +3343,9 @@ image_instantiator_format_create_glyphs_mswindows (void) IIFORMAT_VALID_KEYWORD (bmp, Q_data, check_valid_string); IIFORMAT_VALID_KEYWORD (bmp, Q_file, check_valid_string); + IIFORMAT_VALID_CONSOLE2 (mswindows, msprinter, bmp); + /* mswindows resources */ INITIALIZE_IMAGE_INSTANTIATOR_FORMAT (mswindows_resource, "mswindows-resource"); @@ -1973,17 +3354,16 @@ image_instantiator_format_create_glyphs_mswindows (void) IIFORMAT_HAS_METHOD (mswindows_resource, possible_dest_types); IIFORMAT_HAS_METHOD (mswindows_resource, instantiate); - IIFORMAT_VALID_KEYWORD (mswindows_resource, Q_resource_type, + IIFORMAT_VALID_KEYWORD (mswindows_resource, Q_resource_type, check_valid_resource_symbol); IIFORMAT_VALID_KEYWORD (mswindows_resource, Q_resource_id, check_valid_resource_id); IIFORMAT_VALID_KEYWORD (mswindows_resource, Q_file, check_valid_string); + IIFORMAT_VALID_CONSOLE2 (mswindows, msprinter, mswindows_resource); } void vars_of_glyphs_mswindows (void) { - Fprovide (Qbmp); - Fprovide (Qmswindows_resource); DEFVAR_LISP ("mswindows-bitmap-file-path", &Vmswindows_bitmap_file_path /* A list of the directories in which mswindows bitmap files may be found. This is used by the `make-image-instance' function.