xemacs-beta: src/glyphs-msw.c comparison

comparison src/glyphs-msw.c @ 434:9d177e8d4150 r21-2-25

Import from CVS: tag r21-2-25

author	cvs
date	Mon, 13 Aug 2007 11:30:53 +0200
parents	a5df635868b2
children	84b14dcb0985

comparison

equal deleted inserted replaced

-:892ca416f0fb
+:9d177e8d4150
 /* mswindows-specific glyph objects.
 Copyright (C) 1998, 1999 Andy Piper.
 This file is part of XEmacs.
 XEmacs is free software; you can redistribute it and/or modify it
 under the terms of the GNU General Public License as published by the
 Free Software Foundation; either version 2, or (at your option) any
 #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);
 #endif
 DEFINE_DEVICE_IIFORMAT (mswindows, xbm);
 #ifdef HAVE_XFACE
 static void
 mswindows_initialize_dibitmap_image_instance (struct 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);
 COLORREF mswindows_string_to_color (CONST char *name);
 #define BPLINE(width) ((int)(~3UL & (unsigned long)((width) +3)))
 * long. Windows can actually handle rgb triples in the raw so I
 * don't see much point trying to optimize down to the best
 * structure - unless it has memory / color allocation implications
 * .... */
 bmp_info=xnew_and_zero (BITMAPINFO);
 if (!bmp_info)
 	{
 	  return NULL;
 	}
 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;
 /* bitmap data needs to be in blue, green, red triples - in that
 	 order, eimage is in RGB format so we need to convert */
 *bmp_data = xnew_array_and_zero (unsigned char, bpline * height);
 *bit_count = bpline * height;
 qtable = build_EImage_quantable(pic, width, height, 256);
 if (qtable == NULL) return NULL;
 /* use our quantize table to allocate the colors */
 ncolors = qtable->num_active_colors;
 bmp_info=(BITMAPINFO*)xmalloc_and_zero (sizeof(BITMAPINFOHEADER) +
 					     sizeof(RGBQUAD) * ncolors);
 if (!bmp_info)
 	{
 	  xfree (qtable);
 	  return NULL;
 	}
 colortbl=(RGBQUAD*)(((unsigned char*)bmp_info)+sizeof(BITMAPINFOHEADER));
 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_data = (unsigned char *) xmalloc_and_zero (bpline * height);
 *bit_count = bpline * height;
 if (!*bmp_data)
 	{
 	  xfree (qtable);
 	  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];
 	  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;
 return bmp_info;
 }
 /* Given a pixmap filename, look through all of the "standard" places
 GCPRO1 (temp);
 locate_file (temp, name, Qnil, &found, R_OK);
 UNGCPRO;
 }
 return found;
 }
 /* Initialize an image instance from a bitmap
 				   BITMAPINFO *bmp_info,
 				   int dest_mask,
 				   void *bmp_data,
 				   int bmp_bits,
 				   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);
 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
 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);
 if (!bitmap || !bmp_buf)
 signal_simple_error ("Unable to create bitmap", instantiator);
 if (create_mask)
 {
 mswindows_initialize_image_instance_mask (ii, f);
 }
 if (type == IMAGE_POINTER)
 {
 mswindows_initialize_image_instance_icon(ii, TRUE);
 }
 }
 Lisp_Object device = IMAGE_INSTANCE_DEVICE (ii);
 struct device *d = XDEVICE (device);
 struct frame *f = XFRAME (DEVICE_SELECTED_FRAME (d));
 void* bmp_buf=0;
 HDC hdc = FRAME_MSWINDOWS_CDC (f);
 HBITMAP bitmap = CreateDIBSection (hdc,
 				     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);
 static void
 mswindows_init_image_instance_from_eimage (struct Lisp_Image_Instance *ii,
 					   int width, int height,
 					   int slices,
 					   unsigned char *eimage,
 					   int dest_mask,
 					   Lisp_Object instantiator,
 					   Lisp_Object domain)
 {
 Lisp_Object device = IMAGE_INSTANCE_DEVICE (ii);
 BITMAPINFO*		bmp_info;
 unsigned char*	bmp_data;
 int			bmp_bits;
 COLORREF		bkcolor;
 int slice;
 if (!DEVICE_MSWINDOWS_P (XDEVICE (device)))
 signal_simple_error ("Not an mswindows device", device);
 /* this is a hack but MaskBlt and TransparentBlt are not supported
 on most windows variants */
 bkcolor = COLOR_INSTANCE_MSWINDOWS_COLOR
 (XCOLOR_INSTANCE (FACE_BACKGROUND (Vdefault_face, domain)));
 for (slice = 0; slice < slices; slice++)
 {
 /* 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);
 					   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);
 }
 }
 static void set_mono_pixel ( unsigned char* bits,
 			     int bpline, int height,
 			     int x, int y, int white )
 {
 int index;
 unsigned char    bitnum;
 /* Find the byte on which this scanline begins */
 index = (height - y - 1) * bpline;
 /* Find the byte containing this pixel */
 index += (x >> 3);
 /* Which bit is it? */
 bitnum = (unsigned char)( 7 - (x % 8) );
 if( white )         /* Turn it on */
 bits[index] |= (1<<bitnum);
 else         /* Turn it off */
 bits[index] &= ~(1<<bitnum);
 }
 static void
 mswindows_initialize_image_instance_mask (struct Lisp_Image_Instance* image,
 					  struct frame* f)
 {
 HBITMAP mask;
 HGDIOBJ old = NULL;
 HDC hcdc = FRAME_MSWINDOWS_CDC (f);
 unsigned char* dibits;
 BITMAPINFO* bmp_info =
 xmalloc_and_zero (sizeof(BITMAPINFO) + sizeof(RGBQUAD));
 int i, j;
 int height = IMAGE_INSTANCE_PIXMAP_HEIGHT (image);
 void* and_bits;
-int maskbpline = BPLINE (((IMAGE_INSTANCE_PIXMAP_WIDTH (image)+7)/8));
+int maskbpline = BPLINE ((IMAGE_INSTANCE_PIXMAP_WIDTH (image)+7)/8);
 int bpline = BPLINE (IMAGE_INSTANCE_PIXMAP_WIDTH (image) * 3);
 if (!bmp_info)
 return;
 bmp_info->bmiHeader.biWidth=IMAGE_INSTANCE_PIXMAP_WIDTH (image);
 bmp_info->bmiHeader.biHeight = height;
 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->bmiColors[0].rgbRed = 0;
 bmp_info->bmiColors[0].rgbGreen = 0;
 bmp_info->bmiColors[0].rgbBlue = 0;
 bmp_info->bmiColors[0].rgbReserved = 0;
 bmp_info->bmiColors[1].rgbRed = 255;
 bmp_info->bmiColors[1].rgbGreen = 255;
 bmp_info->bmiColors[1].rgbBlue = 255;
 bmp_info->bmiColors[0].rgbReserved = 0;
 if (!(mask = CreateDIBSection (hcdc,
 				 bmp_info,
 				 DIB_RGB_COLORS,
 				 &and_bits,
 				 0,0)))
 {
 xfree (bmp_info);
 return;
 }
 bmp_info->bmiHeader.biWidth=IMAGE_INSTANCE_PIXMAP_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.biSizeImage = height * bpline;
 dibits = xmalloc_and_zero (bpline * height);
 if (GetDIBits (hcdc,
 		 IMAGE_INSTANCE_MSWINDOWS_BITMAP (image),
 return;
 }
 /* now set the colored bits in the mask and transparent ones to
 black in the original */
 for(i=0; i<IMAGE_INSTANCE_PIXMAP_WIDTH (image); i++)
 {
 for(j=0; j<height; j++)
 	{
 	  unsigned char* idx = &dibits[j * bpline + i * 3];
 	  if( RGB (idx[2], idx[1], idx[0]) == transparent_color )
 	    {
 	      idx[0] = idx[1] = idx[2] = 0;
 	      set_mono_pixel( and_bits, maskbpline, height, i, j, TRUE );
 	    }
 	  else
 	    {
 	      set_mono_pixel( and_bits, maskbpline, height, i, j, FALSE );
 }
 	}
 }
 	     bmp_info,
 	     DIB_RGB_COLORS);
 xfree (bmp_info);
 xfree (dibits);
 SelectObject(hcdc, old);
 IMAGE_INSTANCE_MSWINDOWS_MASK (image) = mask;
 }
 x_icon.fIcon=cursor ? FALSE : TRUE;
 x_icon.xHotspot=XINT (IMAGE_INSTANCE_PIXMAP_HOTSPOT_X (image));
 x_icon.yHotspot=XINT (IMAGE_INSTANCE_PIXMAP_HOTSPOT_Y (image));
 x_icon.hbmMask=IMAGE_INSTANCE_MSWINDOWS_MASK (image);
 x_icon.hbmColor=IMAGE_INSTANCE_MSWINDOWS_BITMAP (image);
 IMAGE_INSTANCE_MSWINDOWS_ICON (image)=
 CreateIconIndirect (&x_icon);
 }
 HBITMAP
 				 int newx, int newy)
 {
 HBITMAP newbmp;
 HGDIOBJ old1, old2;
 HDC hcdc = FRAME_MSWINDOWS_CDC (f);
 HDC hdcDst = CreateCompatibleDC (hcdc);
 old1 = SelectObject (hcdc, IMAGE_INSTANCE_MSWINDOWS_BITMAP (ii));
 newbmp = CreateCompatibleBitmap (hcdc, newx, newy);
 old2 = SelectObject (hdcDst, newbmp);
 if (!StretchBlt (hdcDst, 0, 0, newx, newy,
 		   hcdc, 0, 0,
 		   IMAGE_INSTANCE_PIXMAP_WIDTH (ii),
 		   IMAGE_INSTANCE_PIXMAP_HEIGHT (ii),
 		   SRCCOPY))
 {
 DeleteObject (newbmp);
 DeleteDC (hdcDst);
 return 0;
 if (IMAGE_INSTANCE_MSWINDOWS_MASK (ii))
 {
 HBITMAP newmask;
 HGDIOBJ old1, old2;
 HDC hcdc = FRAME_MSWINDOWS_CDC (f);
 HDC hdcDst = CreateCompatibleDC (hcdc);
 old1 = SelectObject (hcdc, IMAGE_INSTANCE_MSWINDOWS_MASK (ii));
 newmask = CreateCompatibleBitmap(hcdc, newx, newy);
 old2 = SelectObject (hdcDst, newmask);
 if (!StretchBlt(hdcDst, 0, 0, newx, newy,
 		      hcdc, 0, 0,
 		      IMAGE_INSTANCE_PIXMAP_WIDTH (ii),
 		      IMAGE_INSTANCE_PIXMAP_HEIGHT (ii),
 		      SRCCOPY))
 	{
 	  DeleteObject (newmask);
 	  DeleteDC (hdcDst);
 	  return NULL;
 	}
 SelectObject (hdcDst, old2);
 SelectObject (hcdc, old1);
 DeleteDC (hdcDst);
 HBITMAP newbmp = mswindows_create_resized_bitmap (ii, f, newx, newy);
 HBITMAP newmask = mswindows_create_resized_mask (ii, f, newx, newy);
 if (!newbmp)
 return FALSE;
 if (IMAGE_INSTANCE_MSWINDOWS_BITMAP (ii))
 DeleteObject (IMAGE_INSTANCE_MSWINDOWS_BITMAP (ii));
 if (IMAGE_INSTANCE_MSWINDOWS_MASK (ii))
 DeleteObject (IMAGE_INSTANCE_MSWINDOWS_MASK (ii));
 colortbl = xnew_array_and_zero (struct color_symbol, i);
 for (j=0; j<i; j++)
 {
 Lisp_Object cons = XCAR (results);
 colortbl[j].color =
 	COLOR_INSTANCE_MSWINDOWS_COLOR (XCOLOR_INSTANCE (XCDR (cons)));
 GET_C_STRING_OS_DATA_ALLOCA (XCAR (cons), colortbl[j].name);
 colortbl[j].name = xstrdup (colortbl[j].name); /* mustn't lose this when we return */
 free_cons (XCONS (cons));
 XpmInfo xpminfo;
 int result, i, j, transp_idx, maskbpline;
 unsigned char* dptr;
 unsigned int* sptr;
 COLORREF color; /* the american spelling virus hits again .. */
 COLORREF* colortbl;
 xzero (xpmimage);
 xzero (xpminfo);
 xpminfo.valuemask=XpmHotspot;
 *transp=FALSE;
 	signal_double_file_error_2 ("Parsing pixmap data",
 				    "unknown error code",
 				    make_int (result), image);
 }
 }
 *width = xpmimage.width;
 *height = xpmimage.height;
-maskbpline = BPLINE (((~7UL & (unsigned long)(*width + 7)) / 8));
+maskbpline = BPLINE ((~7UL & (unsigned long)(*width + 7)) / 8);
 *data = xnew_array_and_zero (unsigned char, *width * *height * 3);
 if (!*data)
 {
 XpmFreeXpmImage (&xpmimage);
 	  if (!strcasecmp (xpmimage.colorTable[i].symbolic,"BgColor")
 	      ||
 	      !strcasecmp (xpmimage.colorTable[i].symbolic,"None"))
 	    {
 	      *transp=TRUE;
 	      colortbl[i]=transparent_color;
 	      transp_idx=i;
 	      goto label_found_color;
 	    }
 	  else if (color_symbols)
 	    {
 	}
 /* pick up transparencies */
 if (!strcasecmp (xpmimage.colorTable[i].c_color,"None"))
 	{
 	  *transp=TRUE;
 	  colortbl[i]=transparent_color;
 	  transp_idx=i;
 	  goto label_found_color;
 	}
 /* finally pick up a normal color spec */
 if (xpmimage.colorTable[i].c_color)
 	{
 	  colortbl[i]=
 	    mswindows_string_to_color (xpmimage.colorTable[i].c_color);
 	  goto label_found_color;
 	}
 label_no_color:
 xfree (*data);
 xfree (colortbl);
 XpmFreeXpmImage (&xpmimage);
 XpmFreeXpmInfo (&xpminfo);
 return 0;
 label_found_color:;
 }
 /* convert the image */
 sptr=xpmimage.data;
 BITMAPINFO*		bmp_info;
 unsigned char*	bmp_data;
 int			bmp_bits;
 int 			nsymbols=0, transp;
 struct color_symbol*	color_symbols=NULL;
 Lisp_Object data = find_keyword_in_vector (instantiator, Q_data);
 Lisp_Object color_symbol_alist = find_keyword_in_vector (instantiator,
 							   Q_color_symbols);
 if (!DEVICE_MSWINDOWS_P (XDEVICE (device)))
 /* convert to an eimage to make processing easier */
 if (!xpm_to_eimage (image_instance, bytes, &eimage, &width, &height,
 		      &x_hot, &y_hot, &transp, color_symbols, nsymbols))
 {
 signal_simple_error ("XPM to EImage conversion failed",
 			   image_instance);
 }
 if (color_symbols)
 {
 while (nsymbols--)
 	{
 	  xfree (color_symbols[nsymbols].name);
 	}
 xfree(color_symbols);
 }
 /* build a bitmap from the eimage */
 if (!(bmp_info=convert_EImage_to_DIBitmap (device, width, height, eimage,
 					     &bmp_bits, &bmp_data)))
 {
 signal_simple_error ("XPM to EImage conversion failed",
 signal_simple_error ("Not an mswindows device", device);
 assert (!NILP (data));
 GET_STRING_BINARY_DATA_ALLOCA (data, bytes, len);
 /* Then slurp the image into memory, decoding along the way.
 The result is the image in a simple one-byte-per-pixel
 format. */
 bmp_file_header=(BITMAPFILEHEADER*)bytes;
 bmp_info = (BITMAPINFO*)(bytes + sizeof(BITMAPFILEHEADER));
 bmp_data = (Extbyte*)bytes + bmp_file_header->bfOffBits;
 bmp_bits = bmp_file_header->bfSize - bmp_file_header->bfOffBits;
 **********************************************************************/
 static void
 mswindows_resource_validate (Lisp_Object instantiator)
 {
 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_type)))
 signal_simple_error ("Must supply :file, :resource-id and :resource-type",
 			 instantiator);
 }
 struct gcpro gcpro1, gcpro2;
 Lisp_Object alist = Qnil;
 GCPRO2 (file, alist);
 file = potential_pixmap_file_instantiator (inst, Q_file, Q_data,
 					     console_type);
 if (CONSP (file)) /* failure locating filename */
 signal_double_file_error ("Opening pixmap file",
 			      "no such file or directory",
 mswindows_resource_possible_dest_types (void)
 {
 return IMAGE_POINTER_MASK | IMAGE_COLOR_PIXMAP_MASK;
 }
 typedef struct
 {
 char *name;
 int	resource_id;
 } resource_t;
 #if defined (__CYGWIN32__) && CYGWIN_VERSION_DLL_MAJOR < 21
 #define LR_SHARED           0x8000
 #endif
 #endif
 static CONST resource_t bitmap_table[] =
 {
 /* bitmaps */
 { "close", OBM_CLOSE },
 { "uparrow", OBM_UPARROW },
 { "dnarrow", OBM_DNARROW },
 { "checkboxes", OBM_CHECKBOXES },
 { "btncorners" , OBM_BTNCORNERS },
 {0}
 };
 static CONST resource_t cursor_table[] =
 {
 /* cursors */
 { "normal", OCR_NORMAL },
 { "ibeam", OCR_IBEAM },
 { "wait", OCR_WAIT },
 /* { "icour", OCR_ICOCUR }, */
 { "no", OCR_NO },
 { 0 }
 };
 static CONST resource_t icon_table[] =
 {
 /* icons */
 { "sample", OIC_SAMPLE },
 { "hand", OIC_HAND },
 { "ques", OIC_QUES },
 {0}
 };
 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
 			   : bitmap_table);
 if (INTP (name))
 {
 return XINT (name);
 }
 else if (!STRINGP (name))
 {
 signal_simple_error ("invalid resource identifier", name);
 }
 do {
 Extbyte* nm=0;
 GET_C_STRING_OS_DATA_ALLOCA (name, nm);
 if (!strcasecmp ((char*)res->name, nm))
 return res->resource_id;
 int iitype=0;
 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,
 						      Q_resource_type);
 Lisp_Object resource_id = find_keyword_in_vector (instantiator,
 						    Q_resource_id);
 xzero (iconinfo);
 if (!DEVICE_MSWINDOWS_P (XDEVICE (device)))
 if (dest_mask & IMAGE_POINTER_MASK && type == IMAGE_CURSOR)
 iitype = IMAGE_POINTER;
 else if (dest_mask & IMAGE_COLOR_PIXMAP_MASK)
 iitype = IMAGE_COLOR_PIXMAP;
 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 (f, fname);
 #else
 fname = f;
 #endif
 if (NILP (resource_id))
 	resid = (LPCTSTR)fname;
 else
 	{
 	  hinst = LoadLibraryEx (fname, NULL,
 				 LOAD_LIBRARY_AS_DATAFILE);
 	  resid = MAKEINTRESOURCE (resource_name_to_resource (resource_id,
 							   type));
 	  if (!resid)
 	    GET_C_STRING_OS_DATA_ALLOCA (resource_id, resid);
 	}
 }
 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))))
 {
 signal_simple_error ("Cannot load image", instantiator);
 }
 FreeLibrary (hinst);
 mswindows_initialize_dibitmap_image_instance (ii, 1, iitype);
 IMAGE_INSTANCE_PIXMAP_FILENAME (ii) = file;
 IMAGE_INSTANCE_PIXMAP_WIDTH (ii) =
 GetSystemMetrics (type == IMAGE_CURSOR ? SM_CXCURSOR : SM_CXICON);
 IMAGE_INSTANCE_PIXMAP_HEIGHT (ii) =
 GetSystemMetrics (type == IMAGE_CURSOR ? SM_CYCURSOR : SM_CYICON);
 IMAGE_INSTANCE_PIXMAP_DEPTH (ii) = 1;
 /* hey, we've got an icon type thing so we can reverse engineer the
 bitmap and mask */
 *     XmuReadBitmapData		read data from FILE descriptor
 *     XmuReadBitmapDataFromFile	read X10 or X11 format bitmap files
 *					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
 * without the other).
 */
 /*
 /* delimiters of significance are flagged w/ negative value */
 hexTable[' '] = -1;	hexTable[','] = -1;
 hexTable['}'] = -1;	hexTable['\n'] = -1;
 hexTable['\t'] = -1;
 initialized = TRUE;
 }
 /*
 *	read next hex value in the input stream, return -1 if EOF
 {
 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 */
 while (!done) {
 	ch = getc(fstream);
 		if (!strcmp("y_hot", type))
 		  hy = value;
 	    }
 	    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)
 	  version10p = 0;
 	else if (sscanf(line, "static char %s = {", name_and_type) == 1)
 	else
 	  type++;
 	if (strcmp("bits[]", type))
 	  continue;
 	if (!ww || !hh)
 	  RETURN (BitmapFileInvalid);
 	if ((ww % 16) && ((ww % 16) < 9) && version10p)
 	  padding = 1;
 	bytes_per_line = (ww+7)/8 + padding;
 	size = bytes_per_line * hh;
 	data = (unsigned char *) Xmalloc ((unsigned int) size);
 	if (!data)
 	  RETURN (BitmapNoMemory);
 	if (version10p) {
 	    unsigned char *ptr;
 	    int bytes;
 	} else {
 	    unsigned char *ptr;
 	    int bytes;
 	    for (bytes=0, ptr=data; bytes<size; bytes++, ptr++) {
 		if ((value = NextInt(fstream)) < 0)
 		  RETURN (BitmapFileInvalid);
 		*ptr=value;
 	    }
 	}
 	break;
 RETURN (BitmapSuccess);
 }
 int read_bitmap_data_from_file (CONST char *filename, unsigned int *width,
 				unsigned int *height, unsigned char **datap,
 				int *x_hot, int *y_hot)
 {
 FILE *fstream;
 int status;
 int new_width = BPLINE (2*((width + 15)/16));
 unsigned char *offset;
 void *bmp_buf = 0;
 unsigned char *new_data, *new_offset;
 int i, j;
 BITMAPINFO* bmp_info =
 xmalloc_and_zero (sizeof(BITMAPINFO) + sizeof(RGBQUAD));
 HBITMAP bitmap;
 if (!bmp_info)
 return NULL;
 new_data = (unsigned char *) xmalloc_and_zero (height * new_width);
 if (!new_data)
 {
 xfree (bmp_info);
 return NULL;
 }
 for (i=0; i<height; i++)
 {
 offset = data + i*old_width;
 new_offset = new_data + i*new_width;
 bmp_info->bmiHeader.biWidth=width;
 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.biCompression=BI_RGB;
 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);
 bmp_info->bmiColors[0].rgbReserved = 0;
 bmp_info->bmiColors[1].rgbRed = GetRValue (bg);
 bmp_info->bmiColors[1].rgbGreen = GetGValue (bg);
 bmp_info->bmiColors[1].rgbBlue = GetBValue (bg);
 bmp_info->bmiColors[1].rgbReserved = 0;
 bitmap = CreateDIBSection (hdc,
 			     bmp_info,
 			     DIB_RGB_COLORS,
 			     &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);
 return bitmap;
 incompatible_image_types (instantiator, dest_mask,
 			      IMAGE_MONO_PIXMAP_MASK | IMAGE_COLOR_PIXMAP_MASK
 			      | IMAGE_POINTER_MASK);
 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_PIXMAP_DEPTH (ii) = 1;
 XSETINT (IMAGE_INSTANCE_PIXMAP_HOTSPOT_X (ii), 0);
 XSETINT (IMAGE_INSTANCE_PIXMAP_HOTSPOT_Y (ii), 0);
 IMAGE_INSTANCE_MSWINDOWS_MASK (ii) = mask ? mask :
 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,
 				     FALSE, black, black);
 break;
 case IMAGE_COLOR_PIXMAP:
 {
 	  bg = COLOR_INSTANCE_MSWINDOWS_COLOR (XCOLOR_INSTANCE (background));
 	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,
 				       FALSE, fg, black);
 }
 break;
 case IMAGE_POINTER:
 	if (NILP (foreground))
 	  foreground = pointer_fg;
 	if (NILP (background))
 	  background = pointer_bg;
 	IMAGE_INSTANCE_PIXMAP_HOTSPOT_X (ii) =
 	  find_keyword_in_vector (instantiator, Q_hotspot_x);
 	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;
 	if (COLOR_INSTANCEP (foreground))
 	  fg = COLOR_INSTANCE_MSWINDOWS_COLOR (XCOLOR_INSTANCE (foreground));
 	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,
 				       TRUE, fg, black);
 	mswindows_initialize_image_instance_icon (ii, TRUE);
 }
 break;
 		   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);
 HBITMAP mask = 0;
 CONST char *gcc_may_you_rot_in_hell;
 }
 /* Instantiate method for XBM's. */
 static void
 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);
 switch (IMAGE_INSTANCE_TYPE (p))
 {
 case IMAGE_MONO_PIXMAP:
 case IMAGE_COLOR_PIXMAP:
 case IMAGE_POINTER:
 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",
 		   (unsigned long) IMAGE_INSTANCE_MSWINDOWS_MASK (p));
 	  write_c_string (buf, printcharfun);
 	}
 write_c_string (")", printcharfun);
 break;
 mswindows_finalize_image_instance (struct Lisp_Image_Instance *p)
 {
 if (DEVICE_LIVE_P (XDEVICE (p->device)))
 {
 if (IMAGE_INSTANCE_TYPE (p) == IMAGE_WIDGET
 	  ||
 	  IMAGE_INSTANCE_TYPE (p) == IMAGE_SUBWINDOW)
 	{
 #ifdef DEBUG_WIDGETS
 	  debug_widget_instances--;
 	  stderr_out ("widget destroyed, %d left\n", debug_widget_instances);
 static void
 mswindows_unmap_subwindow (struct Lisp_Image_Instance *p)
 {
 if (IMAGE_INSTANCE_SUBWINDOW_ID (p))
 {
 SetWindowPos (IMAGE_INSTANCE_MSWINDOWS_CLIPWINDOW (p),
 		    NULL,
 		    0, 0, 0, 0,
 		    SWP_HIDEWINDOW | SWP_NOMOVE | SWP_NOSIZE
 		    | SWP_NOSENDCHANGING);
 }
 }
 mswindows_map_subwindow (struct Lisp_Image_Instance *p, int x, int y,
 			 struct display_glyph_area* dga)
 {
 /* 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. */
 SetWindowPos (IMAGE_INSTANCE_MSWINDOWS_CLIPWINDOW (p),
 		NULL,
 		0, 0, 0, 0,
 		SWP_NOZORDER | SWP_NOSIZE | SWP_NOMOVE
 		| SWP_SHOWWINDOW | SWP_NOCOPYBITS
 		| SWP_NOSENDCHANGING);
 }
 /* resize the subwindow instance */
 static void
 mswindows_resize_subwindow (struct Lisp_Image_Instance* ii, int w, int h)
 {
 /* Set the size of the control .... */
 SetWindowPos (WIDGET_INSTANCE_MSWINDOWS_HANDLE (ii),
 		NULL,
 		0, 0, w, h,
 		SWP_NOZORDER | SWP_NOMOVE
 		| SWP_NOCOPYBITS | SWP_NOSENDCHANGING);
 }
 {
 /* buttons checked or otherwise */
 if ( EQ (IMAGE_INSTANCE_WIDGET_TYPE (p), Qbutton))
 	{
 	  if (gui_item_selected_p (IMAGE_INSTANCE_WIDGET_ITEM (p)))
 	    SendMessage (WIDGET_INSTANCE_MSWINDOWS_HANDLE (p),
 			 BM_SETCHECK, (WPARAM)BST_CHECKED, 0);
 	  else
 	    SendMessage (WIDGET_INSTANCE_MSWINDOWS_HANDLE (p),
 			 BM_SETCHECK, (WPARAM)BST_UNCHECKED, 0);
 	}
 /* set the widget font from the widget face */
 SendMessage (WIDGET_INSTANCE_MSWINDOWS_HANDLE (p),
 		   WM_SETFONT,
 		   (WPARAM)FONT_INSTANCE_MSWINDOWS_HFONT
 		   (XFONT_INSTANCE (widget_face_font_info
 				    (IMAGE_INSTANCE_SUBWINDOW_FRAME (p),
 				     IMAGE_INSTANCE_WIDGET_FACE (p),
 				     0, 0))),
 		   MAKELPARAM (TRUE, 0));
 }
 }
 /* register widgets into our hastable so that we can cope with the
 			/* 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;
 }
 switch (IMAGE_INSTANCE_TYPE (p1))
 {
 case IMAGE_MONO_PIXMAP:
 case IMAGE_COLOR_PIXMAP:
 case IMAGE_POINTER:
 if (IMAGE_INSTANCE_MSWINDOWS_BITMAP (p1)
 	  != IMAGE_INSTANCE_MSWINDOWS_BITMAP (p2))
 	return 0;
 break;
 default:
 break;
 }
 return 1;
 {
 case IMAGE_MONO_PIXMAP:
 case IMAGE_COLOR_PIXMAP:
 case IMAGE_POINTER:
 return (unsigned long) IMAGE_INSTANCE_MSWINDOWS_BITMAP (p);
 default:
 return 0;
 }
 }
 IMAGE_INSTANCE_PIXMAP_HOTSPOT_X (ii) = Qnil;
 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
 			/* parent window */
 			FRAME_MSWINDOWS_HANDLE (XFRAME (frame)),
 			(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 */
 SendMessage (wnd, WM_SETFONT,
 	       (WPARAM)FONT_INSTANCE_MSWINDOWS_HFONT
 	       (XFONT_INSTANCE (widget_face_font_info
 				(domain,
 				 IMAGE_INSTANCE_WIDGET_FACE (ii),
 				 0, 0))),
 	       MAKELPARAM (TRUE, 0));
 }
 /* Instantiate a button widget. Unfortunately instantiated widgets are
 particular to a frame since they need to have a parent. It's not
 {
 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;
 }
 else
 flags |= BS_DEFPUSHBUTTON;
 mswindows_widget_instantiate (image_instance, instantiator, pointer_fg,
 				pointer_bg, dest_mask, domain, "BUTTON", flags,
 				WS_EX_CONTROLPARENT);
 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))
 {
 SendMessage (wnd, BM_SETIMAGE,
 		   (WPARAM) (XIMAGE_INSTANCE_MSWINDOWS_BITMAP (glyph) ?
 			     IMAGE_BITMAP : IMAGE_ICON),
 		   (LPARAM) (XIMAGE_INSTANCE_MSWINDOWS_BITMAP (glyph) ?
 			     XIMAGE_INSTANCE_MSWINDOWS_BITMAP (glyph) :
 			     XIMAGE_INSTANCE_MSWINDOWS_ICON (glyph)));
 }
 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 | WS_EX_CONTROLPARENT);
 }
 				int dest_mask, Lisp_Object domain)
 {
 HWND wnd;
 struct Lisp_Image_Instance *ii = XIMAGE_INSTANCE (image_instance);
 mswindows_widget_instantiate (image_instance, instantiator, pointer_fg,
 				pointer_bg, dest_mask, domain, PROGRESS_CLASS,
 				WS_TABSTOP | WS_BORDER | PBS_SMOOTH,
 				WS_EX_CLIENTEDGE | WS_EX_CONTROLPARENT);
 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_SUBWINDOW_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_SUBWINDOW_FRAME (ii))))));
 #endif
 }
 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 (item, domain);
 tvitem.item.mask |= TVIF_PARAM;
 GET_C_STRING_OS_DATA_ALLOCA (XGUI_ITEM (item)->name,
 				   tvitem.item.pszText);
 }
 else
 GET_C_STRING_OS_DATA_ALLOCA (item, tvitem.item.pszText);
 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;
 }
 Lisp_Object rest;
 HWND wnd;
 HTREEITEM parent;
 struct 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 | WS_EX_CONTROLPARENT);
 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)))
 			     Lisp_Object domain, int index)
 {
 TC_ITEM tvitem, *ret;
 tvitem.mask = TCIF_TEXT;
 if (GUI_ITEMP (item))
 {
 tvitem.lParam = mswindows_register_gui_item (item, domain);
 tvitem.mask |= TCIF_PARAM;
 GET_C_STRING_OS_DATA_ALLOCA (XGUI_ITEM (item)->name,
 				   tvitem.pszText);
 }
 else
 {
 CHECK_STRING (item);
 GET_C_STRING_OS_DATA_ALLOCA (item, tvitem.pszText);
 }
 tvitem.cchTextMax = strlen (tvitem.pszText);
 if ((ret = (TC_ITEM*)SendMessage (wnd, TCM_INSERTITEM,
 				    index, (LPARAM)&tvitem)) < 0)
 signal_simple_error ("error adding tab entry", item);
 return ret;
 }
 Lisp_Object rest;
 HWND wnd;
 int index = 0;
 struct Lisp_Image_Instance *ii = XIMAGE_INSTANCE (image_instance);
 mswindows_widget_instantiate (image_instance, instantiator, pointer_fg,
 				pointer_bg, dest_mask, domain, WC_TABCONTROL,
 				/* borders don't suit tabs so well */
 				WS_TABSTOP,
 				WS_EX_CONTROLPARENT);
 wnd = WIDGET_INSTANCE_MSWINDOWS_HANDLE (ii);
 Lisp_Object rest;
 check_valid_item_list_1 (val);
 /* delete the pre-existing items */
 SendMessage (wnd, TCM_DELETEALLITEMS, 0, 0);
 IMAGE_INSTANCE_WIDGET_ITEMS (ii) =
 	Fcons (XCAR (IMAGE_INSTANCE_WIDGET_ITEMS (ii)),
 	       parse_gui_item_tree_children (val));
 /* add items to the tab */
 LIST_LOOP (rest, XCDR (IMAGE_INSTANCE_WIDGET_ITEMS (ii)))
 	{
 	  add_tab_item (image_instance, wnd, XCAR (rest),
 			IMAGE_INSTANCE_SUBWINDOW_FRAME (ii), index);
 	  index++;
 	}
 return Qt;
 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",
 				0,
 				WS_EX_CLIENTEDGE );
 }
 /* instantiate a combo control */
 thing. */
 widget_instantiate_1 (image_instance, instantiator, pointer_fg,
 			pointer_bg, dest_mask, domain, len + 1, 0, 0);
 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 | WS_EX_CONTROLPARENT);
 /* reset the height */
 widget_text_to_pixel_conversion (domain,
 				   IMAGE_INSTANCE_WIDGET_FACE (ii), 1, 0,
 				   &IMAGE_INSTANCE_SUBWINDOW_HEIGHT (ii), 0);
 wnd = WIDGET_INSTANCE_MSWINDOWS_HANDLE (ii);
 /* add items to the combo box */
 SendMessage (wnd, CB_RESETCONTENT, 0, 0);
 LIST_LOOP (rest, Fplist_get (IMAGE_INSTANCE_WIDGET_PROPS (ii), Q_items, Qnil))
 /* get the text from a control */
 if (EQ (prop, Q_text))
 {
 Extcount len = SendMessage (wnd, WM_GETTEXTLENGTH, 0, 0);
 Extbyte* buf =alloca (len+1);
 SendMessage (wnd, WM_GETTEXT, (WPARAM)len+1, (LPARAM) buf);
 return build_ext_string (buf, FORMAT_OS);
 }
 return Qunbound;
 }
 #ifdef HAVE_JPEG
 IIFORMAT_VALID_CONSOLE (mswindows, jpeg);
 #endif
 #ifdef HAVE_TIFF
 IIFORMAT_VALID_CONSOLE (mswindows, tiff);
 #endif
 #ifdef HAVE_PNG
 IIFORMAT_VALID_CONSOLE (mswindows, png);
 #endif
 #ifdef HAVE_GIF
 IIFORMAT_VALID_CONSOLE (mswindows, gif);
 #endif
 #ifdef HAVE_WIDGETS
 /* button widget */
 INITIALIZE_DEVICE_IIFORMAT (mswindows, button);
 IIFORMAT_HAS_DEVMETHOD (mswindows, button, property);
 IIFORMAT_HAS_DEVMETHOD (mswindows, button, instantiate);
 INITIALIZE_DEVICE_IIFORMAT (mswindows, edit_field);
 IIFORMAT_HAS_DEVMETHOD (mswindows, edit_field, instantiate);
 INITIALIZE_DEVICE_IIFORMAT (mswindows, subwindow);
 IIFORMAT_HAS_DEVMETHOD (mswindows, subwindow, instantiate);
 INITIALIZE_DEVICE_IIFORMAT (mswindows, widget);
 IIFORMAT_HAS_DEVMETHOD (mswindows, widget, property);
 IIFORMAT_HAS_METHOD (mswindows_resource, validate);
 IIFORMAT_HAS_METHOD (mswindows_resource, normalize);
 IIFORMAT_HAS_METHOD (mswindows_resource, possible_dest_types);
 IIFORMAT_HAS_METHOD (mswindows_resource, instantiate);
 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_CONSOLE (mswindows, mswindows_resource);
 }

Mercurial > hg > xemacs-beta

comparison src/glyphs-msw.c @ 434:9d177e8d4150 r21-2-25