Mercurial > hg > xemacs-beta

comparison src/glyphs-msw.c @ 286:57709be46d1b r21-0b41

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Import from CVS: tag r21-0b41
author cvs
date Mon, 13 Aug 2007 10:35:03 +0200
parents 558f606b08ae
children e11d67e05968
comparison
equal deleted inserted replaced
285:9a3756523c1b 286:57709be46d1b
24 glyphs-x.c */ 24 glyphs-x.c */
25 25
26 #include <config.h> 26 #include <config.h>
27 #include "lisp.h" 27 #include "lisp.h"
28 #include "lstream.h" 28 #include "lstream.h"
29
30 #define OEMRESOURCE /* Define OCR_ and friend constants */
29 #include "console-msw.h" 31 #include "console-msw.h"
30 #include "glyphs-msw.h" 32 #include "glyphs-msw.h"
31 #include "objects-msw.h" 33 #include "objects-msw.h"
32 34
33 #include "buffer.h" 35 #include "buffer.h"
45 DEFINE_IMAGE_INSTANTIATOR_FORMAT (bmp); 47 DEFINE_IMAGE_INSTANTIATOR_FORMAT (bmp);
46 Lisp_Object Qbmp; 48 Lisp_Object Qbmp;
47 Lisp_Object Vmswindows_bitmap_file_path; 49 Lisp_Object Vmswindows_bitmap_file_path;
48 static COLORREF transparent_color = RGB (1,1,1); 50 static COLORREF transparent_color = RGB (1,1,1);
49 51
50 DEFINE_IMAGE_INSTANTIATOR_FORMAT (cursor); 52 DEFINE_IMAGE_INSTANTIATOR_FORMAT (resource);
51 Lisp_Object Qcursor; 53 Lisp_Object Qresource;
52 Lisp_Object Q_resource_type, Q_resource_id; 54 Lisp_Object Q_resource_type, Q_resource_id;
53 55
54 static void 56 static void
55 mswindows_initialize_dibitmap_image_instance (struct Lisp_Image_Instance *ii, 57 mswindows_initialize_dibitmap_image_instance (struct Lisp_Image_Instance *ii,
56 enum image_instance_type type); 58 enum image_instance_type type);
158 return NULL; 160 return NULL;
159 } 161 }
160 162
161 /* build up an RGBQUAD colortable */ 163 /* build up an RGBQUAD colortable */
162 for (i = 0; i < qtable->num_active_colors; i++) { 164 for (i = 0; i < qtable->num_active_colors; i++) {
163 colortbl[i].rgbRed = qtable->rm[i]; 165 colortbl[i].rgbRed = (BYTE) qtable->rm[i];
164 colortbl[i].rgbGreen = qtable->gm[i]; 166 colortbl[i].rgbGreen = (BYTE) qtable->gm[i];
165 colortbl[i].rgbBlue = qtable->bm[i]; 167 colortbl[i].rgbBlue = (BYTE) qtable->bm[i];
166 colortbl[i].rgbReserved = 0; 168 colortbl[i].rgbReserved = 0;
167 } 169 }
168 170
169 /* now build up the data. picture has to be upside-down and 171 /* now build up the data. picture has to be upside-down and
170 back-to-front for msw bitmaps */ 172 back-to-front for msw bitmaps */
446 448
447 IMAGE_INSTANCE_MSWINDOWS_ICON (image)= 449 IMAGE_INSTANCE_MSWINDOWS_ICON (image)=
448 CreateIconIndirect (&x_icon); 450 CreateIconIndirect (&x_icon);
449 } 451 }
450 452
451 int 453 HBITMAP
452 mswindows_resize_dibitmap_instance (struct Lisp_Image_Instance* ii, 454 mswindows_create_resized_bitmap (struct Lisp_Image_Instance* ii,
453 struct frame* f, 455 struct frame* f,
454 int newx, int newy) 456 int newx, int newy)
455 { 457 {
456 HBITMAP newbmp, newmask=NULL; 458 HBITMAP newbmp;
459 HGDIOBJ old1, old2;
457 HDC hcdc = FRAME_MSWINDOWS_CDC (f); 460 HDC hcdc = FRAME_MSWINDOWS_CDC (f);
458 HDC hdcDst = CreateCompatibleDC (hcdc); 461 HDC hdcDst = CreateCompatibleDC (hcdc);
459 462
460 SelectObject (hcdc, IMAGE_INSTANCE_MSWINDOWS_BITMAP (ii)); 463 old1 = SelectObject (hcdc, IMAGE_INSTANCE_MSWINDOWS_BITMAP (ii));
461 464
462 newbmp = CreateCompatibleBitmap (hcdc, newx, newy); 465 newbmp = CreateCompatibleBitmap (hcdc, newx, newy);
463 466
464 DeleteObject (SelectObject (hdcDst, newbmp) ); 467 old2 = SelectObject (hdcDst, newbmp);
465 468
466 if (!StretchBlt (hdcDst, 0, 0, newx, newy, 469 if (!StretchBlt (hdcDst, 0, 0, newx, newy,
467 hcdc, 0, 0, 470 hcdc, 0, 0,
468 IMAGE_INSTANCE_PIXMAP_WIDTH (ii), 471 IMAGE_INSTANCE_PIXMAP_WIDTH (ii),
469 IMAGE_INSTANCE_PIXMAP_HEIGHT (ii), 472 IMAGE_INSTANCE_PIXMAP_HEIGHT (ii),
470 SRCCOPY)) 473 SRCCOPY))
471 { 474 {
472 return FALSE; 475 return 0;
473 } 476 }
474 477
478 SelectObject (hdcDst, old2);
479 SelectObject (hcdc, old1);
480 DeleteDC (hdcDst);
481
482 return newbmp;
483 }
484
485 HBITMAP
486 mswindows_create_resized_mask (struct Lisp_Image_Instance* ii,
487 struct frame* f,
488 int newx, int newy)
489 {
475 if (IMAGE_INSTANCE_MSWINDOWS_MASK (ii)) 490 if (IMAGE_INSTANCE_MSWINDOWS_MASK (ii))
476 { 491 {
477 SelectObject (hcdc, IMAGE_INSTANCE_MSWINDOWS_MASK (ii)); 492 HBITMAP newmask;
493 HGDIOBJ old1, old2;
494 HDC hcdc = FRAME_MSWINDOWS_CDC (f);
495 HDC hdcDst = CreateCompatibleDC (hcdc);
496
497 old1 = SelectObject (hcdc, IMAGE_INSTANCE_MSWINDOWS_MASK (ii));
478 newmask = CreateCompatibleBitmap(hcdc, newx, newy); 498 newmask = CreateCompatibleBitmap(hcdc, newx, newy);
479 SelectObject (hdcDst, newmask); 499 old2 = SelectObject (hdcDst, newmask);
480 500
481 if (!StretchBlt(hdcDst, 0, 0, newx, newy, 501 if (!StretchBlt(hdcDst, 0, 0, newx, newy,
482 hcdc, 0, 0, 502 hcdc, 0, 0,
483 IMAGE_INSTANCE_PIXMAP_WIDTH (ii), 503 IMAGE_INSTANCE_PIXMAP_WIDTH (ii),
484 IMAGE_INSTANCE_PIXMAP_HEIGHT (ii), 504 IMAGE_INSTANCE_PIXMAP_HEIGHT (ii),
485 SRCCOPY)) 505 SRCCOPY))
486 { 506 {
487 return FALSE; 507 return NULL;
488 } 508 }
489 } 509
490 510 SelectObject (hdcDst, old2);
491 SelectObject (hdcDst, 0); 511 SelectObject (hcdc, old1);
492 SelectObject (hcdc, 0); 512
513 DeleteDC (hdcDst);
514
515 return newmask;
516 }
517
518 return NULL;
519 }
520
521 int
522 mswindows_resize_dibitmap_instance (struct Lisp_Image_Instance* ii,
523 struct frame* f,
524 int newx, int newy)
525 {
526 HBITMAP newbmp = mswindows_create_resized_bitmap (ii, f, newx, newy);
527 HBITMAP newmask = mswindows_create_resized_mask (ii, f, newx, newy);
528
529 if (!newbmp)
530 return FALSE;
493 531
494 if (IMAGE_INSTANCE_MSWINDOWS_BITMAP (ii)) 532 if (IMAGE_INSTANCE_MSWINDOWS_BITMAP (ii))
495 DeleteObject (IMAGE_INSTANCE_MSWINDOWS_BITMAP (ii)); 533 DeleteObject (IMAGE_INSTANCE_MSWINDOWS_BITMAP (ii));
496 if (IMAGE_INSTANCE_MSWINDOWS_MASK (ii)) 534 if (IMAGE_INSTANCE_MSWINDOWS_MASK (ii))
497 DeleteObject (IMAGE_INSTANCE_MSWINDOWS_MASK (ii)); 535 DeleteObject (IMAGE_INSTANCE_MSWINDOWS_MASK (ii));
498 536
499 IMAGE_INSTANCE_MSWINDOWS_BITMAP (ii) = newbmp; 537 IMAGE_INSTANCE_MSWINDOWS_BITMAP (ii) = newbmp;
500 IMAGE_INSTANCE_MSWINDOWS_MASK (ii) = newmask; 538 IMAGE_INSTANCE_MSWINDOWS_MASK (ii) = newmask;
501 IMAGE_INSTANCE_PIXMAP_WIDTH (ii) = newx; 539 IMAGE_INSTANCE_PIXMAP_WIDTH (ii) = newx;
502 IMAGE_INSTANCE_PIXMAP_HEIGHT (ii) = newy; 540 IMAGE_INSTANCE_PIXMAP_HEIGHT (ii) = newy;
503
504 DeleteDC (hdcDst);
505 541
506 return TRUE; 542 return TRUE;
507 } 543 }
508 544
509 /********************************************************************** 545 /**********************************************************************
837 0, 0, 0); 873 0, 0, 0);
838 } 874 }
839 875
840 876
841 /********************************************************************** 877 /**********************************************************************
842 * CURSORS * 878 * RESOURCES *
843 **********************************************************************/ 879 **********************************************************************/
844 880
845 static void 881 static void
846 cursor_validate (Lisp_Object instantiator) 882 resource_validate (Lisp_Object instantiator)
847 { 883 {
848 if ((NILP (find_keyword_in_vector (instantiator, Q_file)) 884 if ((NILP (find_keyword_in_vector (instantiator, Q_file))
849 && 885 &&
850 NILP (find_keyword_in_vector (instantiator, Q_resource_id))) 886 NILP (find_keyword_in_vector (instantiator, Q_resource_id)))
851 || 887 ||
853 signal_simple_error ("Must supply :file, :resource-id and :resource-type", 889 signal_simple_error ("Must supply :file, :resource-id and :resource-type",
854 instantiator); 890 instantiator);
855 } 891 }
856 892
857 static Lisp_Object 893 static Lisp_Object
858 cursor_normalize (Lisp_Object inst, Lisp_Object console_type) 894 resource_normalize (Lisp_Object inst, Lisp_Object console_type)
859 { 895 {
860 /* This function can call lisp */ 896 /* This function can call lisp */
861 Lisp_Object file = Qnil; 897 Lisp_Object file = Qnil;
862 struct gcpro gcpro1, gcpro2; 898 struct gcpro gcpro1, gcpro2;
863 Lisp_Object alist = Qnil; 899 Lisp_Object alist = Qnil;
881 alist = remassq_no_quit (Q_file, alist); 917 alist = remassq_no_quit (Q_file, alist);
882 alist = Fcons (Fcons (Q_file, file), alist); 918 alist = Fcons (Fcons (Q_file, file), alist);
883 } 919 }
884 920
885 { 921 {
886 Lisp_Object result = alist_to_tagged_vector (Qcursor, alist); 922 Lisp_Object result = alist_to_tagged_vector (Qresource, alist);
887 free_alist (alist); 923 free_alist (alist);
888 RETURN_UNGCPRO (result); 924 RETURN_UNGCPRO (result);
889 } 925 }
890 } 926 }
891 927
892 static int 928 static int
893 cursor_possible_dest_types (void) 929 resource_possible_dest_types (void)
894 { 930 {
895 return IMAGE_POINTER_MASK | IMAGE_COLOR_PIXMAP_MASK; 931 return IMAGE_POINTER_MASK | IMAGE_COLOR_PIXMAP_MASK;
896 } 932 }
897 933
898 typedef struct 934 typedef struct
910 #define OIC_NOTE 32516 946 #define OIC_NOTE 32516
911 #define OIC_WINLOGO 32517 947 #define OIC_WINLOGO 32517
912 #define LR_SHARED 0x8000 948 #define LR_SHARED 0x8000
913 #endif 949 #endif
914 950
915 static CONST resource_t resource_table[] = 951 static CONST resource_t bitmap_table[] =
916 { 952 {
917 /* bitmaps */ 953 /* bitmaps */
918 { "close", OBM_CLOSE }, 954 { "close", OBM_CLOSE },
919 { "uparrow", OBM_UPARROW }, 955 { "uparrow", OBM_UPARROW },
920 { "dnarrow", OBM_DNARROW }, 956 { "dnarrow", OBM_DNARROW },
939 { "size", OBM_SIZE }, 975 { "size", OBM_SIZE },
940 { "btsize", OBM_BTSIZE }, 976 { "btsize", OBM_BTSIZE },
941 { "check", OBM_CHECK }, 977 { "check", OBM_CHECK },
942 { "cehckboxes", OBM_CHECKBOXES }, 978 { "cehckboxes", OBM_CHECKBOXES },
943 { "btncorners" , OBM_BTNCORNERS }, 979 { "btncorners" , OBM_BTNCORNERS },
980 {0}
981 };
982
983 static CONST resource_t cursor_table[] =
984 {
944 /* cursors */ 985 /* cursors */
945 { "normal", OCR_NORMAL }, 986 { "normal", OCR_NORMAL },
946 { "ibeam", OCR_IBEAM }, 987 { "ibeam", OCR_IBEAM },
947 { "wait", OCR_WAIT }, 988 { "wait", OCR_WAIT },
948 { "cross", OCR_CROSS }, 989 { "cross", OCR_CROSS },
953 { "sizewe", OCR_SIZEWE }, 994 { "sizewe", OCR_SIZEWE },
954 { "sizens", OCR_SIZENS }, 995 { "sizens", OCR_SIZENS },
955 { "sizeall", OCR_SIZEALL }, 996 { "sizeall", OCR_SIZEALL },
956 /* { "icour", OCR_ICOCUR }, */ 997 /* { "icour", OCR_ICOCUR }, */
957 { "no", OCR_NO }, 998 { "no", OCR_NO },
999 { 0 }
1000 };
1001
1002 static CONST resource_t icon_table[] =
1003 {
958 /* icons */ 1004 /* icons */
959 { "sample", OIC_SAMPLE }, 1005 { "sample", OIC_SAMPLE },
960 { "hand", OIC_HAND }, 1006 { "hand", OIC_HAND },
961 { "ques", OIC_QUES }, 1007 { "ques", OIC_QUES },
962 { "bang", OIC_BANG }, 1008 { "bang", OIC_BANG },
963 { "note", OIC_NOTE }, 1009 { "note", OIC_NOTE },
964 { "winlogo", OIC_WINLOGO }, 1010 { "winlogo", OIC_WINLOGO },
965 {0} 1011 {0}
966 }; 1012 };
967 1013
968 static int cursor_name_to_resource (Lisp_Object name) 1014 static int resource_name_to_resource (Lisp_Object name, int type)
969 { 1015 {
970 CONST resource_t* res = resource_table; 1016 CONST resource_t* res = (type == IMAGE_CURSOR ? cursor_table
1017 : type == IMAGE_ICON ? icon_table
1018 : bitmap_table);
971 1019
972 if (INTP (name)) 1020 if (INTP (name))
973 { 1021 {
974 return XINT (name); 1022 return XINT (name);
975 } 1023 }
983 return res->resource_id; 1031 return res->resource_id;
984 } while ((++res)->name); 1032 } while ((++res)->name);
985 return 0; 1033 return 0;
986 } 1034 }
987 1035
988 static void 1036 static int
989 cursor_instantiate (Lisp_Object image_instance, Lisp_Object instantiator, 1037 resource_symbol_to_type (Lisp_Object data)
1038 {
1039 if (EQ (data, Qcursor))
1040 return IMAGE_CURSOR;
1041 else if (EQ (data, Qicon))
1042 return IMAGE_ICON;
1043 else if (EQ (data, Qbitmap))
1044 return IMAGE_BITMAP;
1045 else
1046 return 0;
1047 }
1048
1049 static void
1050 resource_instantiate (Lisp_Object image_instance, Lisp_Object instantiator,
990 Lisp_Object pointer_fg, Lisp_Object pointer_bg, 1051 Lisp_Object pointer_fg, Lisp_Object pointer_bg,
991 int dest_mask, Lisp_Object domain) 1052 int dest_mask, Lisp_Object domain)
992 { 1053 {
993 struct Lisp_Image_Instance *ii = XIMAGE_INSTANCE (image_instance); 1054 struct Lisp_Image_Instance *ii = XIMAGE_INSTANCE (image_instance);
994 unsigned int type = 0; 1055 unsigned int type = 0;
995 HANDLE himage = NULL; 1056 HANDLE himage = NULL;
996 LPCTSTR resid=0; 1057 LPCTSTR resid=0;
1058 HINSTANCE hinst = NULL;
1059 ICONINFO iconinfo;
997 int iitype=0; 1060 int iitype=0;
1061 char* fname=0;
998 Lisp_Object device = IMAGE_INSTANCE_DEVICE (ii); 1062 Lisp_Object device = IMAGE_INSTANCE_DEVICE (ii);
999 1063
1000 Lisp_Object file = find_keyword_in_vector (instantiator, Q_file); 1064 Lisp_Object file = find_keyword_in_vector (instantiator, Q_file);
1001 Lisp_Object resource_type = find_keyword_in_vector (instantiator, 1065 Lisp_Object resource_type = find_keyword_in_vector (instantiator,
1002 Q_resource_type); 1066 Q_resource_type);
1003 Lisp_Object resource_id = find_keyword_in_vector (instantiator, 1067 Lisp_Object resource_id = find_keyword_in_vector (instantiator,
1004 Q_resource_id); 1068 Q_resource_id);
1005 1069
1070 xzero (iconinfo);
1071
1006 if (!DEVICE_MSWINDOWS_P (XDEVICE (device))) 1072 if (!DEVICE_MSWINDOWS_P (XDEVICE (device)))
1007 signal_simple_error ("Not an mswindows device", device); 1073 signal_simple_error ("Not an mswindows device", device);
1008 1074
1009 assert (!NILP (resource_type) && !NILP (resource_id)); 1075 type = resource_symbol_to_type (resource_type);
1010
1011 /* check the resource type */
1012 if (!SYMBOLP (resource_type))
1013 {
1014 signal_simple_error ("invalid resource type", resource_type);
1015 }
1016 if (!strcmp ((char *) string_data (XSYMBOL (resource_type)->name),
1017 "bitmap"))
1018 type = IMAGE_BITMAP;
1019 else if (!strcmp ((char *) string_data (XSYMBOL (resource_type)->name),
1020 "cursor"))
1021 type = IMAGE_CURSOR;
1022 else if (!strcmp ((char *) string_data (XSYMBOL (resource_type)->name),
1023 "icon"))
1024 type = IMAGE_ICON;
1025 else
1026 signal_simple_error ("invalid resource type", resource_type);
1027 1076
1028 if (dest_mask & IMAGE_POINTER_MASK && type == IMAGE_CURSOR) 1077 if (dest_mask & IMAGE_POINTER_MASK && type == IMAGE_CURSOR)
1029 iitype = IMAGE_POINTER; 1078 iitype = IMAGE_POINTER;
1030 else if (dest_mask & IMAGE_COLOR_PIXMAP_MASK) 1079 else if (dest_mask & IMAGE_COLOR_PIXMAP_MASK)
1031 iitype = IMAGE_COLOR_PIXMAP; 1080 iitype = IMAGE_COLOR_PIXMAP;
1032 else 1081 else
1033 incompatible_image_types (instantiator, dest_mask, 1082 incompatible_image_types (instantiator, dest_mask,
1034 IMAGE_COLOR_PIXMAP_MASK | IMAGE_POINTER_MASK); 1083 IMAGE_COLOR_PIXMAP_MASK | IMAGE_POINTER_MASK);
1035 1084
1085 /* mess with the keyword info we were provided with */
1036 if (!NILP (file)) 1086 if (!NILP (file))
1037 resid = (LPCTSTR)XSTRING_DATA (file); 1087 {
1038 else if (!(resid = MAKEINTRESOURCE(cursor_name_to_resource (resource_id)))) 1088 #ifdef __CYGWIN32__
1039 signal_simple_error ("invalid resource id", resource_id); 1089 CYGWIN_WIN32_PATH (XSTRING_DATA (file), fname);
1090 #else
1091 /* #### FIXME someone who knows ... */
1092 fname = XSTRING_DATA (file);
1093 #endif
1094
1095 if (NILP (resource_id))
1096 resid = (LPCTSTR)fname;
1097 else
1098 {
1099 hinst = LoadLibraryEx (fname, NULL,
1100 LOAD_LIBRARY_AS_DATAFILE);
1101 resid = MAKEINTRESOURCE (resource_name_to_resource (resource_id,
1102 type));
1103
1104 if (!resid)
1105 resid = XSTRING_DATA (resource_id);
1106 }
1107 }
1108 else if (!(resid = MAKEINTRESOURCE (resource_name_to_resource (resource_id,
1109 type))))
1110 signal_simple_error ("invalid resource identifier", resource_id);
1040 1111
1041 /* load the image */ 1112 /* load the image */
1042 if (!(himage = LoadImage (NULL, resid, type, 0, 0, 1113 if (!(himage = LoadImage (hinst, resid, type, 0, 0,
1043 LR_CREATEDIBSECTION | LR_DEFAULTSIZE | 1114 LR_CREATEDIBSECTION | LR_DEFAULTSIZE |
1044 LR_SHARED | 1115 LR_SHARED |
1045 (!NILP (file) ? LR_LOADFROMFILE : 0)))) 1116 (!NILP (file) ? LR_LOADFROMFILE : 0))))
1046 { 1117 {
1047 signal_simple_error ("cannot load image", instantiator); 1118 signal_simple_error ("cannot load image", instantiator);
1048 } 1119 }
1049 1120
1121 if (hinst)
1122 FreeLibrary (hinst);
1123
1050 mswindows_initialize_dibitmap_image_instance (ii, iitype); 1124 mswindows_initialize_dibitmap_image_instance (ii, iitype);
1051 1125
1052 IMAGE_INSTANCE_PIXMAP_FILENAME (ii) = file; 1126 IMAGE_INSTANCE_PIXMAP_FILENAME (ii) = file;
1053 IMAGE_INSTANCE_MSWINDOWS_BITMAP (ii) = (type==IMAGE_BITMAP ? himage : NULL);
1054 IMAGE_INSTANCE_MSWINDOWS_MASK (ii) = NULL;
1055 IMAGE_INSTANCE_MSWINDOWS_ICON (ii) = (type!=IMAGE_BITMAP ? himage : NULL);
1056 IMAGE_INSTANCE_PIXMAP_WIDTH (ii) = 1127 IMAGE_INSTANCE_PIXMAP_WIDTH (ii) =
1057 (type == IMAGE_CURSOR ? SM_CXCURSOR : SM_CXICON); 1128 GetSystemMetrics (type == IMAGE_CURSOR ? SM_CXCURSOR : SM_CXICON);
1058 IMAGE_INSTANCE_PIXMAP_HEIGHT (ii) = 1129 IMAGE_INSTANCE_PIXMAP_HEIGHT (ii) =
1059 (type == IMAGE_CURSOR ? SM_CYCURSOR : SM_CYICON); 1130 GetSystemMetrics (type == IMAGE_CURSOR ? SM_CYCURSOR : SM_CYICON);
1060 IMAGE_INSTANCE_PIXMAP_DEPTH (ii) = 0; 1131 IMAGE_INSTANCE_PIXMAP_DEPTH (ii) = 1;
1061 XSETINT (IMAGE_INSTANCE_PIXMAP_HOTSPOT_X (ii), 0); 1132
1062 XSETINT (IMAGE_INSTANCE_PIXMAP_HOTSPOT_Y (ii), 0); 1133 /* hey, we've got an icon type thing so we can reverse engineer the
1063 } 1134 bitmap and mask */
1064 1135 if (type != IMAGE_BITMAP)
1065 void 1136 {
1066 check_valid_symbol (Lisp_Object data) 1137 GetIconInfo (himage, &iconinfo);
1138 IMAGE_INSTANCE_MSWINDOWS_BITMAP (ii) = iconinfo.hbmColor;
1139 IMAGE_INSTANCE_MSWINDOWS_MASK (ii) = iconinfo.hbmMask;
1140 XSETINT (IMAGE_INSTANCE_PIXMAP_HOTSPOT_X (ii), iconinfo.xHotspot);
1141 XSETINT (IMAGE_INSTANCE_PIXMAP_HOTSPOT_Y (ii), iconinfo.yHotspot);
1142 IMAGE_INSTANCE_MSWINDOWS_ICON (ii) = himage;
1143 }
1144 else
1145 {
1146 IMAGE_INSTANCE_MSWINDOWS_ICON (ii) = NULL;
1147 IMAGE_INSTANCE_MSWINDOWS_BITMAP (ii) = himage;
1148 IMAGE_INSTANCE_MSWINDOWS_MASK (ii) = NULL;
1149 XSETINT (IMAGE_INSTANCE_PIXMAP_HOTSPOT_X (ii), 0);
1150 XSETINT (IMAGE_INSTANCE_PIXMAP_HOTSPOT_Y (ii), 0);
1151 }
1152 }
1153
1154 static void
1155 check_valid_resource_symbol (Lisp_Object data)
1067 { 1156 {
1068 CHECK_SYMBOL (data); 1157 CHECK_SYMBOL (data);
1158 if (!resource_symbol_to_type (data))
1159 signal_simple_error ("invalid resource type", data);
1160 }
1161
1162 static void
1163 check_valid_resource_id (Lisp_Object data)
1164 {
1165 if (!resource_name_to_resource (data, IMAGE_CURSOR)
1166 &&
1167 !resource_name_to_resource (data, IMAGE_ICON)
1168 &&
1169 !resource_name_to_resource (data, IMAGE_BITMAP))
1170 signal_simple_error ("invalid resource identifier", data);
1069 } 1171 }
1070 1172
1071 void 1173 void
1072 check_valid_string_or_int (Lisp_Object data) 1174 check_valid_string_or_int (Lisp_Object data)
1073 { 1175 {
1228 IIFORMAT_HAS_METHOD (bmp, instantiate); 1330 IIFORMAT_HAS_METHOD (bmp, instantiate);
1229 1331
1230 IIFORMAT_VALID_KEYWORD (bmp, Q_data, check_valid_string); 1332 IIFORMAT_VALID_KEYWORD (bmp, Q_data, check_valid_string);
1231 IIFORMAT_VALID_KEYWORD (bmp, Q_file, check_valid_string); 1333 IIFORMAT_VALID_KEYWORD (bmp, Q_file, check_valid_string);
1232 1334
1233 INITIALIZE_IMAGE_INSTANTIATOR_FORMAT (cursor, "cursor"); 1335 INITIALIZE_IMAGE_INSTANTIATOR_FORMAT (resource, "resource");
1234 1336
1235 IIFORMAT_HAS_METHOD (cursor, validate); 1337 IIFORMAT_HAS_METHOD (resource, validate);
1236 IIFORMAT_HAS_METHOD (cursor, normalize); 1338 IIFORMAT_HAS_METHOD (resource, normalize);
1237 IIFORMAT_HAS_METHOD (cursor, possible_dest_types); 1339 IIFORMAT_HAS_METHOD (resource, possible_dest_types);
1238 IIFORMAT_HAS_METHOD (cursor, instantiate); 1340 IIFORMAT_HAS_METHOD (resource, instantiate);
1239 1341
1240 IIFORMAT_VALID_KEYWORD (cursor, Q_resource_type, check_valid_symbol); 1342 IIFORMAT_VALID_KEYWORD (resource, Q_resource_type,
1241 IIFORMAT_VALID_KEYWORD (cursor, Q_resource_id, check_valid_string_or_int); 1343 check_valid_resource_symbol);
1242 IIFORMAT_VALID_KEYWORD (cursor, Q_file, check_valid_string); 1344 IIFORMAT_VALID_KEYWORD (resource, Q_resource_id, check_valid_resource_id);
1345 IIFORMAT_VALID_KEYWORD (resource, Q_file, check_valid_string);
1243 } 1346 }
1244 1347
1245 void 1348 void
1246 vars_of_glyphs_mswindows (void) 1349 vars_of_glyphs_mswindows (void)
1247 { 1350 {
1248 Fprovide (Qbmp); 1351 Fprovide (Qbmp);
1249 Fprovide (Qcursor); 1352 Fprovide (Qresource);
1250 DEFVAR_LISP ("mswindows-bitmap-file-path", &Vmswindows_bitmap_file_path /* 1353 DEFVAR_LISP ("mswindows-bitmap-file-path", &Vmswindows_bitmap_file_path /*
1251 A list of the directories in which mswindows bitmap files may be found. 1354 A list of the directories in which mswindows bitmap files may be found.
1252 This is used by the `make-image-instance' function. 1355 This is used by the `make-image-instance' function.
1253 */ ); 1356 */ );
1254 Vmswindows_bitmap_file_path = Qnil; 1357 Vmswindows_bitmap_file_path = Qnil;