Mercurial > hg > xemacs-beta

comparison src/glyphs-x.c @ 412:697ef44129c6 r21-2-14

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Import from CVS: tag r21-2-14
author cvs
date Mon, 13 Aug 2007 11:20:41 +0200
parents de805c49cfc1
children 41dbb7a9d5f2
comparison
equal deleted inserted replaced
411:12e008d41344 412:697ef44129c6
2 Copyright (C) 1993, 1994 Free Software Foundation, Inc. 2 Copyright (C) 1993, 1994 Free Software Foundation, Inc.
3 Copyright (C) 1995 Board of Trustees, University of Illinois. 3 Copyright (C) 1995 Board of Trustees, University of Illinois.
4 Copyright (C) 1995 Tinker Systems 4 Copyright (C) 1995 Tinker Systems
5 Copyright (C) 1995, 1996 Ben Wing 5 Copyright (C) 1995, 1996 Ben Wing
6 Copyright (C) 1995 Sun Microsystems 6 Copyright (C) 1995 Sun Microsystems
7 Copyright (C) 1999, 2000 Andy Piper
8 7
9 This file is part of XEmacs. 8 This file is part of XEmacs.
10 9
11 XEmacs is free software; you can redistribute it and/or modify it 10 XEmacs is free software; you can redistribute it and/or modify it
12 under the terms of the GNU General Public License as published by the 11 under the terms of the GNU General Public License as published by the
38 Pointer/icon overhaul, more restructuring by Ben Wing for 19.14 37 Pointer/icon overhaul, more restructuring by Ben Wing for 19.14
39 GIF support changed to external GIFlib 3.1 by Jareth Hein for 21.0 38 GIF support changed to external GIFlib 3.1 by Jareth Hein for 21.0
40 Many changes for color work and optimizations by Jareth Hein for 21.0 39 Many changes for color work and optimizations by Jareth Hein for 21.0
41 Switch of GIF/JPEG/PNG to new EImage intermediate code by Jareth Hein for 21.0 40 Switch of GIF/JPEG/PNG to new EImage intermediate code by Jareth Hein for 21.0
42 TIFF code by Jareth Hein for 21.0 41 TIFF code by Jareth Hein for 21.0
43 GIF/JPEG/PNG/TIFF code moved to new glyph-eimage.c by Andy Piper for 21.0 42 GIF/JPEG/PNG/TIFF code moved to new glyph-eimage.c for 21.0
44 Subwindow and Widget support by Andy Piper for 21.2
45 43
46 TODO: 44 TODO:
47 Support the GrayScale, StaticColor and StaticGray visual classes.
48 Convert images.el to C and stick it in here? 45 Convert images.el to C and stick it in here?
49 */ 46 */
50 47
51 #include <config.h> 48 #include <config.h>
52 #include "lisp.h" 49 #include "lisp.h"
53 #include "lstream.h" 50 #include "lstream.h"
54 #include "console-x.h" 51 #include "console-x.h"
55 #include "glyphs-x.h" 52 #include "glyphs-x.h"
56 #include "objects-x.h" 53 #include "objects-x.h"
57 #ifdef HAVE_WIDGETS
58 #include "gui-x.h"
59 #endif
60 #include "xmu.h" 54 #include "xmu.h"
61 55
62 #include "buffer.h" 56 #include "buffer.h"
63 #include "window.h" 57 #include "window.h"
64 #include "frame.h" 58 #include "frame.h"
65 #include "insdel.h" 59 #include "insdel.h"
66 #include "opaque.h" 60 #include "opaque.h"
67 #include "gui.h"
68 #include "faces.h"
69 61
70 #include "imgproc.h" 62 #include "imgproc.h"
71 63
72 #include "sysfile.h" 64 #include "sysfile.h"
73 65
74 #include <setjmp.h> 66 #include <setjmp.h>
75 67
76 #ifdef FILE_CODING 68 #ifdef FILE_CODING
77 #include "file-coding.h" 69 #include "file-coding.h"
78 #endif 70 #endif
79
80 #ifdef LWLIB_WIDGETS_MOTIF
81 #include <Xm/Xm.h>
82 #endif
83 #include <X11/IntrinsicP.h>
84 71
85 #if INTBITS == 32 72 #if INTBITS == 32
86 # define FOUR_BYTE_TYPE unsigned int 73 # define FOUR_BYTE_TYPE unsigned int
87 #elif LONGBITS == 32 74 #elif LONGBITS == 32
88 # define FOUR_BYTE_TYPE unsigned long 75 # define FOUR_BYTE_TYPE unsigned long
92 #error What kind of strange-ass system are we running on? 79 #error What kind of strange-ass system are we running on?
93 #endif 80 #endif
94 81
95 #define LISP_DEVICE_TO_X_SCREEN(dev) XDefaultScreenOfDisplay (DEVICE_X_DISPLAY (XDEVICE (dev))) 82 #define LISP_DEVICE_TO_X_SCREEN(dev) XDefaultScreenOfDisplay (DEVICE_X_DISPLAY (XDEVICE (dev)))
96 83
97 DECLARE_IMAGE_INSTANTIATOR_FORMAT (nothing);
98 DECLARE_IMAGE_INSTANTIATOR_FORMAT (string);
99 DECLARE_IMAGE_INSTANTIATOR_FORMAT (formatted_string);
100 DECLARE_IMAGE_INSTANTIATOR_FORMAT (inherit);
101 #ifdef HAVE_JPEG
102 DECLARE_IMAGE_INSTANTIATOR_FORMAT (jpeg);
103 #endif
104 #ifdef HAVE_TIFF
105 DECLARE_IMAGE_INSTANTIATOR_FORMAT (tiff);
106 #endif
107 #ifdef HAVE_PNG
108 DECLARE_IMAGE_INSTANTIATOR_FORMAT (png);
109 #endif
110 #ifdef HAVE_GIF
111 DECLARE_IMAGE_INSTANTIATOR_FORMAT (gif);
112 #endif
113 #ifdef HAVE_XPM 84 #ifdef HAVE_XPM
114 DEFINE_DEVICE_IIFORMAT (x, xpm); 85 DEFINE_DEVICE_IIFORMAT (x, xpm);
115 #endif 86 #endif
116 DEFINE_DEVICE_IIFORMAT (x, xbm); 87 DEFINE_DEVICE_IIFORMAT (x, xbm);
117 DEFINE_DEVICE_IIFORMAT (x, subwindow); 88 DEFINE_DEVICE_IIFORMAT (x, subwindow);
123 Lisp_Object Qcursor_font; 94 Lisp_Object Qcursor_font;
124 95
125 DEFINE_IMAGE_INSTANTIATOR_FORMAT (font); 96 DEFINE_IMAGE_INSTANTIATOR_FORMAT (font);
126 97
127 DEFINE_IMAGE_INSTANTIATOR_FORMAT (autodetect); 98 DEFINE_IMAGE_INSTANTIATOR_FORMAT (autodetect);
128
129 #ifdef HAVE_WIDGETS
130 DECLARE_IMAGE_INSTANTIATOR_FORMAT (layout);
131 DEFINE_DEVICE_IIFORMAT (x, widget);
132 DEFINE_DEVICE_IIFORMAT (x, native_layout);
133 DEFINE_DEVICE_IIFORMAT (x, button);
134 DEFINE_DEVICE_IIFORMAT (x, progress_gauge);
135 DEFINE_DEVICE_IIFORMAT (x, edit_field);
136 #if defined (LWLIB_WIDGETS_MOTIF) && XmVERSION > 1
137 DEFINE_DEVICE_IIFORMAT (x, combo_box);
138 #endif
139 DEFINE_DEVICE_IIFORMAT (x, tab_control);
140 DEFINE_DEVICE_IIFORMAT (x, label);
141 #endif
142 99
143 static void cursor_font_instantiate (Lisp_Object image_instance, 100 static void cursor_font_instantiate (Lisp_Object image_instance,
144 Lisp_Object instantiator, 101 Lisp_Object instantiator,
145 Lisp_Object pointer_fg, 102 Lisp_Object pointer_fg,
146 Lisp_Object pointer_bg, 103 Lisp_Object pointer_bg,
147 int dest_mask, 104 int dest_mask,
148 Lisp_Object domain); 105 Lisp_Object domain);
149
150 #ifdef HAVE_WIDGETS
151 static void
152 update_widget_face (widget_value* wv,
153 Lisp_Image_Instance* ii, Lisp_Object domain);
154 static void
155 update_tab_widget_face (widget_value* wv,
156 Lisp_Image_Instance* ii, Lisp_Object domain);
157 #endif
158 106
159 #include "bitmaps.h" 107 #include "bitmaps.h"
160 108
161 109
162 /************************************************************************/ 110 /************************************************************************/
188 dpy = DEVICE_X_DISPLAY (XDEVICE (device)); 136 dpy = DEVICE_X_DISPLAY (XDEVICE (device));
189 cmap = DEVICE_X_COLORMAP (XDEVICE(device)); 137 cmap = DEVICE_X_COLORMAP (XDEVICE(device));
190 vis = DEVICE_X_VISUAL (XDEVICE(device)); 138 vis = DEVICE_X_VISUAL (XDEVICE(device));
191 depth = DEVICE_X_DEPTH(XDEVICE(device)); 139 depth = DEVICE_X_DEPTH(XDEVICE(device));
192 140
193 if (vis->class == GrayScale || vis->class == StaticColor ||
194 vis->class == StaticGray)
195 {
196 /* #### Implement me!!! */
197 return NULL;
198 }
199
200 if (vis->class == PseudoColor) 141 if (vis->class == PseudoColor)
201 { 142 {
202 /* Quantize the image and get a histogram while we're at it. 143 /* Quantize the image and get a histogram while we're at it.
203 Do this first to save memory */ 144 Do this first to save memory */
204 qtable = build_EImage_quantable(pic, width, height, 256); 145 qtable = build_EImage_quantable(pic, width, height, 256);
232 /* use our quantize table to allocate the colors */ 173 /* use our quantize table to allocate the colors */
233 pixcount = 32; 174 pixcount = 32;
234 *pixtbl = xnew_array (unsigned long, pixcount); 175 *pixtbl = xnew_array (unsigned long, pixcount);
235 *npixels = 0; 176 *npixels = 0;
236 177
237 /* #### should implement a sort by popularity to assure proper allocation */ 178 /* ### should implement a sort by popularity to assure proper allocation */
238 n = *npixels; 179 n = *npixels;
239 for (i = 0; i < qtable->num_active_colors; i++) 180 for (i = 0; i < qtable->num_active_colors; i++)
240 { 181 {
241 XColor color; 182 XColor color;
242 int res; 183 int res;
263 { 204 {
264 rd = *ip++; 205 rd = *ip++;
265 gr = *ip++; 206 gr = *ip++;
266 bl = *ip++; 207 bl = *ip++;
267 conv.val = pixarray[QUANT_GET_COLOR(qtable,rd,gr,bl)]; 208 conv.val = pixarray[QUANT_GET_COLOR(qtable,rd,gr,bl)];
268 #ifdef WORDS_BIGENDIAN 209 #if WORDS_BIGENDIAN
269 if (outimg->byte_order == MSBFirst) 210 if (outimg->byte_order == MSBFirst)
270 for (q = 4-byte_cnt; q < 4; q++) *dp++ = conv.cp[q]; 211 for (q = 4-byte_cnt; q < 4; q++) *dp++ = conv.cp[q];
271 else 212 else
272 for (q = 3; q >= 4-byte_cnt; q--) *dp++ = conv.cp[q]; 213 for (q = 3; q >= 4-byte_cnt; q--) *dp++ = conv.cp[q];
273 #else 214 #else
338 bl = *ip++ << (bbits - 8); 279 bl = *ip++ << (bbits - 8);
339 else 280 else
340 bl = *ip++ >> (8 - bbits); 281 bl = *ip++ >> (8 - bbits);
341 282
342 conv.val = (rd << rshift) | (gr << gshift) | (bl << bshift); 283 conv.val = (rd << rshift) | (gr << gshift) | (bl << bshift);
343 #ifdef WORDS_BIGENDIAN 284 #if WORDS_BIGENDIAN
344 if (outimg->byte_order == MSBFirst) 285 if (outimg->byte_order == MSBFirst)
345 for (q = 4-byte_cnt; q < 4; q++) *dp++ = conv.cp[q]; 286 for (q = 4-byte_cnt; q < 4; q++) *dp++ = conv.cp[q];
346 else 287 else
347 for (q = 3; q >= 4-byte_cnt; q--) *dp++ = conv.cp[q]; 288 for (q = 3; q >= 4-byte_cnt; q--) *dp++ = conv.cp[q];
348 #else 289 #else
358 } 299 }
359 300
360 301
361 302
362 static void 303 static void
363 x_print_image_instance (Lisp_Image_Instance *p, 304 x_print_image_instance (struct Lisp_Image_Instance *p,
364 Lisp_Object printcharfun, 305 Lisp_Object printcharfun,
365 int escapeflag) 306 int escapeflag)
366 { 307 {
367 char buf[100]; 308 char buf[100];
368 309
383 default: 324 default:
384 break; 325 break;
385 } 326 }
386 } 327 }
387 328
388 #ifdef DEBUG_WIDGETS 329 static void
389 extern int debug_widget_instances; 330 x_finalize_image_instance (struct Lisp_Image_Instance *p)
390 #endif
391
392 static void
393 x_finalize_image_instance (Lisp_Image_Instance *p)
394 { 331 {
395 if (!p->data) 332 if (!p->data)
396 return; 333 return;
397 334
398 if (DEVICE_LIVE_P (XDEVICE (IMAGE_INSTANCE_DEVICE (p)))) 335 if (DEVICE_LIVE_P (XDEVICE (p->device)))
399 { 336 {
400 Display *dpy = DEVICE_X_DISPLAY 337 Display *dpy = DEVICE_X_DISPLAY (XDEVICE (p->device));
401 (XDEVICE (IMAGE_INSTANCE_DEVICE (p))); 338
402 if (0) 339 if (IMAGE_INSTANCE_TYPE (p) == IMAGE_WIDGET
403 ; 340 ||
404 #ifdef HAVE_WIDGETS 341 IMAGE_INSTANCE_TYPE (p) == IMAGE_SUBWINDOW)
405 else if (IMAGE_INSTANCE_TYPE (p) == IMAGE_WIDGET)
406 {
407 if (IMAGE_INSTANCE_SUBWINDOW_ID (p))
408 {
409 #ifdef DEBUG_WIDGETS
410 debug_widget_instances--;
411 stderr_out ("widget destroyed, %d left\n", debug_widget_instances);
412 #endif
413 lw_destroy_widget (IMAGE_INSTANCE_X_WIDGET_ID (p));
414 lw_destroy_widget (IMAGE_INSTANCE_X_CLIPWIDGET (p));
415
416 /* We can release the callbacks again. */
417 ungcpro_popup_callbacks (IMAGE_INSTANCE_X_WIDGET_LWID (p));
418
419 IMAGE_INSTANCE_X_WIDGET_ID (p) = 0;
420 IMAGE_INSTANCE_X_CLIPWIDGET (p) = 0;
421 }
422 }
423 #endif
424 else if (IMAGE_INSTANCE_TYPE (p) == IMAGE_SUBWINDOW)
425 { 342 {
426 if (IMAGE_INSTANCE_SUBWINDOW_ID (p)) 343 if (IMAGE_INSTANCE_SUBWINDOW_ID (p))
427 XDestroyWindow (dpy, IMAGE_INSTANCE_X_SUBWINDOW_ID (p)); 344 XDestroyWindow (dpy, IMAGE_INSTANCE_X_SUBWINDOW_ID (p));
428 IMAGE_INSTANCE_SUBWINDOW_ID (p) = 0; 345 IMAGE_INSTANCE_SUBWINDOW_ID (p) = 0;
429 } 346 }
430 else 347 else
431 { 348 {
432 int i; 349 if (IMAGE_INSTANCE_X_PIXMAP (p))
433 if (IMAGE_INSTANCE_PIXMAP_TIMEOUT (p)) 350 XFreePixmap (dpy, IMAGE_INSTANCE_X_PIXMAP (p));
434 disable_glyph_animated_timeout (IMAGE_INSTANCE_PIXMAP_TIMEOUT (p));
435
436 if (IMAGE_INSTANCE_X_MASK (p) && 351 if (IMAGE_INSTANCE_X_MASK (p) &&
437 IMAGE_INSTANCE_X_MASK (p) != IMAGE_INSTANCE_X_PIXMAP (p)) 352 IMAGE_INSTANCE_X_MASK (p) != IMAGE_INSTANCE_X_PIXMAP (p))
438 XFreePixmap (dpy, IMAGE_INSTANCE_X_MASK (p)); 353 XFreePixmap (dpy, IMAGE_INSTANCE_X_MASK (p));
439 IMAGE_INSTANCE_PIXMAP_MASK (p) = 0; 354 IMAGE_INSTANCE_X_PIXMAP (p) = 0;
440 355 IMAGE_INSTANCE_X_MASK (p) = 0;
441 if (IMAGE_INSTANCE_X_PIXMAP_SLICES (p)) 356
442 {
443 for (i = 0; i < IMAGE_INSTANCE_PIXMAP_MAXSLICE (p); i++)
444 if (IMAGE_INSTANCE_X_PIXMAP_SLICE (p,i))
445 {
446 XFreePixmap (dpy, IMAGE_INSTANCE_X_PIXMAP_SLICE (p,i));
447 IMAGE_INSTANCE_X_PIXMAP_SLICE (p, i) = 0;
448 }
449 xfree (IMAGE_INSTANCE_X_PIXMAP_SLICES (p));
450 IMAGE_INSTANCE_X_PIXMAP_SLICES (p) = 0;
451 }
452
453 if (IMAGE_INSTANCE_X_CURSOR (p)) 357 if (IMAGE_INSTANCE_X_CURSOR (p))
454 { 358 {
455 XFreeCursor (dpy, IMAGE_INSTANCE_X_CURSOR (p)); 359 XFreeCursor (dpy, IMAGE_INSTANCE_X_CURSOR (p));
456 IMAGE_INSTANCE_X_CURSOR (p) = 0; 360 IMAGE_INSTANCE_X_CURSOR (p) = 0;
457 } 361 }
458 362
459 if (IMAGE_INSTANCE_X_NPIXELS (p) != 0) 363 if (IMAGE_INSTANCE_X_NPIXELS (p) != 0)
460 { 364 {
461 XFreeColors (dpy, 365 XFreeColors (dpy,
462 IMAGE_INSTANCE_X_COLORMAP (p), 366 IMAGE_INSTANCE_X_COLORMAP (p),
463 IMAGE_INSTANCE_X_PIXELS (p), 367 IMAGE_INSTANCE_X_PIXELS (p),
464 IMAGE_INSTANCE_X_NPIXELS (p), 0); 368 IMAGE_INSTANCE_X_NPIXELS (p), 0);
465 IMAGE_INSTANCE_X_NPIXELS (p) = 0; 369 IMAGE_INSTANCE_X_NPIXELS (p) = 0;
466 } 370 }
467 } 371 }
468 } 372 }
469 /* You can sometimes have pixels without a live device. I forget 373 if (IMAGE_INSTANCE_X_PIXELS (p))
470 why, but that's why we free them here if we have a pixmap type
471 image instance. It probably means that we might also get a memory
472 leak with widgets. */
473 if (IMAGE_INSTANCE_TYPE (p) != IMAGE_WIDGET
474 && IMAGE_INSTANCE_TYPE (p) != IMAGE_SUBWINDOW
475 && IMAGE_INSTANCE_X_PIXELS (p))
476 { 374 {
477 xfree (IMAGE_INSTANCE_X_PIXELS (p)); 375 xfree (IMAGE_INSTANCE_X_PIXELS (p));
478 IMAGE_INSTANCE_X_PIXELS (p) = 0; 376 IMAGE_INSTANCE_X_PIXELS (p) = 0;
479 } 377 }
480 378
481 xfree (p->data); 379 xfree (p->data);
482 p->data = 0; 380 p->data = 0;
483 } 381 }
484 382
485 static int 383 static int
486 x_image_instance_equal (Lisp_Image_Instance *p1, 384 x_image_instance_equal (struct Lisp_Image_Instance *p1,
487 Lisp_Image_Instance *p2, int depth) 385 struct Lisp_Image_Instance *p2, int depth)
488 { 386 {
489 switch (IMAGE_INSTANCE_TYPE (p1)) 387 switch (IMAGE_INSTANCE_TYPE (p1))
490 { 388 {
491 case IMAGE_MONO_PIXMAP: 389 case IMAGE_MONO_PIXMAP:
492 case IMAGE_COLOR_PIXMAP: 390 case IMAGE_COLOR_PIXMAP:
501 399
502 return 1; 400 return 1;
503 } 401 }
504 402
505 static unsigned long 403 static unsigned long
506 x_image_instance_hash (Lisp_Image_Instance *p, int depth) 404 x_image_instance_hash (struct Lisp_Image_Instance *p, int depth)
507 { 405 {
508 switch (IMAGE_INSTANCE_TYPE (p)) 406 switch (IMAGE_INSTANCE_TYPE (p))
509 { 407 {
510 case IMAGE_MONO_PIXMAP: 408 case IMAGE_MONO_PIXMAP:
511 case IMAGE_COLOR_PIXMAP: 409 case IMAGE_COLOR_PIXMAP:
521 method. It is assumed that the device slot within the image 419 method. It is assumed that the device slot within the image
522 instance is already set -- this is the case when instantiate 420 instance is already set -- this is the case when instantiate
523 methods are called. */ 421 methods are called. */
524 422
525 static void 423 static void
526 x_initialize_pixmap_image_instance (Lisp_Image_Instance *ii, 424 x_initialize_pixmap_image_instance (struct Lisp_Image_Instance *ii,
527 int slices,
528 enum image_instance_type type) 425 enum image_instance_type type)
529 { 426 {
530 ii->data = xnew_and_zero (struct x_image_instance_data); 427 ii->data = xnew_and_zero (struct x_image_instance_data);
531 IMAGE_INSTANCE_PIXMAP_MAXSLICE (ii) = slices;
532 IMAGE_INSTANCE_X_PIXMAP_SLICES (ii) =
533 xnew_array_and_zero (Pixmap, slices);
534 IMAGE_INSTANCE_TYPE (ii) = type; 428 IMAGE_INSTANCE_TYPE (ii) = type;
535 IMAGE_INSTANCE_PIXMAP_FILENAME (ii) = Qnil; 429 IMAGE_INSTANCE_PIXMAP_FILENAME (ii) = Qnil;
536 IMAGE_INSTANCE_PIXMAP_MASK_FILENAME (ii) = Qnil; 430 IMAGE_INSTANCE_PIXMAP_MASK_FILENAME (ii) = Qnil;
537 IMAGE_INSTANCE_PIXMAP_HOTSPOT_X (ii) = Qnil; 431 IMAGE_INSTANCE_PIXMAP_HOTSPOT_X (ii) = Qnil;
538 IMAGE_INSTANCE_PIXMAP_HOTSPOT_Y (ii) = Qnil; 432 IMAGE_INSTANCE_PIXMAP_HOTSPOT_Y (ii) = Qnil;
572 (XSTRING_BYTE (name, 1) == '/' || 466 (XSTRING_BYTE (name, 1) == '/' ||
573 (XSTRING_BYTE (name, 1) == '.' && 467 (XSTRING_BYTE (name, 1) == '.' &&
574 (XSTRING_BYTE (name, 2) == '/'))))) 468 (XSTRING_BYTE (name, 2) == '/')))))
575 { 469 {
576 if (!NILP (Ffile_readable_p (name))) 470 if (!NILP (Ffile_readable_p (name)))
577 return Fexpand_file_name (name, Qnil); 471 return name;
578 else 472 else
579 return Qnil; 473 return Qnil;
580 } 474 }
581 475
582 if (NILP (Vdefault_x_device)) 476 if (NILP (Vdefault_x_device))
698 #endif 592 #endif
699 593
700 /* Get the data while doing the conversion */ 594 /* Get the data while doing the conversion */
701 while (1) 595 while (1)
702 { 596 {
703 ssize_t size_in_bytes = Lstream_read (istr, tempbuf, sizeof (tempbuf)); 597 int size_in_bytes = Lstream_read (istr, tempbuf, sizeof (tempbuf));
704 if (!size_in_bytes) 598 if (!size_in_bytes)
705 break; 599 break;
706 /* It does seem the flushes are necessary... */ 600 /* It does seem the flushes are necessary... */
707 #ifdef FILE_CODING 601 #ifdef FILE_CODING
708 Lstream_write (costr, tempbuf, size_in_bytes); 602 Lstream_write (costr, tempbuf, size_in_bytes);
841 735
842 #### This should be able to handle conversion into `pointer'. 736 #### This should be able to handle conversion into `pointer'.
843 Use the same code as for `xpm'. */ 737 Use the same code as for `xpm'. */
844 738
845 static void 739 static void
846 init_image_instance_from_x_image (Lisp_Image_Instance *ii, 740 init_image_instance_from_x_image (struct Lisp_Image_Instance *ii,
847 XImage *ximage, 741 XImage *ximage,
848 int dest_mask, 742 int dest_mask,
849 Colormap cmap, 743 Colormap cmap,
850 unsigned long *pixels, 744 unsigned long *pixels,
851 int npixels, 745 int npixels,
852 int slices,
853 Lisp_Object instantiator) 746 Lisp_Object instantiator)
854 { 747 {
855 Lisp_Object device = IMAGE_INSTANCE_DEVICE (ii); 748 Lisp_Object device = IMAGE_INSTANCE_DEVICE (ii);
856 Display *dpy; 749 Display *dpy;
857 GC gc; 750 GC gc;
883 XPutImage (dpy, pixmap, gc, ximage, 0, 0, 0, 0, 776 XPutImage (dpy, pixmap, gc, ximage, 0, 0, 0, 0,
884 ximage->width, ximage->height); 777 ximage->width, ximage->height);
885 778
886 XFreeGC (dpy, gc); 779 XFreeGC (dpy, gc);
887 780
888 x_initialize_pixmap_image_instance (ii, slices, IMAGE_COLOR_PIXMAP); 781 x_initialize_pixmap_image_instance (ii, IMAGE_COLOR_PIXMAP);
889 782
890 IMAGE_INSTANCE_PIXMAP_FILENAME (ii) = 783 IMAGE_INSTANCE_PIXMAP_FILENAME (ii) =
891 find_keyword_in_vector (instantiator, Q_file); 784 find_keyword_in_vector (instantiator, Q_file);
892 785
893 /* Fixup a set of pixmaps. */
894 IMAGE_INSTANCE_X_PIXMAP (ii) = pixmap; 786 IMAGE_INSTANCE_X_PIXMAP (ii) = pixmap;
895 787 IMAGE_INSTANCE_X_MASK (ii) = 0;
896 IMAGE_INSTANCE_PIXMAP_MASK (ii) = 0;
897 IMAGE_INSTANCE_PIXMAP_WIDTH (ii) = ximage->width; 788 IMAGE_INSTANCE_PIXMAP_WIDTH (ii) = ximage->width;
898 IMAGE_INSTANCE_PIXMAP_HEIGHT (ii) = ximage->height; 789 IMAGE_INSTANCE_PIXMAP_HEIGHT (ii) = ximage->height;
899 IMAGE_INSTANCE_PIXMAP_DEPTH (ii) = ximage->depth; 790 IMAGE_INSTANCE_PIXMAP_DEPTH (ii) = ximage->depth;
900 IMAGE_INSTANCE_X_COLORMAP (ii) = cmap; 791 IMAGE_INSTANCE_X_COLORMAP (ii) = cmap;
901 IMAGE_INSTANCE_X_PIXELS (ii) = pixels; 792 IMAGE_INSTANCE_X_PIXELS (ii) = pixels;
902 IMAGE_INSTANCE_X_NPIXELS (ii) = npixels; 793 IMAGE_INSTANCE_X_NPIXELS (ii) = npixels;
903 } 794 }
904 795
905 static void 796 static void
906 image_instance_add_x_image (Lisp_Image_Instance *ii, 797 x_init_image_instance_from_eimage (struct Lisp_Image_Instance *ii,
907 XImage *ximage,
908 int slice,
909 Lisp_Object instantiator)
910 {
911 Lisp_Object device = IMAGE_INSTANCE_DEVICE (ii);
912 Display *dpy;
913 GC gc;
914 Drawable d;
915 Pixmap pixmap;
916
917 dpy = DEVICE_X_DISPLAY (XDEVICE (device));
918 d = XtWindow(DEVICE_XT_APP_SHELL (XDEVICE (device)));
919
920 pixmap = XCreatePixmap (dpy, d, ximage->width,
921 ximage->height, ximage->depth);
922 if (!pixmap)
923 signal_simple_error ("Unable to create pixmap", instantiator);
924
925 gc = XCreateGC (dpy, pixmap, 0, NULL);
926 if (!gc)
927 {
928 XFreePixmap (dpy, pixmap);
929 signal_simple_error ("Unable to create GC", instantiator);
930 }
931
932 XPutImage (dpy, pixmap, gc, ximage, 0, 0, 0, 0,
933 ximage->width, ximage->height);
934
935 XFreeGC (dpy, gc);
936
937 IMAGE_INSTANCE_X_PIXMAP_SLICE (ii, slice) = pixmap;
938 }
939
940 static void
941 x_init_image_instance_from_eimage (Lisp_Image_Instance *ii,
942 int width, int height, 798 int width, int height,
943 int slices,
944 unsigned char *eimage, 799 unsigned char *eimage,
945 int dest_mask, 800 int dest_mask,
946 Lisp_Object instantiator, 801 Lisp_Object instantiator,
947 Lisp_Object domain) 802 Lisp_Object domain)
948 { 803 {
949 Lisp_Object device = IMAGE_INSTANCE_DEVICE (ii); 804 Lisp_Object device = IMAGE_INSTANCE_DEVICE (ii);
950 Colormap cmap = DEVICE_X_COLORMAP (XDEVICE(device)); 805 Colormap cmap = DEVICE_X_COLORMAP (XDEVICE(device));
951 unsigned long *pixtbl = NULL; 806 unsigned long *pixtbl = NULL;
952 int npixels = 0; 807 int npixels = 0;
953 int slice;
954 XImage* ximage; 808 XImage* ximage;
955 809
956 for (slice = 0; slice < slices; slice++) 810 ximage = convert_EImage_to_XImage (device, width, height, eimage,
957 { 811 &pixtbl, &npixels);
958 ximage = convert_EImage_to_XImage (device, width, height, 812 if (!ximage)
959 eimage + (width * height * 3 * slice), 813 {
960 &pixtbl, &npixels); 814 if (pixtbl) xfree (pixtbl);
961 if (!ximage) 815 signal_image_error("EImage to XImage conversion failed", instantiator);
962 { 816 }
963 if (pixtbl) xfree (pixtbl); 817
964 signal_image_error("EImage to XImage conversion failed", instantiator); 818 /* Now create the pixmap and set up the image instance */
965 } 819 init_image_instance_from_x_image (ii, ximage, dest_mask,
966 820 cmap, pixtbl, npixels,
967 /* Now create the pixmap and set up the image instance */ 821 instantiator);
968 if (slice == 0) 822
969 init_image_instance_from_x_image (ii, ximage, dest_mask, 823 if (ximage)
970 cmap, pixtbl, npixels, slices, 824 {
971 instantiator); 825 if (ximage->data)
972 else 826 {
973 image_instance_add_x_image (ii, ximage, slice, instantiator); 827 xfree (ximage->data);
974 828 ximage->data = 0;
975 if (ximage) 829 }
976 { 830 XDestroyImage (ximage);
977 if (ximage->data) 831 }
978 { 832 }
979 xfree (ximage->data); 833
980 ximage->data = 0; 834 int read_bitmap_data_from_file (CONST char *filename, unsigned int *width,
981 }
982 XDestroyImage (ximage);
983 ximage = 0;
984 }
985 }
986 }
987
988 int read_bitmap_data_from_file (const char *filename, unsigned int *width,
989 unsigned int *height, unsigned char **datap, 835 unsigned int *height, unsigned char **datap,
990 int *x_hot, int *y_hot) 836 int *x_hot, int *y_hot)
991 { 837 {
992 return XmuReadBitmapDataFromFile (filename, width, height, 838 return XmuReadBitmapDataFromFile (filename, width, height,
993 datap, x_hot, y_hot); 839 datap, x_hot, y_hot);
997 corresponding X object. */ 843 corresponding X object. */
998 844
999 static Pixmap 845 static Pixmap
1000 pixmap_from_xbm_inline (Lisp_Object device, int width, int height, 846 pixmap_from_xbm_inline (Lisp_Object device, int width, int height,
1001 /* Note that data is in ext-format! */ 847 /* Note that data is in ext-format! */
1002 const Extbyte *bits) 848 CONST Extbyte *bits)
1003 { 849 {
1004 return XCreatePixmapFromBitmapData (DEVICE_X_DISPLAY (XDEVICE(device)), 850 return XCreatePixmapFromBitmapData (DEVICE_X_DISPLAY (XDEVICE(device)),
1005 XtWindow (DEVICE_XT_APP_SHELL (XDEVICE (device))), 851 XtWindow (DEVICE_XT_APP_SHELL (XDEVICE (device))),
1006 (char *) bits, width, height, 852 (char *) bits, width, height,
1007 1, 0, 1); 853 1, 0, 1);
1009 855
1010 /* Given inline data for a mono pixmap, initialize the given 856 /* Given inline data for a mono pixmap, initialize the given
1011 image instance accordingly. */ 857 image instance accordingly. */
1012 858
1013 static void 859 static void
1014 init_image_instance_from_xbm_inline (Lisp_Image_Instance *ii, 860 init_image_instance_from_xbm_inline (struct Lisp_Image_Instance *ii,
1015 int width, int height, 861 int width, int height,
1016 /* Note that data is in ext-format! */ 862 /* Note that data is in ext-format! */
1017 const char *bits, 863 CONST char *bits,
1018 Lisp_Object instantiator, 864 Lisp_Object instantiator,
1019 Lisp_Object pointer_fg, 865 Lisp_Object pointer_fg,
1020 Lisp_Object pointer_bg, 866 Lisp_Object pointer_bg,
1021 int dest_mask, 867 int dest_mask,
1022 Pixmap mask, 868 Pixmap mask,
1054 else 900 else
1055 incompatible_image_types (instantiator, dest_mask, 901 incompatible_image_types (instantiator, dest_mask,
1056 IMAGE_MONO_PIXMAP_MASK | IMAGE_COLOR_PIXMAP_MASK 902 IMAGE_MONO_PIXMAP_MASK | IMAGE_COLOR_PIXMAP_MASK
1057 | IMAGE_POINTER_MASK); 903 | IMAGE_POINTER_MASK);
1058 904
1059 x_initialize_pixmap_image_instance (ii, 1, type); 905 x_initialize_pixmap_image_instance (ii, type);
1060 IMAGE_INSTANCE_PIXMAP_WIDTH (ii) = width; 906 IMAGE_INSTANCE_PIXMAP_WIDTH (ii) = width;
1061 IMAGE_INSTANCE_PIXMAP_HEIGHT (ii) = height; 907 IMAGE_INSTANCE_PIXMAP_HEIGHT (ii) = height;
1062 IMAGE_INSTANCE_PIXMAP_FILENAME (ii) = 908 IMAGE_INSTANCE_PIXMAP_FILENAME (ii) =
1063 find_keyword_in_vector (instantiator, Q_file); 909 find_keyword_in_vector (instantiator, Q_file);
1064 910
1150 static void 996 static void
1151 xbm_instantiate_1 (Lisp_Object image_instance, Lisp_Object instantiator, 997 xbm_instantiate_1 (Lisp_Object image_instance, Lisp_Object instantiator,
1152 Lisp_Object pointer_fg, Lisp_Object pointer_bg, 998 Lisp_Object pointer_fg, Lisp_Object pointer_bg,
1153 int dest_mask, int width, int height, 999 int dest_mask, int width, int height,
1154 /* Note that data is in ext-format! */ 1000 /* Note that data is in ext-format! */
1155 const char *bits) 1001 CONST char *bits)
1156 { 1002 {
1157 Lisp_Object mask_data = find_keyword_in_vector (instantiator, Q_mask_data); 1003 Lisp_Object mask_data = find_keyword_in_vector (instantiator, Q_mask_data);
1158 Lisp_Object mask_file = find_keyword_in_vector (instantiator, Q_mask_file); 1004 Lisp_Object mask_file = find_keyword_in_vector (instantiator, Q_mask_file);
1159 Lisp_Image_Instance *ii = XIMAGE_INSTANCE (image_instance); 1005 struct Lisp_Image_Instance *ii = XIMAGE_INSTANCE (image_instance);
1160 Pixmap mask = 0; 1006 Pixmap mask = 0;
1007 CONST char *gcc_may_you_rot_in_hell;
1161 1008
1162 if (!NILP (mask_data)) 1009 if (!NILP (mask_data))
1163 { 1010 {
1164 const char *ext_data; 1011 GET_C_STRING_BINARY_DATA_ALLOCA (XCAR (XCDR (XCDR (mask_data))),
1165 1012 gcc_may_you_rot_in_hell);
1166 TO_EXTERNAL_FORMAT (LISP_STRING, XCAR (XCDR (XCDR (mask_data))), 1013 mask =
1167 C_STRING_ALLOCA, ext_data, 1014 pixmap_from_xbm_inline (IMAGE_INSTANCE_DEVICE (ii),
1168 Qbinary); 1015 XINT (XCAR (mask_data)),
1169 mask = pixmap_from_xbm_inline (IMAGE_INSTANCE_DEVICE (ii), 1016 XINT (XCAR (XCDR (mask_data))),
1170 XINT (XCAR (mask_data)), 1017 (CONST unsigned char *)
1171 XINT (XCAR (XCDR (mask_data))), 1018 gcc_may_you_rot_in_hell);
1172 (const unsigned char *) ext_data);
1173 } 1019 }
1174 1020
1175 init_image_instance_from_xbm_inline (ii, width, height, bits, 1021 init_image_instance_from_xbm_inline (ii, width, height, bits,
1176 instantiator, pointer_fg, pointer_bg, 1022 instantiator, pointer_fg, pointer_bg,
1177 dest_mask, mask, mask_file); 1023 dest_mask, mask, mask_file);
1183 x_xbm_instantiate (Lisp_Object image_instance, Lisp_Object instantiator, 1029 x_xbm_instantiate (Lisp_Object image_instance, Lisp_Object instantiator,
1184 Lisp_Object pointer_fg, Lisp_Object pointer_bg, 1030 Lisp_Object pointer_fg, Lisp_Object pointer_bg,
1185 int dest_mask, Lisp_Object domain) 1031 int dest_mask, Lisp_Object domain)
1186 { 1032 {
1187 Lisp_Object data = find_keyword_in_vector (instantiator, Q_data); 1033 Lisp_Object data = find_keyword_in_vector (instantiator, Q_data);
1188 const char *ext_data; 1034 CONST char *gcc_go_home;
1189 1035
1190 assert (!NILP (data)); 1036 assert (!NILP (data));
1191 1037
1192 TO_EXTERNAL_FORMAT (LISP_STRING, XCAR (XCDR (XCDR (data))), 1038 GET_C_STRING_BINARY_DATA_ALLOCA (XCAR (XCDR (XCDR (data))),
1193 C_STRING_ALLOCA, ext_data, 1039 gcc_go_home);
1194 Qbinary);
1195 1040
1196 xbm_instantiate_1 (image_instance, instantiator, pointer_fg, 1041 xbm_instantiate_1 (image_instance, instantiator, pointer_fg,
1197 pointer_bg, dest_mask, XINT (XCAR (data)), 1042 pointer_bg, dest_mask, XINT (XCAR (data)),
1198 XINT (XCAR (XCDR (data))), ext_data); 1043 XINT (XCAR (XCDR (data))), gcc_go_home);
1199 } 1044 }
1200 1045
1201 1046
1202 #ifdef HAVE_XPM 1047 #ifdef HAVE_XPM
1203 1048
1297 XpmFreeAttributes (xpmattrs); 1142 XpmFreeAttributes (xpmattrs);
1298 } 1143 }
1299 1144
1300 static void 1145 static void
1301 x_xpm_instantiate (Lisp_Object image_instance, Lisp_Object instantiator, 1146 x_xpm_instantiate (Lisp_Object image_instance, Lisp_Object instantiator,
1302 Lisp_Object pointer_fg, Lisp_Object pointer_bg, 1147 Lisp_Object pointer_fg, Lisp_Object pointer_bg,
1303 int dest_mask, Lisp_Object domain) 1148 int dest_mask, Lisp_Object domain)
1304 { 1149 {
1305 /* This function can GC */ 1150 /* This function can GC */
1306 Lisp_Image_Instance *ii = XIMAGE_INSTANCE (image_instance); 1151 struct Lisp_Image_Instance *ii = XIMAGE_INSTANCE (image_instance);
1307 Lisp_Object device = IMAGE_INSTANCE_DEVICE (ii); 1152 Lisp_Object device = IMAGE_INSTANCE_DEVICE (ii);
1308 Lisp_Object data = find_keyword_in_vector (instantiator, Q_data); 1153 Lisp_Object data = find_keyword_in_vector (instantiator, Q_data);
1309 Display *dpy; 1154 Display *dpy;
1310 Screen *xs; 1155 Screen *xs;
1311 Colormap cmap; 1156 Colormap cmap;
1359 cmap = DEVICE_X_COLORMAP (XDEVICE(device)); 1204 cmap = DEVICE_X_COLORMAP (XDEVICE(device));
1360 depth = DEVICE_X_DEPTH (XDEVICE(device)); 1205 depth = DEVICE_X_DEPTH (XDEVICE(device));
1361 visual = DEVICE_X_VISUAL (XDEVICE(device)); 1206 visual = DEVICE_X_VISUAL (XDEVICE(device));
1362 #endif 1207 #endif
1363 1208
1364 x_initialize_pixmap_image_instance (ii, 1, type); 1209 x_initialize_pixmap_image_instance (ii, type);
1365 1210
1366 assert (!NILP (data)); 1211 assert (!NILP (data));
1367 1212
1368 retry: 1213 retry:
1369 1214
1469 } 1314 }
1470 else 1315 else
1471 pixels = NULL; 1316 pixels = NULL;
1472 1317
1473 IMAGE_INSTANCE_X_PIXMAP (ii) = pixmap; 1318 IMAGE_INSTANCE_X_PIXMAP (ii) = pixmap;
1474 IMAGE_INSTANCE_PIXMAP_MASK (ii) = (void*)mask; 1319 IMAGE_INSTANCE_X_MASK (ii) = mask;
1475 IMAGE_INSTANCE_X_COLORMAP (ii) = cmap; 1320 IMAGE_INSTANCE_X_COLORMAP (ii) = cmap;
1476 IMAGE_INSTANCE_X_PIXELS (ii) = pixels; 1321 IMAGE_INSTANCE_X_PIXELS (ii) = pixels;
1477 IMAGE_INSTANCE_X_NPIXELS (ii) = npixels; 1322 IMAGE_INSTANCE_X_NPIXELS (ii) = npixels;
1478 IMAGE_INSTANCE_PIXMAP_WIDTH (ii) = w; 1323 IMAGE_INSTANCE_PIXMAP_WIDTH (ii) = w;
1479 IMAGE_INSTANCE_PIXMAP_HEIGHT (ii) = h; 1324 IMAGE_INSTANCE_PIXMAP_HEIGHT (ii) = h;
1668 Lisp_Object pointer_fg, Lisp_Object pointer_bg, 1513 Lisp_Object pointer_fg, Lisp_Object pointer_bg,
1669 int dest_mask, Lisp_Object domain) 1514 int dest_mask, Lisp_Object domain)
1670 { 1515 {
1671 Lisp_Object data = find_keyword_in_vector (instantiator, Q_data); 1516 Lisp_Object data = find_keyword_in_vector (instantiator, Q_data);
1672 int i, stattis; 1517 int i, stattis;
1673 char *bits, *bp; 1518 char *p, *bits, *bp;
1674 const char *p; 1519 CONST char * volatile emsg = 0;
1675 const char * volatile emsg = 0; 1520 CONST char * volatile dstring;
1676 const char * volatile dstring;
1677 1521
1678 assert (!NILP (data)); 1522 assert (!NILP (data));
1679 1523
1680 TO_EXTERNAL_FORMAT (LISP_STRING, data, 1524 GET_C_STRING_BINARY_DATA_ALLOCA (data, dstring);
1681 C_STRING_ALLOCA, dstring,
1682 Qbinary);
1683 1525
1684 if ((p = strchr (dstring, ':'))) 1526 if ((p = strchr (dstring, ':')))
1685 { 1527 {
1686 dstring = p + 1; 1528 dstring = p + 1;
1687 } 1529 }
1741 data_must_be_present (instantiator); 1583 data_must_be_present (instantiator);
1742 } 1584 }
1743 1585
1744 static Lisp_Object 1586 static Lisp_Object
1745 autodetect_normalize (Lisp_Object instantiator, 1587 autodetect_normalize (Lisp_Object instantiator,
1746 Lisp_Object console_type) 1588 Lisp_Object console_type)
1747 { 1589 {
1748 Lisp_Object file = find_keyword_in_vector (instantiator, Q_data); 1590 Lisp_Object file = find_keyword_in_vector (instantiator, Q_data);
1749 Lisp_Object filename = Qnil; 1591 Lisp_Object filename = Qnil;
1750 Lisp_Object data = Qnil; 1592 Lisp_Object data = Qnil;
1751 struct gcpro gcpro1, gcpro2, gcpro3; 1593 struct gcpro gcpro1, gcpro2, gcpro3;
1832 IMAGE_TEXT_MASK; 1674 IMAGE_TEXT_MASK;
1833 } 1675 }
1834 1676
1835 static void 1677 static void
1836 autodetect_instantiate (Lisp_Object image_instance, 1678 autodetect_instantiate (Lisp_Object image_instance,
1837 Lisp_Object instantiator, 1679 Lisp_Object instantiator,
1838 Lisp_Object pointer_fg, 1680 Lisp_Object pointer_fg,
1839 Lisp_Object pointer_bg, 1681 Lisp_Object pointer_bg,
1840 int dest_mask, Lisp_Object domain) 1682 int dest_mask, Lisp_Object domain)
1841 { 1683 {
1842 Lisp_Object data = find_keyword_in_vector (instantiator, Q_data); 1684 Lisp_Object data = find_keyword_in_vector (instantiator, Q_data);
1843 struct gcpro gcpro1, gcpro2, gcpro3; 1685 struct gcpro gcpro1, gcpro2, gcpro3;
1844 Lisp_Object alist = Qnil; 1686 Lisp_Object alist = Qnil;
1845 Lisp_Object result = Qnil; 1687 Lisp_Object result = Qnil;
1848 GCPRO3 (data, alist, result); 1690 GCPRO3 (data, alist, result);
1849 1691
1850 alist = tagged_vector_to_alist (instantiator); 1692 alist = tagged_vector_to_alist (instantiator);
1851 if (dest_mask & IMAGE_POINTER_MASK) 1693 if (dest_mask & IMAGE_POINTER_MASK)
1852 { 1694 {
1853 const char *name_ext; 1695 CONST char *name_ext;
1854 TO_EXTERNAL_FORMAT (LISP_STRING, data, 1696 GET_C_STRING_FILENAME_DATA_ALLOCA (data, name_ext);
1855 C_STRING_ALLOCA, name_ext,
1856 Qfile_name);
1857 if (XmuCursorNameToIndex (name_ext) != -1) 1697 if (XmuCursorNameToIndex (name_ext) != -1)
1858 { 1698 {
1859 result = alist_to_tagged_vector (Qcursor_font, alist); 1699 result = alist_to_tagged_vector (Qcursor_font, alist);
1860 is_cursor_font = 1; 1700 is_cursor_font = 1;
1861 } 1701 }
1938 Lisp_Object pointer_fg, Lisp_Object pointer_bg, 1778 Lisp_Object pointer_fg, Lisp_Object pointer_bg,
1939 int dest_mask, Lisp_Object domain) 1779 int dest_mask, Lisp_Object domain)
1940 { 1780 {
1941 /* This function can GC */ 1781 /* This function can GC */
1942 Lisp_Object data = find_keyword_in_vector (instantiator, Q_data); 1782 Lisp_Object data = find_keyword_in_vector (instantiator, Q_data);
1943 Lisp_Image_Instance *ii = XIMAGE_INSTANCE (image_instance); 1783 struct Lisp_Image_Instance *ii = XIMAGE_INSTANCE (image_instance);
1944 Lisp_Object device = IMAGE_INSTANCE_DEVICE (ii); 1784 Lisp_Object device = IMAGE_INSTANCE_DEVICE (ii);
1945 Display *dpy; 1785 Display *dpy;
1946 XColor fg, bg; 1786 XColor fg, bg;
1947 Font source, mask; 1787 Font source, mask;
1948 char source_name[MAXPATHLEN], mask_name[MAXPATHLEN], dummy; 1788 char source_name[MAXPATHLEN], mask_name[MAXPATHLEN], dummy;
2002 if (!mask) 1842 if (!mask)
2003 mask_char = 0; 1843 mask_char = 0;
2004 1844
2005 /* #### call XQueryTextExtents() and check_pointer_sizes() here. */ 1845 /* #### call XQueryTextExtents() and check_pointer_sizes() here. */
2006 1846
2007 x_initialize_pixmap_image_instance (ii, 1, IMAGE_POINTER); 1847 x_initialize_pixmap_image_instance (ii, IMAGE_POINTER);
2008 IMAGE_INSTANCE_X_CURSOR (ii) = 1848 IMAGE_INSTANCE_X_CURSOR (ii) =
2009 XCreateGlyphCursor (dpy, source, mask, source_char, mask_char, 1849 XCreateGlyphCursor (dpy, source, mask, source_char, mask_char,
2010 &fg, &bg); 1850 &fg, &bg);
2011 XIMAGE_INSTANCE_PIXMAP_FG (image_instance) = foreground; 1851 XIMAGE_INSTANCE_PIXMAP_FG (image_instance) = foreground;
2012 XIMAGE_INSTANCE_PIXMAP_BG (image_instance) = background; 1852 XIMAGE_INSTANCE_PIXMAP_BG (image_instance) = background;
2036 Lisp_Object pointer_fg, Lisp_Object pointer_bg, 1876 Lisp_Object pointer_fg, Lisp_Object pointer_bg,
2037 int dest_mask, Lisp_Object domain) 1877 int dest_mask, Lisp_Object domain)
2038 { 1878 {
2039 /* This function can GC */ 1879 /* This function can GC */
2040 Lisp_Object data = find_keyword_in_vector (instantiator, Q_data); 1880 Lisp_Object data = find_keyword_in_vector (instantiator, Q_data);
2041 Lisp_Image_Instance *ii = XIMAGE_INSTANCE (image_instance); 1881 struct Lisp_Image_Instance *ii = XIMAGE_INSTANCE (image_instance);
2042 Lisp_Object device = IMAGE_INSTANCE_DEVICE (ii); 1882 Lisp_Object device = IMAGE_INSTANCE_DEVICE (ii);
2043 Display *dpy; 1883 Display *dpy;
2044 int i; 1884 int i;
2045 const char *name_ext; 1885 CONST char *name_ext;
2046 Lisp_Object foreground, background; 1886 Lisp_Object foreground, background;
2047 1887
2048 if (!DEVICE_X_P (XDEVICE (device))) 1888 if (!DEVICE_X_P (XDEVICE (device)))
2049 signal_simple_error ("Not an X device", device); 1889 signal_simple_error ("Not an X device", device);
2050 1890
2051 dpy = DEVICE_X_DISPLAY (XDEVICE (device)); 1891 dpy = DEVICE_X_DISPLAY (XDEVICE (device));
2052 1892
2053 if (!(dest_mask & IMAGE_POINTER_MASK)) 1893 if (!(dest_mask & IMAGE_POINTER_MASK))
2054 incompatible_image_types (instantiator, dest_mask, IMAGE_POINTER_MASK); 1894 incompatible_image_types (instantiator, dest_mask, IMAGE_POINTER_MASK);
2055 1895
2056 TO_EXTERNAL_FORMAT (LISP_STRING, data, 1896 GET_C_STRING_FILENAME_DATA_ALLOCA (data, name_ext);
2057 C_STRING_ALLOCA, name_ext,
2058 Qfile_name);
2059 if ((i = XmuCursorNameToIndex (name_ext)) == -1) 1897 if ((i = XmuCursorNameToIndex (name_ext)) == -1)
2060 signal_simple_error ("Unrecognized cursor-font name", data); 1898 signal_simple_error ("Unrecognized cursor-font name", data);
2061 1899
2062 x_initialize_pixmap_image_instance (ii, 1, IMAGE_POINTER); 1900 x_initialize_pixmap_image_instance (ii, IMAGE_POINTER);
2063 IMAGE_INSTANCE_X_CURSOR (ii) = XCreateFontCursor (dpy, i); 1901 IMAGE_INSTANCE_X_CURSOR (ii) = XCreateFontCursor (dpy, i);
2064 foreground = find_keyword_in_vector (instantiator, Q_foreground); 1902 foreground = find_keyword_in_vector (instantiator, Q_foreground);
2065 if (NILP (foreground)) 1903 if (NILP (foreground))
2066 foreground = pointer_fg; 1904 foreground = pointer_fg;
2067 background = find_keyword_in_vector (instantiator, Q_background); 1905 background = find_keyword_in_vector (instantiator, Q_background);
2072 1910
2073 static int 1911 static int
2074 x_colorize_image_instance (Lisp_Object image_instance, 1912 x_colorize_image_instance (Lisp_Object image_instance,
2075 Lisp_Object foreground, Lisp_Object background) 1913 Lisp_Object foreground, Lisp_Object background)
2076 { 1914 {
2077 Lisp_Image_Instance *p; 1915 struct Lisp_Image_Instance *p;
2078 1916
2079 p = XIMAGE_INSTANCE (image_instance); 1917 p = XIMAGE_INSTANCE (image_instance);
2080 1918
2081 switch (IMAGE_INSTANCE_TYPE (p)) 1919 switch (IMAGE_INSTANCE_TYPE (p))
2082 { 1920 {
2083 case IMAGE_MONO_PIXMAP: 1921 case IMAGE_MONO_PIXMAP:
2084 IMAGE_INSTANCE_TYPE (p) = IMAGE_COLOR_PIXMAP; 1922 IMAGE_INSTANCE_TYPE (p) = IMAGE_COLOR_PIXMAP;
2085 /* Make sure there aren't two pointers to the same mask, causing 1923 /* Make sure there aren't two pointers to the same mask, causing
2086 it to get freed twice. */ 1924 it to get freed twice. */
2087 IMAGE_INSTANCE_PIXMAP_MASK (p) = 0; 1925 IMAGE_INSTANCE_X_MASK (p) = 0;
2088 break; 1926 break;
2089 1927
2090 default: 1928 default:
2091 return 0; 1929 return 0;
2092 } 1930 }
2125 /************************************************************************/ 1963 /************************************************************************/
2126 1964
2127 /* unmap the image if it is a widget. This is used by redisplay via 1965 /* unmap the image if it is a widget. This is used by redisplay via
2128 redisplay_unmap_subwindows */ 1966 redisplay_unmap_subwindows */
2129 static void 1967 static void
2130 x_unmap_subwindow (Lisp_Image_Instance *p) 1968 x_unmap_subwindow (struct Lisp_Image_Instance *p)
2131 { 1969 {
2132 if (IMAGE_INSTANCE_TYPE (p) == IMAGE_SUBWINDOW) 1970 XUnmapWindow (DisplayOfScreen (IMAGE_INSTANCE_X_SUBWINDOW_SCREEN (p)),
2133 { 1971 IMAGE_INSTANCE_X_SUBWINDOW_ID (p));
2134 XUnmapWindow
2135 (IMAGE_INSTANCE_X_SUBWINDOW_DISPLAY (p),
2136 IMAGE_INSTANCE_X_CLIPWINDOW (p));
2137 }
2138 else /* must be a widget */
2139 {
2140 XtUnmapWidget (IMAGE_INSTANCE_X_CLIPWIDGET (p));
2141 }
2142 } 1972 }
2143 1973
2144 /* map the subwindow. This is used by redisplay via 1974 /* map the subwindow. This is used by redisplay via
2145 redisplay_output_subwindow */ 1975 redisplay_output_subwindow */
2146 static void 1976 static void
2147 x_map_subwindow (Lisp_Image_Instance *p, int x, int y, 1977 x_map_subwindow (struct Lisp_Image_Instance *p, int x, int y)
2148 struct display_glyph_area* dga) 1978 {
2149 { 1979 XMapWindow (DisplayOfScreen (IMAGE_INSTANCE_X_SUBWINDOW_SCREEN (p)),
2150 if (IMAGE_INSTANCE_TYPE (p) == IMAGE_SUBWINDOW) 1980 IMAGE_INSTANCE_X_SUBWINDOW_ID (p));
2151 { 1981 XMoveWindow (DisplayOfScreen (IMAGE_INSTANCE_X_SUBWINDOW_SCREEN (p)),
2152 Window subwindow = IMAGE_INSTANCE_X_SUBWINDOW_ID (p); 1982 IMAGE_INSTANCE_X_SUBWINDOW_ID (p), x, y);
2153 XMoveResizeWindow (IMAGE_INSTANCE_X_SUBWINDOW_DISPLAY (p),
2154 IMAGE_INSTANCE_X_CLIPWINDOW (p),
2155 x, y, dga->width, dga->height);
2156 XMoveWindow (IMAGE_INSTANCE_X_SUBWINDOW_DISPLAY (p),
2157 subwindow, -dga->xoffset, -dga->yoffset);
2158 XMapWindow (IMAGE_INSTANCE_X_SUBWINDOW_DISPLAY (p),
2159 IMAGE_INSTANCE_X_CLIPWINDOW (p));
2160 }
2161 else /* must be a widget */
2162 {
2163 XtConfigureWidget (IMAGE_INSTANCE_X_CLIPWIDGET (p),
2164 x + IMAGE_INSTANCE_X_WIDGET_XOFFSET (p),
2165 y + IMAGE_INSTANCE_X_WIDGET_YOFFSET (p),
2166 dga->width, dga->height, 0);
2167 XtMoveWidget (IMAGE_INSTANCE_X_WIDGET_ID (p),
2168 -dga->xoffset, -dga->yoffset);
2169 XtMapWidget (IMAGE_INSTANCE_X_CLIPWIDGET (p));
2170 }
2171 }
2172
2173 /* when you click on a widget you may activate another widget this
2174 needs to be checked and all appropriate widgets updated */
2175 static void
2176 x_update_subwindow (Lisp_Image_Instance *p)
2177 {
2178 /* Update the subwindow size if necessary. */
2179 if (IMAGE_INSTANCE_SIZE_CHANGED (p))
2180 {
2181 XResizeWindow (IMAGE_INSTANCE_X_SUBWINDOW_DISPLAY (p),
2182 IMAGE_INSTANCE_X_SUBWINDOW_ID (p),
2183 IMAGE_INSTANCE_WIDTH (p),
2184 IMAGE_INSTANCE_HEIGHT (p));
2185 }
2186 }
2187
2188 /* Update all attributes that have changed. Lwlib actually does most
2189 of this for us. */
2190 static void
2191 x_update_widget (Lisp_Image_Instance *p)
2192 {
2193 /* This function can GC if IN_REDISPLAY is false. */
2194 #ifdef HAVE_WIDGETS
2195 widget_value* wv = 0;
2196
2197 /* First get the items if they have changed since this is a
2198 structural change. As such it will nuke all added values so we
2199 need to update most other things after the items have changed.*/
2200 if (IMAGE_INSTANCE_WIDGET_ITEMS_CHANGED (p))
2201 {
2202 Lisp_Object image_instance;
2203
2204 XSETIMAGE_INSTANCE (image_instance, p);
2205 wv = gui_items_to_widget_values
2206 (image_instance, IMAGE_INSTANCE_WIDGET_PENDING_ITEMS (p));
2207 wv->change = STRUCTURAL_CHANGE;
2208 /* now modify the widget */
2209 lw_modify_all_widgets (IMAGE_INSTANCE_X_WIDGET_LWID (p),
2210 wv, True);
2211 free_widget_value_tree (wv);
2212 }
2213
2214 /* Now do non structural updates. */
2215 wv = lw_get_all_values (IMAGE_INSTANCE_X_WIDGET_LWID (p));
2216
2217 if (!wv)
2218 return;
2219
2220 /* Possibly update the colors and font */
2221 if (IMAGE_INSTANCE_WIDGET_FACE_CHANGED (p)
2222 ||
2223 XFRAME (IMAGE_INSTANCE_FRAME (p))->faces_changed
2224 ||
2225 IMAGE_INSTANCE_WIDGET_ITEMS_CHANGED (p))
2226 {
2227 update_widget_face (wv, p, IMAGE_INSTANCE_FRAME (p));
2228 }
2229
2230 /* Possibly update the text. */
2231 if (IMAGE_INSTANCE_TEXT_CHANGED (p))
2232 {
2233 char* str;
2234 Lisp_Object val = IMAGE_INSTANCE_WIDGET_TEXT (p);
2235 TO_EXTERNAL_FORMAT (LISP_STRING, val,
2236 C_STRING_ALLOCA, str,
2237 Qnative);
2238 wv->value = str;
2239 }
2240
2241 /* Possibly update the size. */
2242 if (IMAGE_INSTANCE_SIZE_CHANGED (p)
2243 ||
2244 IMAGE_INSTANCE_WIDGET_ITEMS_CHANGED (p)
2245 ||
2246 IMAGE_INSTANCE_TEXT_CHANGED (p))
2247 {
2248 assert (IMAGE_INSTANCE_X_WIDGET_ID (p) &&
2249 IMAGE_INSTANCE_X_CLIPWIDGET (p)) ;
2250
2251 if (IMAGE_INSTANCE_X_WIDGET_ID (p)->core.being_destroyed
2252 || !XtIsManaged(IMAGE_INSTANCE_X_WIDGET_ID (p)))
2253 {
2254 Lisp_Object sw;
2255 XSETIMAGE_INSTANCE (sw, p);
2256 signal_simple_error ("XEmacs bug: subwindow is deleted", sw);
2257 }
2258
2259 lw_add_widget_value_arg (wv, XtNwidth,
2260 (Dimension)IMAGE_INSTANCE_WIDTH (p));
2261 lw_add_widget_value_arg (wv, XtNheight,
2262 (Dimension)IMAGE_INSTANCE_HEIGHT (p));
2263 }
2264
2265 /* now modify the widget */
2266 lw_modify_all_widgets (IMAGE_INSTANCE_X_WIDGET_LWID (p),
2267 wv, False);
2268 #endif
2269 } 1983 }
2270 1984
2271 /* instantiate and x type subwindow */ 1985 /* instantiate and x type subwindow */
2272 static void 1986 static void
2273 x_subwindow_instantiate (Lisp_Object image_instance, Lisp_Object instantiator, 1987 x_subwindow_instantiate (Lisp_Object image_instance, Lisp_Object instantiator,
2274 Lisp_Object pointer_fg, Lisp_Object pointer_bg, 1988 Lisp_Object pointer_fg, Lisp_Object pointer_bg,
2275 int dest_mask, Lisp_Object domain) 1989 int dest_mask, Lisp_Object domain)
2276 { 1990 {
2277 /* This function can GC */ 1991 /* This function can GC */
2278 Lisp_Image_Instance *ii = XIMAGE_INSTANCE (image_instance); 1992 struct Lisp_Image_Instance *ii = XIMAGE_INSTANCE (image_instance);
2279 Lisp_Object device = IMAGE_INSTANCE_DEVICE (ii); 1993 Lisp_Object device = IMAGE_INSTANCE_DEVICE (ii);
2280 Lisp_Object frame = DOMAIN_FRAME (domain); 1994 Lisp_Object frame = FW_FRAME (domain);
2281 struct frame* f = XFRAME (frame); 1995 struct frame* f = XFRAME (frame);
2282 Display *dpy; 1996 Display *dpy;
2283 Screen *xs; 1997 Screen *xs;
2284 Window pw, win; 1998 Window pw, win;
2285 XSetWindowAttributes xswa; 1999 XSetWindowAttributes xswa;
2286 Mask valueMask = 0; 2000 Mask valueMask = 0;
2287 unsigned int w = IMAGE_INSTANCE_WIDTH (ii), 2001 unsigned int w = IMAGE_INSTANCE_SUBWINDOW_WIDTH (ii),
2288 h = IMAGE_INSTANCE_HEIGHT (ii); 2002 h = IMAGE_INSTANCE_SUBWINDOW_HEIGHT (ii);
2289 2003
2290 if (!DEVICE_X_P (XDEVICE (device))) 2004 if (!DEVICE_X_P (XDEVICE (device)))
2291 signal_simple_error ("Not an X device", device); 2005 signal_simple_error ("Not an X device", device);
2292 2006
2293 dpy = DEVICE_X_DISPLAY (XDEVICE (device)); 2007 dpy = DEVICE_X_DISPLAY (XDEVICE (device));
2294 xs = DefaultScreenOfDisplay (dpy); 2008 xs = DefaultScreenOfDisplay (dpy);
2295 2009
2296 IMAGE_INSTANCE_TYPE (ii) = IMAGE_SUBWINDOW; 2010 if (dest_mask & IMAGE_SUBWINDOW_MASK)
2011 IMAGE_INSTANCE_TYPE (ii) = IMAGE_SUBWINDOW;
2012 else
2013 incompatible_image_types (instantiator, dest_mask,
2014 IMAGE_SUBWINDOW_MASK);
2297 2015
2298 pw = XtWindow (FRAME_X_TEXT_WIDGET (f)); 2016 pw = XtWindow (FRAME_X_TEXT_WIDGET (f));
2299 2017
2300 ii->data = xnew_and_zero (struct x_subwindow_data); 2018 ii->data = xnew_and_zero (struct x_subwindow_data);
2301 2019
2302 IMAGE_INSTANCE_X_SUBWINDOW_PARENT (ii) = pw; 2020 IMAGE_INSTANCE_X_SUBWINDOW_PARENT (ii) = pw;
2303 IMAGE_INSTANCE_X_SUBWINDOW_DISPLAY (ii) = DisplayOfScreen (xs); 2021 IMAGE_INSTANCE_X_SUBWINDOW_SCREEN (ii) = xs;
2304 2022
2305 xswa.backing_store = Always; 2023 xswa.backing_store = Always;
2306 valueMask |= CWBackingStore; 2024 valueMask |= CWBackingStore;
2307 xswa.colormap = DefaultColormapOfScreen (xs); 2025 xswa.colormap = DefaultColormapOfScreen (xs);
2308 valueMask |= CWColormap; 2026 valueMask |= CWColormap;
2309 2027
2310 /* Create a window for clipping */ 2028 win = XCreateWindow (dpy, pw, 0, 0, w, h, 0, CopyFromParent,
2311 IMAGE_INSTANCE_X_CLIPWINDOW (ii) =
2312 XCreateWindow (dpy, pw, 0, 0, w, h, 0, CopyFromParent,
2313 InputOutput, CopyFromParent, valueMask,
2314 &xswa);
2315
2316 /* Now put the subwindow inside the clip window. */
2317 win = XCreateWindow (dpy, IMAGE_INSTANCE_X_CLIPWINDOW (ii),
2318 0, 0, w, h, 0, CopyFromParent,
2319 InputOutput, CopyFromParent, valueMask, 2029 InputOutput, CopyFromParent, valueMask,
2320 &xswa); 2030 &xswa);
2321 2031
2322 IMAGE_INSTANCE_SUBWINDOW_ID (ii) = (void*)win; 2032 IMAGE_INSTANCE_SUBWINDOW_ID (ii) = (void*)win;
2323 } 2033 }
2324 2034
2325 #if 0 2035 #if 0
2326 /* #### Should this function exist? If there's any doubt I'm not implementing it --andyp */ 2036 /* #### Should this function exist? If there's any doubt I'm not implementing it --andyp */
2329 Subwindows are not currently implemented. 2039 Subwindows are not currently implemented.
2330 */ 2040 */
2331 (subwindow, property, data)) 2041 (subwindow, property, data))
2332 { 2042 {
2333 Atom property_atom; 2043 Atom property_atom;
2334 Lisp_Subwindow *sw; 2044 struct Lisp_Subwindow *sw;
2335 Display *dpy; 2045 Display *dpy;
2336 2046
2337 CHECK_SUBWINDOW (subwindow); 2047 CHECK_SUBWINDOW (subwindow);
2338 CHECK_STRING (property); 2048 CHECK_STRING (property);
2339 CHECK_STRING (data); 2049 CHECK_STRING (data);
2350 2060
2351 return property; 2061 return property;
2352 } 2062 }
2353 #endif 2063 #endif
2354 2064
2355 2065 static void
2356 #ifdef HAVE_WIDGETS 2066 x_resize_subwindow (struct Lisp_Image_Instance* ii, int w, int h)
2357 2067 {
2358 /************************************************************************/ 2068 XResizeWindow (DisplayOfScreen (IMAGE_INSTANCE_X_SUBWINDOW_SCREEN (ii)),
2359 /* widgets */ 2069 IMAGE_INSTANCE_X_SUBWINDOW_ID (ii),
2360 /************************************************************************/ 2070 w, h);
2361 2071 }
2362 static void
2363 update_widget_face (widget_value* wv, Lisp_Image_Instance *ii,
2364 Lisp_Object domain)
2365 {
2366 #ifdef LWLIB_WIDGETS_MOTIF
2367 XmFontList fontList;
2368 #endif
2369 /* Update the foreground. */
2370 Lisp_Object pixel = FACE_FOREGROUND
2371 (IMAGE_INSTANCE_WIDGET_FACE (ii),
2372 domain);
2373 XColor fcolor = COLOR_INSTANCE_X_COLOR (XCOLOR_INSTANCE (pixel)), bcolor;
2374 lw_add_widget_value_arg (wv, XtNforeground, fcolor.pixel);
2375
2376 /* Update the background. */
2377 pixel = FACE_BACKGROUND (IMAGE_INSTANCE_WIDGET_FACE (ii),
2378 domain);
2379 bcolor = COLOR_INSTANCE_X_COLOR (XCOLOR_INSTANCE (pixel));
2380 lw_add_widget_value_arg (wv, XtNbackground, bcolor.pixel);
2381
2382 #ifdef LWLIB_WIDGETS_MOTIF
2383 fontList = XmFontListCreate
2384 (FONT_INSTANCE_X_FONT
2385 (XFONT_INSTANCE (query_string_font
2386 (IMAGE_INSTANCE_WIDGET_TEXT (ii),
2387 IMAGE_INSTANCE_WIDGET_FACE (ii),
2388 domain))), XmSTRING_DEFAULT_CHARSET);
2389 lw_add_widget_value_arg (wv, XmNfontList, (XtArgVal)fontList);
2390 #endif
2391 lw_add_widget_value_arg
2392 (wv, XtNfont, (XtArgVal)FONT_INSTANCE_X_FONT
2393 (XFONT_INSTANCE (query_string_font
2394 (IMAGE_INSTANCE_WIDGET_TEXT (ii),
2395 IMAGE_INSTANCE_WIDGET_FACE (ii),
2396 domain))));
2397 }
2398
2399 static void
2400 update_tab_widget_face (widget_value* wv, Lisp_Image_Instance *ii,
2401 Lisp_Object domain)
2402 {
2403 if (wv->contents)
2404 {
2405 widget_value* val = wv->contents, *cur;
2406
2407 /* Give each child label the correct foreground color. */
2408 Lisp_Object pixel = FACE_FOREGROUND
2409 (IMAGE_INSTANCE_WIDGET_FACE (ii),
2410 domain);
2411 XColor fcolor = COLOR_INSTANCE_X_COLOR (XCOLOR_INSTANCE (pixel));
2412 lw_add_widget_value_arg (val, XtNtabForeground, fcolor.pixel);
2413
2414 for (cur = val->next; cur; cur = cur->next)
2415 {
2416 if (cur->value)
2417 {
2418 lw_copy_widget_value_args (val, cur);
2419 }
2420 }
2421 }
2422 }
2423
2424 static void
2425 x_widget_instantiate (Lisp_Object image_instance, Lisp_Object instantiator,
2426 Lisp_Object pointer_fg, Lisp_Object pointer_bg,
2427 int dest_mask, Lisp_Object domain,
2428 const char* type, widget_value* wv)
2429 {
2430 Lisp_Image_Instance *ii = XIMAGE_INSTANCE (image_instance);
2431 Lisp_Object device = IMAGE_INSTANCE_DEVICE (ii), pixel;
2432 struct device* d = XDEVICE (device);
2433 Lisp_Object frame = DOMAIN_FRAME (domain);
2434 struct frame* f = XFRAME (frame);
2435 char* nm=0;
2436 Widget wid;
2437 Arg al [32];
2438 int ac = 0;
2439 int id = new_lwlib_id ();
2440 widget_value* clip_wv;
2441 XColor fcolor, bcolor;
2442
2443 if (!DEVICE_X_P (d))
2444 signal_simple_error ("Not an X device", device);
2445
2446 /* have to set the type this late in case there is no device
2447 instantiation for a widget. But we can go ahead and do it without
2448 checking because there is always a generic instantiator. */
2449 IMAGE_INSTANCE_TYPE (ii) = IMAGE_WIDGET;
2450
2451 if (!NILP (IMAGE_INSTANCE_WIDGET_TEXT (ii)))
2452 TO_EXTERNAL_FORMAT (LISP_STRING, IMAGE_INSTANCE_WIDGET_TEXT (ii),
2453 C_STRING_ALLOCA, nm,
2454 Qnative);
2455
2456 ii->data = xnew_and_zero (struct x_subwindow_data);
2457
2458 /* Create a clip window to contain the subwidget. Incredibly the
2459 XEmacs manager seems to be the most appropriate widget for
2460 this. Nothing else is simple enough and yet does what is
2461 required. */
2462 clip_wv = xmalloc_widget_value ();
2463
2464 lw_add_widget_value_arg (clip_wv, XtNresize, False);
2465 lw_add_widget_value_arg (clip_wv, XtNwidth,
2466 (Dimension)IMAGE_INSTANCE_WIDTH (ii));
2467 lw_add_widget_value_arg (clip_wv, XtNheight,
2468 (Dimension)IMAGE_INSTANCE_HEIGHT (ii));
2469 clip_wv->enabled = True;
2470
2471 clip_wv->name = xstrdup ("clip-window");
2472 clip_wv->value = xstrdup ("clip-window");
2473
2474 IMAGE_INSTANCE_X_CLIPWIDGET (ii)
2475 = lw_create_widget ("clip-window", "clip-window", new_lwlib_id (),
2476 clip_wv, FRAME_X_CONTAINER_WIDGET (f),
2477 False, 0, 0, 0);
2478
2479 free_widget_value_tree (clip_wv);
2480
2481 /* copy any args we were given */
2482 ac = 0;
2483 lw_add_value_args_to_args (wv, al, &ac);
2484
2485 /* Fixup the colors. We have to do this *before* the widget gets
2486 created so that Motif will fix up the shadow colors
2487 correctly. Once the widget is created Motif won't do this
2488 anymore...*/
2489 pixel = FACE_FOREGROUND
2490 (IMAGE_INSTANCE_WIDGET_FACE (ii),
2491 IMAGE_INSTANCE_FRAME (ii));
2492 fcolor = COLOR_INSTANCE_X_COLOR (XCOLOR_INSTANCE (pixel));
2493
2494 pixel = FACE_BACKGROUND
2495 (IMAGE_INSTANCE_WIDGET_FACE (ii),
2496 IMAGE_INSTANCE_FRAME (ii));
2497 bcolor = COLOR_INSTANCE_X_COLOR (XCOLOR_INSTANCE (pixel));
2498
2499 lw_add_widget_value_arg (wv, XtNbackground, bcolor.pixel);
2500 lw_add_widget_value_arg (wv, XtNforeground, fcolor.pixel);
2501 /* we cannot allow widgets to resize themselves */
2502 lw_add_widget_value_arg (wv, XtNresize, False);
2503 lw_add_widget_value_arg (wv, XtNwidth,
2504 (Dimension)IMAGE_INSTANCE_WIDTH (ii));
2505 lw_add_widget_value_arg (wv, XtNheight,
2506 (Dimension)IMAGE_INSTANCE_HEIGHT (ii));
2507 /* update the font. */
2508 update_widget_face (wv, ii, domain);
2509
2510 wid = lw_create_widget (type, wv->name, id, wv, IMAGE_INSTANCE_X_CLIPWIDGET (ii),
2511 False, 0, popup_selection_callback, 0);
2512
2513 IMAGE_INSTANCE_SUBWINDOW_ID (ii) = (void*)wid;
2514 IMAGE_INSTANCE_X_WIDGET_LWID (ii) = id;
2515 /* because the EmacsManager is the widgets parent we have to
2516 offset the redisplay of the widget by the amount the text
2517 widget is inside the manager. */
2518 ac = 0;
2519 XtSetArg (al [ac], XtNx, &IMAGE_INSTANCE_X_WIDGET_XOFFSET (ii)); ac++;
2520 XtSetArg (al [ac], XtNy, &IMAGE_INSTANCE_X_WIDGET_YOFFSET (ii)); ac++;
2521 XtGetValues (FRAME_X_TEXT_WIDGET (f), al, ac);
2522
2523 XtSetMappedWhenManaged (wid, TRUE);
2524
2525 free_widget_value_tree (wv);
2526 /* A kludgy but simple way to make sure the callback for a widget
2527 doesn't get deleted. */
2528 gcpro_popup_callbacks (id);
2529 }
2530
2531 /* get properties of a control */
2532 static Lisp_Object
2533 x_widget_property (Lisp_Object image_instance, Lisp_Object prop)
2534 {
2535 Lisp_Image_Instance *ii = XIMAGE_INSTANCE (image_instance);
2536 /* get the text from a control */
2537 if (EQ (prop, Q_text))
2538 {
2539 widget_value* wv = lw_get_all_values (IMAGE_INSTANCE_X_WIDGET_LWID (ii));
2540 return build_ext_string (wv->value, Qnative);
2541 }
2542 return Qunbound;
2543 }
2544
2545 /* Instantiate a layout control for putting other widgets in. */
2546 static void
2547 x_native_layout_instantiate (Lisp_Object image_instance, Lisp_Object instantiator,
2548 Lisp_Object pointer_fg, Lisp_Object pointer_bg,
2549 int dest_mask, Lisp_Object domain)
2550 {
2551 x_widget_instantiate (image_instance, instantiator, pointer_fg,
2552 pointer_bg, dest_mask, domain, "layout", 0);
2553 }
2554
2555 /* Instantiate a button widget. Unfortunately instantiated widgets are
2556 particular to a frame since they need to have a parent. It's not
2557 like images where you just select the image into the context you
2558 want to display it in and BitBlt it. So images instances can have a
2559 many-to-one relationship with things you see, whereas widgets can
2560 only be one-to-one (i.e. per frame) */
2561 static void
2562 x_button_instantiate (Lisp_Object image_instance, Lisp_Object instantiator,
2563 Lisp_Object pointer_fg, Lisp_Object pointer_bg,
2564 int dest_mask, Lisp_Object domain)
2565 {
2566 Lisp_Image_Instance *ii = XIMAGE_INSTANCE (image_instance);
2567 Lisp_Object gui = IMAGE_INSTANCE_WIDGET_ITEM (ii);
2568 Lisp_Object glyph = find_keyword_in_vector (instantiator, Q_image);
2569 widget_value* wv = gui_items_to_widget_values (image_instance, gui);
2570
2571 if (!NILP (glyph))
2572 {
2573 if (!IMAGE_INSTANCEP (glyph))
2574 glyph = glyph_image_instance (glyph, domain, ERROR_ME, 1);
2575 }
2576
2577 x_widget_instantiate (image_instance, instantiator, pointer_fg,
2578 pointer_bg, dest_mask, domain, "button", wv);
2579
2580 /* add the image if one was given */
2581 if (!NILP (glyph) && IMAGE_INSTANCEP (glyph)
2582 && IMAGE_INSTANCE_PIXMAP_TYPE_P (XIMAGE_INSTANCE (glyph)))
2583 {
2584 Arg al [2];
2585 int ac =0;
2586 #ifdef LWLIB_WIDGETS_MOTIF
2587 XtSetArg (al [ac], XmNlabelType, XmPIXMAP); ac++;
2588 XtSetArg (al [ac], XmNlabelPixmap, XIMAGE_INSTANCE_X_PIXMAP (glyph));ac++;
2589 #else
2590 XtSetArg (al [ac], XtNpixmap, XIMAGE_INSTANCE_X_PIXMAP (glyph)); ac++;
2591 #endif
2592 XtSetValues (IMAGE_INSTANCE_X_WIDGET_ID (ii), al, ac);
2593 }
2594 }
2595
2596 /* Update a button's clicked state.
2597
2598 #### This is overkill, but it works. Right now this causes all
2599 button instances to flash for some reason buried deep in lwlib. In
2600 theory this should be the Right Thing to do since lwlib should only
2601 merge in changed values - and if nothing has changed then nothing
2602 should get done. This may be because of the args stuff,
2603 i.e. although the arg contents may be the same the args look
2604 different and so are re-applied to the widget. */
2605 static void
2606 x_button_update (Lisp_Object image_instance)
2607 {
2608 /* This function can GC if IN_REDISPLAY is false. */
2609 Lisp_Image_Instance *p = XIMAGE_INSTANCE (image_instance);
2610 widget_value* wv =
2611 gui_items_to_widget_values (image_instance,
2612 IMAGE_INSTANCE_WIDGET_ITEMS (p));
2613
2614 /* now modify the widget */
2615 lw_modify_all_widgets (IMAGE_INSTANCE_X_WIDGET_LWID (p),
2616 wv, True);
2617 free_widget_value_tree (wv);
2618 }
2619
2620 /* get properties of a button */
2621 static Lisp_Object
2622 x_button_property (Lisp_Object image_instance, Lisp_Object prop)
2623 {
2624 Lisp_Image_Instance *ii = XIMAGE_INSTANCE (image_instance);
2625 /* check the state of a button */
2626 if (EQ (prop, Q_selected))
2627 {
2628 widget_value* wv = lw_get_all_values (IMAGE_INSTANCE_X_WIDGET_LWID (ii));
2629
2630 if (wv->selected)
2631 return Qt;
2632 else
2633 return Qnil;
2634 }
2635 return Qunbound;
2636 }
2637
2638 /* instantiate a progress gauge */
2639 static void
2640 x_progress_gauge_instantiate (Lisp_Object image_instance, Lisp_Object instantiator,
2641 Lisp_Object pointer_fg, Lisp_Object pointer_bg,
2642 int dest_mask, Lisp_Object domain)
2643 {
2644 Lisp_Image_Instance *ii = XIMAGE_INSTANCE (image_instance);
2645 Lisp_Object gui = IMAGE_INSTANCE_WIDGET_ITEM (ii);
2646 widget_value* wv = gui_items_to_widget_values (image_instance, gui);
2647
2648 x_widget_instantiate (image_instance, instantiator, pointer_fg,
2649 pointer_bg, dest_mask, domain, "progress", wv);
2650 }
2651
2652 /* set the properties of a progres guage */
2653 static void
2654 x_progress_gauge_update (Lisp_Object image_instance)
2655 {
2656 Lisp_Image_Instance *ii = XIMAGE_INSTANCE (image_instance);
2657
2658 if (IMAGE_INSTANCE_WIDGET_ITEMS_CHANGED (ii))
2659 {
2660 Arg al [1];
2661 Lisp_Object val;
2662 #ifdef ERROR_CHECK_GLYPHS
2663 assert (GUI_ITEMP (IMAGE_INSTANCE_WIDGET_PENDING_ITEMS (ii)));
2664 #endif
2665 val = XGUI_ITEM (IMAGE_INSTANCE_WIDGET_PENDING_ITEMS (ii))->value;
2666 XtSetArg (al[0], XtNvalue, XINT (val));
2667 XtSetValues (IMAGE_INSTANCE_X_WIDGET_ID (ii), al, 1);
2668 }
2669 }
2670
2671 /* instantiate an edit control */
2672 static void
2673 x_edit_field_instantiate (Lisp_Object image_instance, Lisp_Object instantiator,
2674 Lisp_Object pointer_fg, Lisp_Object pointer_bg,
2675 int dest_mask, Lisp_Object domain)
2676 {
2677 Lisp_Image_Instance *ii = XIMAGE_INSTANCE (image_instance);
2678 Lisp_Object gui = IMAGE_INSTANCE_WIDGET_ITEM (ii);
2679 widget_value* wv = gui_items_to_widget_values (image_instance, gui);
2680
2681 x_widget_instantiate (image_instance, instantiator, pointer_fg,
2682 pointer_bg, dest_mask, domain, "text-field", wv);
2683 }
2684
2685 #if defined (LWLIB_WIDGETS_MOTIF) && XmVERSION > 1
2686 /* instantiate a combo control */
2687 static void
2688 x_combo_box_instantiate (Lisp_Object image_instance, Lisp_Object instantiator,
2689 Lisp_Object pointer_fg, Lisp_Object pointer_bg,
2690 int dest_mask, Lisp_Object domain)
2691 {
2692 Lisp_Image_Instance *ii = XIMAGE_INSTANCE (image_instance);
2693 widget_value * wv = 0;
2694 /* This is not done generically because of sizing problems under
2695 mswindows. */
2696 widget_instantiate (image_instance, instantiator, pointer_fg,
2697 pointer_bg, dest_mask, domain);
2698
2699 wv = gui_items_to_widget_values (image_instance,
2700 IMAGE_INSTANCE_WIDGET_ITEMS (ii));
2701
2702 x_widget_instantiate (image_instance, instantiator, pointer_fg,
2703 pointer_bg, dest_mask, domain, "combo-box", wv);
2704 }
2705 #endif
2706
2707 static void
2708 x_tab_control_instantiate (Lisp_Object image_instance, Lisp_Object instantiator,
2709 Lisp_Object pointer_fg, Lisp_Object pointer_bg,
2710 int dest_mask, Lisp_Object domain)
2711 {
2712 Lisp_Image_Instance *ii = XIMAGE_INSTANCE (image_instance);
2713 widget_value * wv =
2714 gui_items_to_widget_values (image_instance,
2715 IMAGE_INSTANCE_WIDGET_ITEMS (ii));
2716
2717 update_tab_widget_face (wv, ii,
2718 IMAGE_INSTANCE_FRAME (ii));
2719
2720 x_widget_instantiate (image_instance, instantiator, pointer_fg,
2721 pointer_bg, dest_mask, domain, "tab-control", wv);
2722 }
2723
2724 /* set the properties of a tab control */
2725 static void
2726 x_tab_control_update (Lisp_Object image_instance)
2727 {
2728 Lisp_Image_Instance *ii = XIMAGE_INSTANCE (image_instance);
2729
2730 /* Possibly update the face. */
2731 if (IMAGE_INSTANCE_WIDGET_FACE_CHANGED (ii)
2732 ||
2733 XFRAME (IMAGE_INSTANCE_FRAME (ii))->faces_changed
2734 ||
2735 IMAGE_INSTANCE_WIDGET_ITEMS_CHANGED (ii))
2736 {
2737 widget_value* wv = lw_get_all_values (IMAGE_INSTANCE_X_WIDGET_LWID (ii));
2738
2739 /* #### I don't know why this can occur. */
2740 if (!wv)
2741 return;
2742
2743 update_tab_widget_face (wv, ii,
2744 IMAGE_INSTANCE_FRAME (ii));
2745
2746 lw_modify_all_widgets (IMAGE_INSTANCE_X_WIDGET_LWID (ii), wv, True);
2747 }
2748 }
2749
2750 /* instantiate a static control possible for putting other things in */
2751 static void
2752 x_label_instantiate (Lisp_Object image_instance, Lisp_Object instantiator,
2753 Lisp_Object pointer_fg, Lisp_Object pointer_bg,
2754 int dest_mask, Lisp_Object domain)
2755 {
2756 Lisp_Image_Instance *ii = XIMAGE_INSTANCE (image_instance);
2757 Lisp_Object gui = IMAGE_INSTANCE_WIDGET_ITEM (ii);
2758 widget_value* wv = gui_items_to_widget_values (image_instance, gui);
2759
2760 x_widget_instantiate (image_instance, instantiator, pointer_fg,
2761 pointer_bg, dest_mask, domain, "button", wv);
2762 }
2763 #endif /* HAVE_WIDGETS */
2764 2072
2765 2073
2766 /************************************************************************/ 2074 /************************************************************************/
2767 /* initialization */ 2075 /* initialization */
2768 /************************************************************************/ 2076 /************************************************************************/
2787 CONSOLE_HAS_METHOD (x, colorize_image_instance); 2095 CONSOLE_HAS_METHOD (x, colorize_image_instance);
2788 CONSOLE_HAS_METHOD (x, init_image_instance_from_eimage); 2096 CONSOLE_HAS_METHOD (x, init_image_instance_from_eimage);
2789 CONSOLE_HAS_METHOD (x, locate_pixmap_file); 2097 CONSOLE_HAS_METHOD (x, locate_pixmap_file);
2790 CONSOLE_HAS_METHOD (x, unmap_subwindow); 2098 CONSOLE_HAS_METHOD (x, unmap_subwindow);
2791 CONSOLE_HAS_METHOD (x, map_subwindow); 2099 CONSOLE_HAS_METHOD (x, map_subwindow);
2792 CONSOLE_HAS_METHOD (x, update_widget); 2100 CONSOLE_HAS_METHOD (x, resize_subwindow);
2793 CONSOLE_HAS_METHOD (x, update_subwindow);
2794 } 2101 }
2795 2102
2796 void 2103 void
2797 image_instantiator_format_create_glyphs_x (void) 2104 image_instantiator_format_create_glyphs_x (void)
2798 { 2105 {
2799 IIFORMAT_VALID_CONSOLE (x, nothing);
2800 IIFORMAT_VALID_CONSOLE (x, string);
2801 #ifdef HAVE_WIDGETS
2802 IIFORMAT_VALID_CONSOLE (x, layout);
2803 #endif
2804 IIFORMAT_VALID_CONSOLE (x, formatted_string);
2805 IIFORMAT_VALID_CONSOLE (x, inherit);
2806 #ifdef HAVE_XPM 2106 #ifdef HAVE_XPM
2807 INITIALIZE_DEVICE_IIFORMAT (x, xpm); 2107 INITIALIZE_DEVICE_IIFORMAT (x, xpm);
2808 IIFORMAT_HAS_DEVMETHOD (x, xpm, instantiate); 2108 IIFORMAT_HAS_DEVMETHOD (x, xpm, instantiate);
2809 #endif 2109 #endif
2810 #ifdef HAVE_JPEG
2811 IIFORMAT_VALID_CONSOLE (x, jpeg);
2812 #endif
2813 #ifdef HAVE_TIFF
2814 IIFORMAT_VALID_CONSOLE (x, tiff);
2815 #endif
2816 #ifdef HAVE_PNG
2817 IIFORMAT_VALID_CONSOLE (x, png);
2818 #endif
2819 #ifdef HAVE_GIF
2820 IIFORMAT_VALID_CONSOLE (x, gif);
2821 #endif
2822 INITIALIZE_DEVICE_IIFORMAT (x, xbm); 2110 INITIALIZE_DEVICE_IIFORMAT (x, xbm);
2823 IIFORMAT_HAS_DEVMETHOD (x, xbm, instantiate); 2111 IIFORMAT_HAS_DEVMETHOD (x, xbm, instantiate);
2824 2112
2825 INITIALIZE_DEVICE_IIFORMAT (x, subwindow); 2113 INITIALIZE_DEVICE_IIFORMAT (x, subwindow);
2826 IIFORMAT_HAS_DEVMETHOD (x, subwindow, instantiate); 2114 IIFORMAT_HAS_DEVMETHOD (x, subwindow, instantiate);
2827 #ifdef HAVE_WIDGETS 2115
2828 /* layout widget */
2829 INITIALIZE_DEVICE_IIFORMAT (x, native_layout);
2830 IIFORMAT_HAS_DEVMETHOD (x, native_layout, instantiate);
2831 /* button widget */
2832 INITIALIZE_DEVICE_IIFORMAT (x, button);
2833 IIFORMAT_HAS_DEVMETHOD (x, button, property);
2834 IIFORMAT_HAS_DEVMETHOD (x, button, instantiate);
2835 IIFORMAT_HAS_DEVMETHOD (x, button, update);
2836 /* general widget methods. */
2837 INITIALIZE_DEVICE_IIFORMAT (x, widget);
2838 IIFORMAT_HAS_DEVMETHOD (x, widget, property);
2839 /* progress gauge */
2840 INITIALIZE_DEVICE_IIFORMAT (x, progress_gauge);
2841 IIFORMAT_HAS_DEVMETHOD (x, progress_gauge, update);
2842 IIFORMAT_HAS_DEVMETHOD (x, progress_gauge, instantiate);
2843 /* text field */
2844 INITIALIZE_DEVICE_IIFORMAT (x, edit_field);
2845 IIFORMAT_HAS_DEVMETHOD (x, edit_field, instantiate);
2846 #if defined (LWLIB_WIDGETS_MOTIF) && XmVERSION > 1
2847 /* combo box */
2848 INITIALIZE_DEVICE_IIFORMAT (x, combo_box);
2849 IIFORMAT_HAS_DEVMETHOD (x, combo_box, instantiate);
2850 IIFORMAT_HAS_SHARED_DEVMETHOD (x, combo_box, update, tab_control);
2851 #endif
2852 /* tab control widget */
2853 INITIALIZE_DEVICE_IIFORMAT (x, tab_control);
2854 IIFORMAT_HAS_DEVMETHOD (x, tab_control, instantiate);
2855 IIFORMAT_HAS_DEVMETHOD (x, tab_control, update);
2856 /* label */
2857 INITIALIZE_DEVICE_IIFORMAT (x, label);
2858 IIFORMAT_HAS_DEVMETHOD (x, label, instantiate);
2859 #endif
2860 INITIALIZE_IMAGE_INSTANTIATOR_FORMAT (cursor_font, "cursor-font"); 2116 INITIALIZE_IMAGE_INSTANTIATOR_FORMAT (cursor_font, "cursor-font");
2861 IIFORMAT_VALID_CONSOLE (x, cursor_font);
2862 2117
2863 IIFORMAT_HAS_METHOD (cursor_font, validate); 2118 IIFORMAT_HAS_METHOD (cursor_font, validate);
2864 IIFORMAT_HAS_METHOD (cursor_font, possible_dest_types); 2119 IIFORMAT_HAS_METHOD (cursor_font, possible_dest_types);
2865 IIFORMAT_HAS_METHOD (cursor_font, instantiate); 2120 IIFORMAT_HAS_METHOD (cursor_font, instantiate);
2866 2121
2871 INITIALIZE_IMAGE_INSTANTIATOR_FORMAT (font, "font"); 2126 INITIALIZE_IMAGE_INSTANTIATOR_FORMAT (font, "font");
2872 2127
2873 IIFORMAT_HAS_METHOD (font, validate); 2128 IIFORMAT_HAS_METHOD (font, validate);
2874 IIFORMAT_HAS_METHOD (font, possible_dest_types); 2129 IIFORMAT_HAS_METHOD (font, possible_dest_types);
2875 IIFORMAT_HAS_METHOD (font, instantiate); 2130 IIFORMAT_HAS_METHOD (font, instantiate);
2876 IIFORMAT_VALID_CONSOLE (x, font);
2877 2131
2878 IIFORMAT_VALID_KEYWORD (font, Q_data, check_valid_string); 2132 IIFORMAT_VALID_KEYWORD (font, Q_data, check_valid_string);
2879 IIFORMAT_VALID_KEYWORD (font, Q_foreground, check_valid_string); 2133 IIFORMAT_VALID_KEYWORD (font, Q_foreground, check_valid_string);
2880 IIFORMAT_VALID_KEYWORD (font, Q_background, check_valid_string); 2134 IIFORMAT_VALID_KEYWORD (font, Q_background, check_valid_string);
2881 2135
2889 2143
2890 IIFORMAT_HAS_METHOD (autodetect, validate); 2144 IIFORMAT_HAS_METHOD (autodetect, validate);
2891 IIFORMAT_HAS_METHOD (autodetect, normalize); 2145 IIFORMAT_HAS_METHOD (autodetect, normalize);
2892 IIFORMAT_HAS_METHOD (autodetect, possible_dest_types); 2146 IIFORMAT_HAS_METHOD (autodetect, possible_dest_types);
2893 IIFORMAT_HAS_METHOD (autodetect, instantiate); 2147 IIFORMAT_HAS_METHOD (autodetect, instantiate);
2894 IIFORMAT_VALID_CONSOLE (x, autodetect);
2895 2148
2896 IIFORMAT_VALID_KEYWORD (autodetect, Q_data, check_valid_string); 2149 IIFORMAT_VALID_KEYWORD (autodetect, Q_data, check_valid_string);
2897 } 2150 }
2898 2151
2899 void 2152 void
2917 vector3 (Qxbm, Q_data, \ 2170 vector3 (Qxbm, Q_data, \
2918 list3 (make_int (name##_width), \ 2171 list3 (make_int (name##_width), \
2919 make_int (name##_height), \ 2172 make_int (name##_height), \
2920 make_ext_string (name##_bits, \ 2173 make_ext_string (name##_bits, \
2921 sizeof (name##_bits), \ 2174 sizeof (name##_bits), \
2922 Qbinary))), \ 2175 FORMAT_BINARY))), \
2923 Qglobal, Qx, Qnil) 2176 Qglobal, Qx, Qnil)
2924 2177
2925 BUILD_GLYPH_INST (Vtruncation_glyph, truncator); 2178 BUILD_GLYPH_INST (Vtruncation_glyph, truncator);
2926 BUILD_GLYPH_INST (Vcontinuation_glyph, continuer); 2179 BUILD_GLYPH_INST (Vcontinuation_glyph, continuer);
2927 BUILD_GLYPH_INST (Vxemacs_logo, xemacs); 2180 BUILD_GLYPH_INST (Vxemacs_logo, xemacs);