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.
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,
/* 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
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"
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);
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)
;
}
else
{
- int i;
+ unsigned int i;
if (IMAGE_INSTANCE_PIXMAP_TIMEOUT (p))
disable_glyph_animated_timeout (IMAGE_INSTANCE_PIXMAP_TIMEOUT (p));
/* 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... */
else
{
xbg->pixel = 0;
- xbg->red = xbg->green = xbg->blue = ~0;
+ xbg->red = xbg->green = xbg->blue = USHRT_MAX;
}
}
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
break;
default:
- abort ();
+ ABORT ();
}
}
{
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,
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)),
/* 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;
break;
default:
- abort ();
+ ABORT ();
}
xpm_free (&xpmattrs); /* after we've read pixels and hotspot */
{
Lisp_Object data = find_keyword_in_vector (instantiator, Q_data);
int i, stattis;
- char *p, *bits, *bp;
+ char *bits, *bp;
+ const char *p;
const char * volatile emsg = 0;
const char * volatile dstring;
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, ':')))
{
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;
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);
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);
}
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));
}
}
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);
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 */
{
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))
/* 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
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));
{
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;
}
(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
}
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, /*
(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
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);
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);
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);
Lisp_Object pointer_fg, Lisp_Object pointer_bg,
int dest_mask, Lisp_Object domain)
{
- Lisp_Image_Instance *ii = XIMAGE_INSTANCE (image_instance);
-
x_widget_instantiate (image_instance, instantiator, pointer_fg,
pointer_bg, dest_mask, domain, "layout", 0);
}
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))
{
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),
{
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);
{
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);
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);
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)
||
||
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);
}
}
{
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);
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
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);
/* 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);
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);
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)