X-Git-Url: http://git.chise.org/gitweb/?p=chise%2Fxemacs-chise.git.1;a=blobdiff_plain;f=src%2Fglyphs-x.c;h=105bbffc586898e069177f292c54c1d8e23b0a3a;hp=af515d8c7154e1d1d922768ac212720fcfd84cf0;hb=f7019bf646d0d4e750e0186d6e912ec7a3b9da90;hpb=762383636a99307282c2d93d26c35c046ec24da1 diff --git a/src/glyphs-x.c b/src/glyphs-x.c index af515d8..105bbff 100644 --- a/src/glyphs-x.c +++ b/src/glyphs-x.c @@ -4,7 +4,7 @@ Copyright (C) 1995 Tinker Systems Copyright (C) 1995, 1996 Ben Wing Copyright (C) 1995 Sun Microsystems - Copyright (C) 1999, 2000 Andy Piper + Copyright (C) 1999, 2000, 2002 Andy Piper This file is part of XEmacs. @@ -17,7 +17,6 @@ XEmacs is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. - You should have received a copy of the GNU General Public License along with XEmacs; see the file COPYING. If not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, @@ -25,6 +24,8 @@ Boston, MA 02111-1307, USA. */ /* Synched up with: Not in FSF. */ +/* 7-8-00 This file is more or less Mule-ized in my Mule workspace. */ + /* Original author: Jamie Zawinski for 19.8 font-truename stuff added by Jamie Zawinski for 19.10 subwindow support added by Chuck Thompson @@ -155,6 +156,10 @@ static void update_tab_widget_face (widget_value* wv, Lisp_Image_Instance* ii, Lisp_Object domain); #endif +void +emacs_Xt_handle_widget_losing_focus (struct frame* f, Widget losing_widget); +void +enqueue_focus_event (Widget wants_it, Lisp_Object frame, int in_p); #include "bitmaps.h" @@ -228,7 +233,8 @@ convert_EImage_to_XImage (Lisp_Object device, int width, int height, if (vis->class == PseudoColor) { unsigned long pixarray[256]; - int pixcount, n; + int pixcount; + unsigned int n; /* use our quantize table to allocate the colors */ pixcount = 32; *pixtbl = xnew_array (unsigned long, pixcount); @@ -397,7 +403,7 @@ x_finalize_image_instance (Lisp_Image_Instance *p) if (DEVICE_LIVE_P (XDEVICE (IMAGE_INSTANCE_DEVICE (p)))) { - Display *dpy = DEVICE_X_DISPLAY + Display *dpy = DEVICE_X_DISPLAY (XDEVICE (IMAGE_INSTANCE_DEVICE (p))); if (0) ; @@ -429,7 +435,7 @@ x_finalize_image_instance (Lisp_Image_Instance *p) } else { - int i; + unsigned int i; if (IMAGE_INSTANCE_PIXMAP_TIMEOUT (p)) disable_glyph_animated_timeout (IMAGE_INSTANCE_PIXMAP_TIMEOUT (p)); @@ -700,7 +706,7 @@ write_lisp_string_to_temp_file (Lisp_Object string, char *filename_out) /* Get the data while doing the conversion */ while (1) { - ssize_t size_in_bytes = Lstream_read (istr, tempbuf, sizeof (tempbuf)); + Lstream_data_count size_in_bytes = Lstream_read (istr, tempbuf, sizeof (tempbuf)); if (!size_in_bytes) break; /* It does seem the flushes are necessary... */ @@ -795,7 +801,7 @@ generate_cursor_fg_bg (Lisp_Object device, Lisp_Object *foreground, else { xbg->pixel = 0; - xbg->red = xbg->green = xbg->blue = ~0; + xbg->red = xbg->green = xbg->blue = USHRT_MAX; } } @@ -999,12 +1005,13 @@ int read_bitmap_data_from_file (const char *filename, unsigned int *width, static Pixmap pixmap_from_xbm_inline (Lisp_Object device, int width, int height, /* Note that data is in ext-format! */ - const Extbyte *bits) + const char *bits) { - return XCreatePixmapFromBitmapData (DEVICE_X_DISPLAY (XDEVICE(device)), - XtWindow (DEVICE_XT_APP_SHELL (XDEVICE (device))), - (char *) bits, width, height, - 1, 0, 1); + return XCreatePixmapFromBitmapData + (DEVICE_X_DISPLAY (XDEVICE (device)), + XtWindow (DEVICE_XT_APP_SHELL (XDEVICE (device))), + (char *) bits, width, height, + 1, 0, 1); } /* Given inline data for a mono pixmap, initialize the given @@ -1143,7 +1150,7 @@ init_image_instance_from_xbm_inline (Lisp_Image_Instance *ii, break; default: - abort (); + ABORT (); } } @@ -1163,13 +1170,11 @@ xbm_instantiate_1 (Lisp_Object image_instance, Lisp_Object instantiator, { const char *ext_data; - TO_EXTERNAL_FORMAT (LISP_STRING, XCAR (XCDR (XCDR (mask_data))), - C_STRING_ALLOCA, ext_data, - Qbinary); + LISP_STRING_TO_EXTERNAL (XCAR (XCDR (XCDR (mask_data))), ext_data, Qbinary); mask = pixmap_from_xbm_inline (IMAGE_INSTANCE_DEVICE (ii), XINT (XCAR (mask_data)), XINT (XCAR (XCDR (mask_data))), - (const unsigned char *) ext_data); + ext_data); } init_image_instance_from_xbm_inline (ii, width, height, bits, @@ -1189,9 +1194,7 @@ x_xbm_instantiate (Lisp_Object image_instance, Lisp_Object instantiator, assert (!NILP (data)); - TO_EXTERNAL_FORMAT (LISP_STRING, XCAR (XCDR (XCDR (data))), - C_STRING_ALLOCA, ext_data, - Qbinary); + LISP_STRING_TO_EXTERNAL (XCAR (XCDR (XCDR (data))), ext_data, Qbinary); xbm_instantiate_1 (image_instance, instantiator, pointer_fg, pointer_bg, dest_mask, XINT (XCAR (data)), @@ -1274,7 +1277,7 @@ extract_xpm_color_names (XpmAttributes *xpmattrs, Lisp_Object device, /* Duplicate the pixel value so that we still have a lock on it if the pixel we were passed is later freed. */ if (! XAllocColor (dpy, cmap, &color)) - abort (); /* it must be allocable since we're just duplicating it */ + ABORT (); /* it must be allocable since we're just duplicating it */ symbols [i].name = (char *) XSTRING_DATA (XCAR (cons)); symbols [i].pixel = color.pixel; @@ -1629,7 +1632,7 @@ x_xpm_instantiate (Lisp_Object image_instance, Lisp_Object instantiator, break; default: - abort (); + ABORT (); } xpm_free (&xpmattrs); /* after we've read pixels and hotspot */ @@ -1677,9 +1680,7 @@ x_xface_instantiate (Lisp_Object image_instance, Lisp_Object instantiator, assert (!NILP (data)); - TO_EXTERNAL_FORMAT (LISP_STRING, data, - C_STRING_ALLOCA, dstring, - Qbinary); + LISP_STRING_TO_EXTERNAL (data, dstring, Qbinary); if ((p = strchr (dstring, ':'))) { @@ -1743,7 +1744,8 @@ autodetect_validate (Lisp_Object instantiator) static Lisp_Object autodetect_normalize (Lisp_Object instantiator, - Lisp_Object console_type) + Lisp_Object console_type, + Lisp_Object dest_mask) { Lisp_Object file = find_keyword_in_vector (instantiator, Q_data); Lisp_Object filename = Qnil; @@ -1851,9 +1853,7 @@ autodetect_instantiate (Lisp_Object image_instance, if (dest_mask & IMAGE_POINTER_MASK) { const char *name_ext; - TO_EXTERNAL_FORMAT (LISP_STRING, data, - C_STRING_ALLOCA, name_ext, - Qfile_name); + LISP_STRING_TO_EXTERNAL (data, name_ext, Qfile_name); if (XmuCursorNameToIndex (name_ext) != -1) { result = alist_to_tagged_vector (Qcursor_font, alist); @@ -2053,9 +2053,7 @@ cursor_font_instantiate (Lisp_Object image_instance, Lisp_Object instantiator, if (!(dest_mask & IMAGE_POINTER_MASK)) incompatible_image_types (instantiator, dest_mask, IMAGE_POINTER_MASK); - TO_EXTERNAL_FORMAT (LISP_STRING, data, - C_STRING_ALLOCA, name_ext, - Qfile_name); + LISP_STRING_TO_EXTERNAL (data, name_ext, Qfile_name); if ((i = XmuCursorNameToIndex (name_ext)) == -1) signal_simple_error ("Unrecognized cursor-font name", data); @@ -2137,6 +2135,12 @@ x_unmap_subwindow (Lisp_Image_Instance *p) } else /* must be a widget */ { + /* Since we are being unmapped we want the enclosing frame to + get focus. The losing with simple scrolling but is the safest + thing to do. */ + emacs_Xt_handle_widget_losing_focus + ( XFRAME (IMAGE_INSTANCE_FRAME (p)), + IMAGE_INSTANCE_X_WIDGET_ID (p)); XtUnmapWidget (IMAGE_INSTANCE_X_CLIPWIDGET (p)); } } @@ -2147,6 +2151,7 @@ static void x_map_subwindow (Lisp_Image_Instance *p, int x, int y, struct display_glyph_area* dga) { + assert (dga->width > 0 && dga->height > 0); if (IMAGE_INSTANCE_TYPE (p) == IMAGE_SUBWINDOW) { Window subwindow = IMAGE_INSTANCE_X_SUBWINDOW_ID (p); @@ -2155,8 +2160,9 @@ x_map_subwindow (Lisp_Image_Instance *p, int x, int y, x, y, dga->width, dga->height); XMoveWindow (IMAGE_INSTANCE_X_SUBWINDOW_DISPLAY (p), subwindow, -dga->xoffset, -dga->yoffset); - XMapWindow (IMAGE_INSTANCE_X_SUBWINDOW_DISPLAY (p), - IMAGE_INSTANCE_X_CLIPWINDOW (p)); + if (!IMAGE_INSTANCE_SUBWINDOW_DISPLAYEDP (p)) + XMapWindow (IMAGE_INSTANCE_X_SUBWINDOW_DISPLAY (p), + IMAGE_INSTANCE_X_CLIPWINDOW (p)); } else /* must be a widget */ { @@ -2166,14 +2172,23 @@ x_map_subwindow (Lisp_Image_Instance *p, int x, int y, dga->width, dga->height, 0); XtMoveWidget (IMAGE_INSTANCE_X_WIDGET_ID (p), -dga->xoffset, -dga->yoffset); - XtMapWidget (IMAGE_INSTANCE_X_CLIPWIDGET (p)); + if (!IMAGE_INSTANCE_SUBWINDOW_DISPLAYEDP (p)) + XtMapWidget (IMAGE_INSTANCE_X_CLIPWIDGET (p)); + /* See comments in glyphs-msw.c about keyboard focus. */ + if (IMAGE_INSTANCE_WANTS_INITIAL_FOCUS (p)) { + /* #### FIXME to pop-up the find dialog we map the text-field + seven times! This doesn't show on a fast linux box but does + under X on windows. */ + enqueue_focus_event (IMAGE_INSTANCE_X_WIDGET_ID (p), + IMAGE_INSTANCE_FRAME (p), 1); + } } } /* when you click on a widget you may activate another widget this needs to be checked and all appropriate widgets updated */ static void -x_update_subwindow (Lisp_Image_Instance *p) +x_redisplay_subwindow (Lisp_Image_Instance *p) { /* Update the subwindow size if necessary. */ if (IMAGE_INSTANCE_SIZE_CHANGED (p)) @@ -2188,7 +2203,7 @@ x_update_subwindow (Lisp_Image_Instance *p) /* Update all attributes that have changed. Lwlib actually does most of this for us. */ static void -x_update_widget (Lisp_Image_Instance *p) +x_redisplay_widget (Lisp_Image_Instance *p) { /* This function can GC if IN_REDISPLAY is false. */ #ifdef HAVE_WIDGETS @@ -2203,25 +2218,35 @@ x_update_widget (Lisp_Image_Instance *p) XSETIMAGE_INSTANCE (image_instance, p); wv = gui_items_to_widget_values - (image_instance, IMAGE_INSTANCE_WIDGET_PENDING_ITEMS (p)); + (image_instance, IMAGE_INSTANCE_WIDGET_PENDING_ITEMS (p), + /* #### this is not right; we need to keep track of which widgets + want accelerators and which don't */ 0); wv->change = STRUCTURAL_CHANGE; - /* now modify the widget */ - lw_modify_all_widgets (IMAGE_INSTANCE_X_WIDGET_LWID (p), - wv, True); - free_widget_value_tree (wv); } - - /* Now do non structural updates. */ - wv = lw_get_all_values (IMAGE_INSTANCE_X_WIDGET_LWID (p)); - - if (!wv) - return; + else + { + /* Assume the lotus position, breath deeply and chant to + yourself lwlibsux, lwlibsux ... lw_get_all_values returns a + reference to the real values rather than a copy thus any + changes we make to the values we get back will look like they + have already been applied. If we rebuild the widget tree then + we may lose properties. */ + wv = copy_widget_value_tree (lw_get_all_values + (IMAGE_INSTANCE_X_WIDGET_LWID (p)), + NO_CHANGE); + } /* Possibly update the colors and font */ if (IMAGE_INSTANCE_WIDGET_FACE_CHANGED (p) || + /* #### This is not sufficient because it will not cope with widgets + that are not currently visible. Once redisplay has done the + visible ones it will clear this flag so that when new ones + become visible they will not be updated. */ XFRAME (IMAGE_INSTANCE_FRAME (p))->faces_changed || + XFRAME (IMAGE_INSTANCE_FRAME (p))->frame_changed + || IMAGE_INSTANCE_WIDGET_ITEMS_CHANGED (p)) { update_widget_face (wv, p, IMAGE_INSTANCE_FRAME (p)); @@ -2232,9 +2257,7 @@ x_update_widget (Lisp_Image_Instance *p) { char* str; Lisp_Object val = IMAGE_INSTANCE_WIDGET_TEXT (p); - TO_EXTERNAL_FORMAT (LISP_STRING, val, - C_STRING_ALLOCA, str, - Qnative); + LISP_STRING_TO_EXTERNAL (val, str, Qnative); wv->value = str; } @@ -2262,9 +2285,20 @@ x_update_widget (Lisp_Image_Instance *p) (Dimension)IMAGE_INSTANCE_HEIGHT (p)); } + /* Adjust offsets within the frame. */ + if (XFRAME (IMAGE_INSTANCE_FRAME (p))->size_changed) + { + Arg al[2]; + XtSetArg (al [0], XtNx, &IMAGE_INSTANCE_X_WIDGET_XOFFSET (p)); + XtSetArg (al [1], XtNy, &IMAGE_INSTANCE_X_WIDGET_YOFFSET (p)); + XtGetValues (FRAME_X_TEXT_WIDGET + (XFRAME (IMAGE_INSTANCE_FRAME (p))), al, 2); + } + /* now modify the widget */ lw_modify_all_widgets (IMAGE_INSTANCE_X_WIDGET_LWID (p), - wv, False); + wv, True); + free_widget_value_tree (wv); #endif } @@ -2322,6 +2356,14 @@ x_subwindow_instantiate (Lisp_Object image_instance, Lisp_Object instantiator, IMAGE_INSTANCE_SUBWINDOW_ID (ii) = (void*)win; } +/* Account for some of the limitations with widget images. */ +static int +x_widget_border_width (void) +{ + return DEFAULT_WIDGET_BORDER_WIDTH * 2; +} + + #if 0 /* #### Should this function exist? If there's any doubt I'm not implementing it --andyp */ DEFUN ("change-subwindow-property", Fchange_subwindow_property, 3, 3, 0, /* @@ -2394,6 +2436,11 @@ update_widget_face (widget_value* wv, Lisp_Image_Instance *ii, (IMAGE_INSTANCE_WIDGET_TEXT (ii), IMAGE_INSTANCE_WIDGET_FACE (ii), domain)))); + wv->change = VISIBLE_CHANGE; + /* #### Megahack - but its just getting too complicated to do this + in the right place. */ + if (EQ (IMAGE_INSTANCE_WIDGET_TYPE (ii), Qtab_control)) + update_tab_widget_face (wv, ii, domain); } static void @@ -2410,9 +2457,12 @@ update_tab_widget_face (widget_value* wv, Lisp_Image_Instance *ii, domain); XColor fcolor = COLOR_INSTANCE_X_COLOR (XCOLOR_INSTANCE (pixel)); lw_add_widget_value_arg (val, XtNtabForeground, fcolor.pixel); + wv->change = VISIBLE_CHANGE; + val->change = VISIBLE_CHANGE; for (cur = val->next; cur; cur = cur->next) { + cur->change = VISIBLE_CHANGE; if (cur->value) { lw_copy_widget_value_args (val, cur); @@ -2449,9 +2499,7 @@ x_widget_instantiate (Lisp_Object image_instance, Lisp_Object instantiator, IMAGE_INSTANCE_TYPE (ii) = IMAGE_WIDGET; if (!NILP (IMAGE_INSTANCE_WIDGET_TEXT (ii))) - TO_EXTERNAL_FORMAT (LISP_STRING, IMAGE_INSTANCE_WIDGET_TEXT (ii), - C_STRING_ALLOCA, nm, - Qnative); + LISP_STRING_TO_EXTERNAL (IMAGE_INSTANCE_WIDGET_TEXT (ii), nm, Qnative); ii->data = xnew_and_zero (struct x_subwindow_data); @@ -2478,6 +2526,10 @@ x_widget_instantiate (Lisp_Object image_instance, Lisp_Object instantiator, free_widget_value_tree (clip_wv); + /* create a sensible name. */ + if (wv->name == 0 || strcmp(wv->name, "") == 0) + wv->name = xstrdup (type); + /* copy any args we were given */ ac = 0; lw_add_value_args_to_args (wv, al, &ac); @@ -2566,7 +2618,7 @@ x_button_instantiate (Lisp_Object image_instance, Lisp_Object instantiator, Lisp_Image_Instance *ii = XIMAGE_INSTANCE (image_instance); Lisp_Object gui = IMAGE_INSTANCE_WIDGET_ITEM (ii); Lisp_Object glyph = find_keyword_in_vector (instantiator, Q_image); - widget_value* wv = gui_items_to_widget_values (image_instance, gui); + widget_value* wv = gui_items_to_widget_values (image_instance, gui, 1); if (!NILP (glyph)) { @@ -2603,13 +2655,13 @@ x_button_instantiate (Lisp_Object image_instance, Lisp_Object instantiator, i.e. although the arg contents may be the same the args look different and so are re-applied to the widget. */ static void -x_button_update (Lisp_Object image_instance) +x_button_redisplay (Lisp_Object image_instance) { /* This function can GC if IN_REDISPLAY is false. */ Lisp_Image_Instance *p = XIMAGE_INSTANCE (image_instance); widget_value* wv = gui_items_to_widget_values (image_instance, - IMAGE_INSTANCE_WIDGET_ITEMS (p)); + IMAGE_INSTANCE_WIDGET_ITEMS (p), 1); /* now modify the widget */ lw_modify_all_widgets (IMAGE_INSTANCE_X_WIDGET_LWID (p), @@ -2643,15 +2695,15 @@ x_progress_gauge_instantiate (Lisp_Object image_instance, Lisp_Object instantiat { Lisp_Image_Instance *ii = XIMAGE_INSTANCE (image_instance); Lisp_Object gui = IMAGE_INSTANCE_WIDGET_ITEM (ii); - widget_value* wv = gui_items_to_widget_values (image_instance, gui); + widget_value* wv = gui_items_to_widget_values (image_instance, gui, 0); x_widget_instantiate (image_instance, instantiator, pointer_fg, pointer_bg, dest_mask, domain, "progress", wv); } -/* set the properties of a progres guage */ +/* set the properties of a progress gauge */ static void -x_progress_gauge_update (Lisp_Object image_instance) +x_progress_gauge_redisplay (Lisp_Object image_instance) { Lisp_Image_Instance *ii = XIMAGE_INSTANCE (image_instance); @@ -2676,7 +2728,7 @@ x_edit_field_instantiate (Lisp_Object image_instance, Lisp_Object instantiator, { Lisp_Image_Instance *ii = XIMAGE_INSTANCE (image_instance); Lisp_Object gui = IMAGE_INSTANCE_WIDGET_ITEM (ii); - widget_value* wv = gui_items_to_widget_values (image_instance, gui); + widget_value* wv = gui_items_to_widget_values (image_instance, gui, 0); x_widget_instantiate (image_instance, instantiator, pointer_fg, pointer_bg, dest_mask, domain, "text-field", wv); @@ -2697,7 +2749,7 @@ x_combo_box_instantiate (Lisp_Object image_instance, Lisp_Object instantiator, pointer_bg, dest_mask, domain); wv = gui_items_to_widget_values (image_instance, - IMAGE_INSTANCE_WIDGET_ITEMS (ii)); + IMAGE_INSTANCE_WIDGET_ITEMS (ii), 0); x_widget_instantiate (image_instance, instantiator, pointer_fg, pointer_bg, dest_mask, domain, "combo-box", wv); @@ -2712,21 +2764,78 @@ x_tab_control_instantiate (Lisp_Object image_instance, Lisp_Object instantiator, Lisp_Image_Instance *ii = XIMAGE_INSTANCE (image_instance); widget_value * wv = gui_items_to_widget_values (image_instance, - IMAGE_INSTANCE_WIDGET_ITEMS (ii)); - + IMAGE_INSTANCE_WIDGET_ITEMS (ii), 0); update_tab_widget_face (wv, ii, IMAGE_INSTANCE_FRAME (ii)); - x_widget_instantiate (image_instance, instantiator, pointer_fg, pointer_bg, dest_mask, domain, "tab-control", wv); } -/* set the properties of a tab control */ +/* Set the properties of a tab control */ static void -x_tab_control_update (Lisp_Object image_instance) +x_tab_control_redisplay (Lisp_Object image_instance) { Lisp_Image_Instance *ii = XIMAGE_INSTANCE (image_instance); + if (IMAGE_INSTANCE_WIDGET_ITEMS_CHANGED (ii) + || + IMAGE_INSTANCE_WIDGET_ACTION_OCCURRED (ii)) + { + /* If only the order has changed then simply select the first + one of the pending set. This stops horrendous rebuilding - + and hence flicker - of the tabs each time you click on + one. */ + if (tab_control_order_only_changed (image_instance)) + { + Lisp_Object rest, selected = + gui_item_list_find_selected + (NILP (IMAGE_INSTANCE_WIDGET_PENDING_ITEMS (ii)) ? + XCDR (IMAGE_INSTANCE_WIDGET_ITEMS (ii)) : + XCDR (IMAGE_INSTANCE_WIDGET_PENDING_ITEMS (ii))); + + LIST_LOOP (rest, XCDR (IMAGE_INSTANCE_WIDGET_ITEMS (ii))) + { + if (gui_item_equal_sans_selected (XCAR (rest), selected, 0)) + { + /* There may be an encapsulated way of doing this, + but I couldn't find it. */ + Lisp_Object old_selected =gui_item_list_find_selected + (XCDR (IMAGE_INSTANCE_WIDGET_ITEMS (ii))); + Arg al [2]; + char* name; + unsigned int num_children, i; + Widget* children; + + LISP_STRING_TO_EXTERNAL (XGUI_ITEM (XCAR (rest))->name, + name, Qnative); + /* The name may contain a `.' which confuses + XtNameToWidget, so we do it ourselves. */ + children = XtCompositeChildren (IMAGE_INSTANCE_X_WIDGET_ID (ii), + &num_children); + for (i = 0; i < num_children; i++) + { + if (!strcmp (XtName (children [i]), name)) + { + XtSetArg (al [0], XtNtopWidget, children [i]); + XtSetArg (al [1], XtNhighlightWidget, + children [i]); + XtSetValues (IMAGE_INSTANCE_X_WIDGET_ID (ii), al, 2); + break; + } + } + /* Pick up the new selected item. */ + XGUI_ITEM (old_selected)->selected = + XGUI_ITEM (XCAR (rest))->selected; + XGUI_ITEM (XCAR (rest))->selected = + XGUI_ITEM (selected)->selected; + /* We're not actually changing the items anymore. */ + IMAGE_INSTANCE_WIDGET_ITEMS_CHANGED (ii) = 0; + IMAGE_INSTANCE_WIDGET_PENDING_ITEMS (ii) = Qnil; + break; + } + } + } + } /* Possibly update the face. */ if (IMAGE_INSTANCE_WIDGET_FACE_CHANGED (ii) || @@ -2734,16 +2843,21 @@ x_tab_control_update (Lisp_Object image_instance) || IMAGE_INSTANCE_WIDGET_ITEMS_CHANGED (ii)) { - widget_value* wv = lw_get_all_values (IMAGE_INSTANCE_X_WIDGET_LWID (ii)); + /* See previous comments on the brokeness of lwlib. - /* #### I don't know why this can occur. */ - if (!wv) - return; + #### There's actually not much point in doing this here + since, colors will have been set appropriately by + x_redisplay_widget. */ + widget_value* wv =copy_widget_value_tree + (lw_get_all_values + (IMAGE_INSTANCE_X_WIDGET_LWID (ii)), + NO_CHANGE); update_tab_widget_face (wv, ii, IMAGE_INSTANCE_FRAME (ii)); lw_modify_all_widgets (IMAGE_INSTANCE_X_WIDGET_LWID (ii), wv, True); + free_widget_value_tree (wv); } } @@ -2755,7 +2869,7 @@ x_label_instantiate (Lisp_Object image_instance, Lisp_Object instantiator, { Lisp_Image_Instance *ii = XIMAGE_INSTANCE (image_instance); Lisp_Object gui = IMAGE_INSTANCE_WIDGET_ITEM (ii); - widget_value* wv = gui_items_to_widget_values (image_instance, gui); + widget_value* wv = gui_items_to_widget_values (image_instance, gui, 0); x_widget_instantiate (image_instance, instantiator, pointer_fg, pointer_bg, dest_mask, domain, "button", wv); @@ -2789,8 +2903,9 @@ console_type_create_glyphs_x (void) CONSOLE_HAS_METHOD (x, locate_pixmap_file); CONSOLE_HAS_METHOD (x, unmap_subwindow); CONSOLE_HAS_METHOD (x, map_subwindow); - CONSOLE_HAS_METHOD (x, update_widget); - CONSOLE_HAS_METHOD (x, update_subwindow); + CONSOLE_HAS_METHOD (x, redisplay_widget); + CONSOLE_HAS_METHOD (x, redisplay_subwindow); + CONSOLE_HAS_METHOD (x, widget_border_width); } void @@ -2832,13 +2947,13 @@ image_instantiator_format_create_glyphs_x (void) INITIALIZE_DEVICE_IIFORMAT (x, button); IIFORMAT_HAS_DEVMETHOD (x, button, property); IIFORMAT_HAS_DEVMETHOD (x, button, instantiate); - IIFORMAT_HAS_DEVMETHOD (x, button, update); + IIFORMAT_HAS_DEVMETHOD (x, button, redisplay); /* general widget methods. */ INITIALIZE_DEVICE_IIFORMAT (x, widget); IIFORMAT_HAS_DEVMETHOD (x, widget, property); /* progress gauge */ INITIALIZE_DEVICE_IIFORMAT (x, progress_gauge); - IIFORMAT_HAS_DEVMETHOD (x, progress_gauge, update); + IIFORMAT_HAS_DEVMETHOD (x, progress_gauge, redisplay); IIFORMAT_HAS_DEVMETHOD (x, progress_gauge, instantiate); /* text field */ INITIALIZE_DEVICE_IIFORMAT (x, edit_field); @@ -2847,12 +2962,12 @@ image_instantiator_format_create_glyphs_x (void) /* combo box */ INITIALIZE_DEVICE_IIFORMAT (x, combo_box); IIFORMAT_HAS_DEVMETHOD (x, combo_box, instantiate); - IIFORMAT_HAS_SHARED_DEVMETHOD (x, combo_box, update, tab_control); + IIFORMAT_HAS_SHARED_DEVMETHOD (x, combo_box, redisplay, tab_control); #endif /* tab control widget */ INITIALIZE_DEVICE_IIFORMAT (x, tab_control); IIFORMAT_HAS_DEVMETHOD (x, tab_control, instantiate); - IIFORMAT_HAS_DEVMETHOD (x, tab_control, update); + IIFORMAT_HAS_DEVMETHOD (x, tab_control, redisplay); /* label */ INITIALIZE_DEVICE_IIFORMAT (x, label); IIFORMAT_HAS_DEVMETHOD (x, label, instantiate); @@ -2890,6 +3005,17 @@ image_instantiator_format_create_glyphs_x (void) IIFORMAT_HAS_METHOD (autodetect, validate); IIFORMAT_HAS_METHOD (autodetect, normalize); IIFORMAT_HAS_METHOD (autodetect, possible_dest_types); + /* #### autodetect is flawed IMO: + 1. It makes the assumption that you can detect whether the user + wanted a cursor or a string based on the data, since the data is a + string you have to prioritise cursors. Instead we will force users + to pick the appropriate image type, this is what we do under + MS-Windows anyway. + 2. It doesn't fit with the new domain model - you cannot tell which + domain it needs to be instantiated in until you've actually + instantiated it, which mucks up caching. + 3. It only copes with cursors and strings which seems bogus. */ + IIFORMAT_HAS_SHARED_METHOD (autodetect, governing_domain, subwindow); IIFORMAT_HAS_METHOD (autodetect, instantiate); IIFORMAT_VALID_CONSOLE (x, autodetect); @@ -2917,7 +3043,7 @@ complex_vars_of_glyphs_x (void) vector3 (Qxbm, Q_data, \ list3 (make_int (name##_width), \ make_int (name##_height), \ - make_ext_string (name##_bits, \ + make_ext_string ((Extbyte *) name##_bits, \ sizeof (name##_bits), \ Qbinary))), \ Qglobal, Qx, Qnil)