xemacs-beta: src/event-Xt.c comparison

comparison src/event-Xt.c @ 183:e121b013d1f0 r20-3b18

Import from CVS: tag r20-3b18

author	cvs
date	Mon, 13 Aug 2007 09:54:23 +0200
parents	9ad43877534d
children	3d6bfa290dbd

comparison

equal deleted inserted replaced

-:f07455f06202
+:e121b013d1f0
 static void
 x_reset_key_mapping (struct device *d)
 {
 Display *display = DEVICE_X_DISPLAY (d);
 struct x_device *xd = DEVICE_X_DATA (d);
-int max_code;
 if (xd->x_keysym_map)
 XFree ((char *) xd->x_keysym_map);
-XDisplayKeycodes (display, &xd->x_keysym_map_min_code,
+XDisplayKeycodes (display,
-		    &max_code);
+		    &xd->x_keysym_map_min_code,
-xd->x_keysym_map =
+		    &xd->x_keysym_map_max_code);
-XGetKeyboardMapping (display, xd->x_keysym_map_min_code,
+xd->x_keysym_map = XGetKeyboardMapping (display,
-			 max_code - xd->x_keysym_map_min_code + 1,
+					  xd->x_keysym_map_min_code,
-			 &xd->x_keysym_map_keysyms_per_code);
+					  xd->x_keysym_map_max_code -
+					  xd->x_keysym_map_min_code + 1,
+					  &xd->x_keysym_map_keysyms_per_code);
 }
 static CONST char *
 index_to_name (int indice)
 {
 switch (indice)
 {
 case ShiftMapIndex:   return "ModShift";
 case LockMapIndex:    return "ModLock";
 case ControlMapIndex: return "ModControl";
 case Mod1MapIndex:    return "Mod1";
 case Mod2MapIndex:    return "Mod2";
 case Mod3MapIndex:    return "Mod3";
 case Mod4MapIndex:    return "Mod4";
 static int
 x_key_is_modifier_p (KeyCode keycode, struct device *d)
 {
 struct x_device *xd = DEVICE_X_DATA (d);
-KeySym *syms = &xd->x_keysym_map [(keycode - xd->x_keysym_map_min_code) *
+KeySym *syms;
-				    xd->x_keysym_map_keysyms_per_code];
 int i;
+if (keycode < xd->x_keysym_map_min_code ||
+keycode > xd->x_keysym_map_max_code)
+return 0;
+syms = &xd->x_keysym_map [(keycode - xd->x_keysym_map_min_code) *
+			   xd->x_keysym_map_keysyms_per_code];
 for (i = 0; i < xd->x_keysym_map_keysyms_per_code; i++)
 if (IsModifierKey (syms [i]) ||
 	syms [i] == XK_Mode_switch) /* why doesn't IsModifierKey count this? */
 return 1;
 return 0;
 return;
 xd = DEVICE_X_DATA (d);
 keycode = ev->xkey.keycode;
 type = ev->type;
+if (keycode < xd->x_keysym_map_min_code ||
+keycode > xd->x_keysym_map_max_code)
+return;
 if (! ((type == KeyPress || type == KeyRelease) &&
 x_key_is_modifier_p (keycode, d)))
 { /* Not a modifier key */
 Bool key_event_p = (type == KeyPress || type == KeyRelease);
 if (type == KeyPress && !xd->last_downkey)
 	xd->last_downkey = keycode;
 else if (type == ButtonPress ||
 	       (type == KeyPress && xd->last_downkey &&
 		(keycode != xd->last_downkey ||
 characters, where "alphabetic" means something more than simply A-Z.
 That is, if Caps_Lock is down, typing ESC doesn't produce Shift-ESC.
 But if shift-lock is down, then it does. */
 if (xd->lock_interpretation == XK_Shift_Lock)
 return 1;
 return
 ((sym >= XK_A)        && (sym <= XK_Z))          ||
 ((sym >= XK_a)        && (sym <= XK_z))          ||
 ((sym >= XK_Agrave)   && (sym <= XK_Odiaeresis)) ||
 ((sym >= XK_agrave)   && (sym <= XK_odiaeresis)) ||
 /* called from EmacsFrame.c (actually from Xt itself) when a
 MappingNotify event is received.  In its infinite wisdom, Xt
 decided that Xt event handlers never get MappingNotify events.
 O'Reilly Xt Programming Manual 9.1.2 says:
 MappingNotify is automatically handled by Xt, so it isn't passed
 to event handlers and you don't need to worry about it.
 Of course, we DO worry about it, so we need a special translation. */
 void
 	  return KEYSYM (buf);
 	}
 /* If it's got a one-character name, that's good enough. */
 if (!name[1])
 	return make_char (name[0]);
 /* If it's in the "Keyboard" character set, downcase it.
 	 The case of those keysyms is too totally random for us to
 	 force anyone to remember them.
 	 The case of the other character sets is significant, however.
 	 */
 print_status_when (XLookupKeySym);
 print_status_when (XLookupBoth);
 print_status_when (XLookupChars);
 print_status_when (XLookupNone);
 print_status_when (XBufferOverflow);
 if (status == XLookupKeySym || status == XLookupBoth)
 	stderr_out (" keysym=%s",  XKeysymToString (keysym));
 if (status == XLookupChars  || status == XLookupBoth)
 	{
 	  if (len != 1)
 /* ### Use Fget_coding_system (Vcomposed_input_coding_system) */
 instream =
 	  make_decoding_input_stream (XLSTREAM (instream),
 				      Fget_coding_system (Qautomatic_conversion));
 while ((ch = Lstream_get_emchar (XLSTREAM (instream))) != EOF)
 {
 Lisp_Object emacs_event = Fmake_event ();
 XEVENT (emacs_event)->channel	      = DEVICE_CONSOLE (d);
 XEVENT (emacs_event)->event_type	      = key_press_event;
 	DEVICE_X_MOUSE_TIMESTAMP (d) =
 	  DEVICE_X_GLOBAL_MOUSE_TIMESTAMP (d) =
 	  key_event_p ? x_event->xkey.time : x_event->xbutton.time;
 	x_handle_sticky_modifiers (x_event, d);
 	if (*state & ControlMask)    modifiers |= MOD_CONTROL;
 	if (*state & xd->MetaMask)   modifiers |= MOD_META;
 	if (*state & xd->SuperMask)  modifiers |= MOD_SUPER;
 	if (*state & xd->HyperMask)  modifiers |= MOD_HYPER;
 	if (*state & xd->AltMask)    modifiers |= MOD_ALT;
 	    /* This used to compute the frame from the given X window and
 	       store it here, but we really don't care about the frame. */
 	    emacs_event->channel = DEVICE_CONSOLE (d);
 	    keysym = x_to_emacs_keysym (&x_event->xkey, 0);
 	    /* If the emacs keysym is nil, then that means that the
 	       X keysym was NoSymbol, which probably means that
 	       we're in the midst of reading a Multi_key sequence,
-	       or a "dead" key prefix.  Ignore it. */
+	       or a "dead" key prefix, or XIM input.  Ignore it. */
 	    if (NILP (keysym))
 	      return 0;
 	    /* More Caps_Lock garbage: Caps_Lock should *only* add the
 	       shift modifier to two-case keys (that is, A-Z and
 	    XButtonEvent *ev = &x_event->xbutton;
 	    struct frame *frame = x_window_to_frame (d, ev->window);
 	    if (! frame)
 	      return 0;	/* not for us */
 	    XSETFRAME (emacs_event->channel, frame);
 	    emacs_event->event_type = (x_event->type == ButtonPress) ?
 	      button_press_event : button_release_event;
 	    emacs_event->event.button.modifiers = modifiers;
 	    emacs_event->timestamp		= ev->time;
 	    emacs_event->event.button.button	= ev->button;
 	    emacs_event->event.button.x		= ev->x;
 	    emacs_event->event.button.y		= ev->y;
 	  }
 }
 break;
 case MotionNotify:
 {
 XMotionEvent *ev = &x_event->xmotion;
 struct frame *frame = x_window_to_frame (d, ev->window);
 unsigned int modifiers = 0;
 XMotionEvent event2;
 if (! frame)
 return 0; /* not for us */
 /* We use MotionHintMask, so we will get only one motion event
 until the next time we call XQueryPointer or the user
 clicks the mouse.  So call XQueryPointer now (meaning that
 the event will be in sync with the server just before
 Fnext_event() returns).  If the mouse is still in motion,
 &event2.root,   &event2.subwindow,
 &event2.x_root, &event2.y_root,
 &event2.x,      &event2.y,
 &event2.state))
 ev = &event2; /* only one structure copy */
 DEVICE_X_MOUSE_TIMESTAMP (d) = ev->time;
 XSETFRAME (emacs_event->channel, frame);
 emacs_event->event_type	    = pointer_motion_event;
 emacs_event->timestamp      = ev->time;
 /* Currently ignores Shift_Lock but probably shouldn't
 (but it definitely should ignore Caps_Lock). */
 emacs_event->event.motion.modifiers = modifiers;
 }
 break;
 case ClientMessage:
 {
 /* Patch bogus TAKE_FOCUS messages from MWM; CurrentTime is
 passed as the timestamp of the TAKE_FOCUS, which the ICCCM
 explicitly prohibits. */
 {
 ev->data.l[1] = DEVICE_X_LAST_SERVER_TIMESTAMP (d);
 }
 }
 /* fall through */
 default: /* it's a magic event */
 {
 struct frame *frame;
 Window w;
+	size_t event_size;
+	XEvent *x_event_copy = &emacs_event->event.magic.underlying_x_event;
+#define FROB(event_member, window_member) \
+	x_event_copy->event_member = x_event->event_member; \
+	w = x_event->event_member.window_member
 switch (x_event->type)
 {
-/* Note: the number of cases could be reduced to two or
+	  case SelectionRequest: FROB(xselectionrequest, owner);  break;
-three by using xany.window, but it's perhaps clearer
+	  case SelectionClear:	 FROB(xselectionclear, window);	  break;
-and potentially more robust this way */
+	  case SelectionNotify:	 FROB(xselection, requestor);	  break;
-case SelectionRequest: w = x_event->xselectionrequest.owner; break;
+	  case PropertyNotify:	 FROB(xproperty, window);	  break;
-case SelectionClear:   w = x_event->xselectionclear.window;  break;
+	  case ClientMessage:	 FROB(xclient, window);		  break;
-case SelectionNotify:  w = x_event->xselection.requestor;    break;
+	  case ConfigureNotify:	 FROB(xconfigure, window);	  break;
-case PropertyNotify:   w = x_event->xproperty.window;        break;
+	  case Expose:
-case ClientMessage:    w = x_event->xclient.window;          break;
+	  case GraphicsExpose:	 FROB(xexpose, window);		  break;
-case ConfigureNotify:  w = x_event->xconfigure.window;       break;
+	  case MapNotify:
-case Expose:
+	  case UnmapNotify:	 FROB(xmap, window);		  break;
-case GraphicsExpose:   w = x_event->xexpose.window;          break;
+	  case EnterNotify:
-case MapNotify:
+	  case LeaveNotify:	 FROB(xcrossing, window);	  break;
-case UnmapNotify:      w = x_event->xmap.window;             break;
+	  case FocusIn:
-case EnterNotify:
+	  case FocusOut:	 FROB(xfocus, window);		  break;
-case LeaveNotify:      w = x_event->xcrossing.window;        break;
+	  case VisibilityNotify: FROB(xvisibility, window);	  break;
-case FocusIn:
+default:
-case FocusOut:         w = x_event->xfocus.window;           break;
+	    w = x_event->xany.window;
-case VisibilityNotify: w = x_event->xvisibility.window;      break;
+	    *x_event_copy = *x_event;
-default:               w = x_event->xany.window;             break;
+	    break;
 }
+#undef FROB
 frame = x_any_window_to_frame (d, w);
 if (!frame)
 return 0;
 emacs_event->event_type = magic_event;
 XSETFRAME (emacs_event->channel, frame);
-emacs_event->event.magic.underlying_x_event = *x_event;
 break;
 }
 }
 return 1;
 }
 */
 {
 Lisp_Object frm;
 Lisp_Object conser;
 struct gcpro gcpro1;
 XSETFRAME (frm, f);
 conser = Fcons (frm, Fcons (FRAME_DEVICE (f), in_p ? Qt : Qnil));
 GCPRO1 (conser);
 emacs_handle_focus_change_preliminary (conser);
 enqueue_magic_eval_event (emacs_handle_focus_change_final,
 {
 /*
 * It's curious that we're using x_any_window_to_frame() instead
 * of x_window_to_frame().  I don't know what the impact of this is.
 */
 struct frame *f =
 x_any_window_to_frame (get_device_from_display (event->xany.display),
 			   event->xfocus.window);
 if (!f)
 /* focus events are sometimes generated just before
 va_run_hook_with_args (Qmap_frame_hook, 1, frame);
 #ifdef EPOCH
 dispatch_epoch_event (f, event, Qx_map);
 #endif
 }
 else if (FRAME_VISIBLE_P (f) && !is_visible)
 {
 FRAME_VISIBLE_P (f) = 0;
 va_run_hook_with_args (Qunmap_frame_hook, 1, frame);
 #ifdef EPOCH
 dispatch_epoch_event (f, event, Qx_unmap);
 	   event->xclient.data.l[0] == DEVICE_XATOM_WM_TAKE_FOCUS (d))
 {
 handle_focus_event_1 (f, 1);
 #if 0
 /* If there is a dialog box up, focus on it.
 	 #### Actually, we're raising it too, which is wrong.  We should
 	 #### just focus on it, but lwlib doesn't currently give us an
 	 #### easy way to do that.  This should be fixed.
 	 */
 unsigned long take_focus_timestamp = event->xclient.data.l[1];
 static void
 emacs_Xt_handle_magic_event (struct Lisp_Event *emacs_event)
 {
 /* This function can GC */
-XEvent *event = (XEvent *) &emacs_event->event.magic.underlying_x_event;
+XEvent *event = &emacs_event->event.magic.underlying_x_event;
 struct frame *f = XFRAME (EVENT_CHANNEL (emacs_event));
 if (!FRAME_LIVE_P (f))
 return;
 switch (event->type)
 {
 case SelectionRequest:
 x_handle_selection_request (&event->xselectionrequest);
 break;
 case SelectionClear:
 x_handle_selection_clear (&event->xselectionclear);
 break;
 case SelectionNotify:
 x_handle_selection_notify (&event->xselection);
 break;
 case PropertyNotify:
 x_handle_property_notify (&event->xproperty);
 #ifdef EPOCH
 dispatch_epoch_event (f, event, Qx_property_change);
 #endif
 break;
 case Expose:
 x_redraw_exposed_area (f, event->xexpose.x, event->xexpose.y,
 			     event->xexpose.width, event->xexpose.height);
 break;
 case GraphicsExpose: /* This occurs when an XCopyArea's source area was
 			    obscured or not available. */
 x_redraw_exposed_area (f, event->xexpose.x, event->xexpose.y,
 			     event->xexpose.width, event->xexpose.height);
 break;
 case MapNotify:
 case UnmapNotify:
 handle_map_event (f, event);
 break;
 case EnterNotify:
 if (event->xcrossing.detail != NotifyInferior)
 	{
 	  Lisp_Object frame;
 	  XSETFRAME (frame, f);
 	  /* FRAME_X_MOUSE_P (f) = 1; */
 	  va_run_hook_with_args (Qmouse_enter_frame_hook, 1, frame);
 	}
 break;
 case LeaveNotify:
 if (event->xcrossing.detail != NotifyInferior)
 	{
 	  Lisp_Object frame;
 	  XSETFRAME (frame, f);
 	  /* FRAME_X_MOUSE_P (f) = 0; */
 	  va_run_hook_with_args (Qmouse_leave_frame_hook, 1, frame);
 	}
 break;
 case FocusIn:
 case FocusOut:
 #ifdef EXTERNAL_WIDGET
 /* External widget lossage: Ben said:
 	 YUCK.  The only way to make focus changes work properly is to
 if (FRAME_X_EXTERNAL_WINDOW_P (f))
 	break;
 #endif
 handle_focus_event_1 (f, event->type == FocusIn);
 break;
 case ClientMessage:
 handle_client_message (f, event);
 break;
 case VisibilityNotify: /* window visiblity has changed */
 if (event->xvisibility.window == XtWindow (FRAME_X_SHELL_WIDGET (f)))
 	{
 	  FRAME_X_TOTALLY_VISIBLE_P (f) =
 	    (event->xvisibility.state == VisibilityUnobscured);
 	  /* Note that the fvwm pager only sends VisibilityNotify when
 	     changing pages. Is this all we need to do ? JV */
 	  /* Nope.  We must at least trigger a redisplay here.
 	     Since this case seems similar to MapNotify, I've
 	     factored out some code to change_frame_visibility().
 	     This triggers the necessary redisplay and runs
 	     (un)map-frame-hook.  - dkindred@cs.cmu.edu */
 	  /* Changed it again to support the tristate visibility flag */
 	  change_frame_visibility (f, (event->xvisibility.state
 				       != VisibilityFullyObscured) ? 1 : -1);
 	}
 break;
 case ConfigureNotify:
 #ifdef HAVE_XIM
 XIM_SetGeometry (f);
 #endif
 #if 0
 	 for the tty fd when there's really only input available
 	 on some process's fd.	(It will subsequently get called
 	 for that process's fd, so returning without setting any
 	 flags will take care of it.)  To see the problem, uncomment
 	 the stderr_out below, turn NORMAL_QUIT_CHECK_TIMEOUT_MSECS
 	 down to 25, do sh -c 'xemacs -nw -q -f shell 2>/tmp/log'
 	 and press return repeatedly.  (Seen under AIX & Linux.)
 	 -dkindred@cs.cmu.edu */
 if (!poll_fds_for_input (temp_mask))
 	{
 #if 0
 	  stderr_out ("mark_what_as_being_ready: no input available (fd=%d)\n",
 		      closure->fd);
 #endif
 assert (!filedesc_to_what_closure[fd]);
 closure = (struct what_is_ready_closure *) xmalloc (sizeof (*closure));
 closure->fd = fd;
 closure->what = what;
 closure->id =
 XtAppAddInput (Xt_app_con, fd,
 		   (XtPointer) (XtInputReadMask /* | XtInputExceptMask */),
 		   Xt_what_callback, closure);
 filedesc_to_what_closure[fd] = closure;
 }
 }
 static void
 emacs_Xt_select_process (struct Lisp_Process *p)
 {
-int infd;
 Lisp_Object process;
+int infd = event_stream_unixoid_select_process (p);
-infd = event_stream_unixoid_select_process (p);
 XSETPROCESS (process, p);
 select_filedesc (infd, process);
 }
 static void
 emacs_Xt_unselect_process (struct Lisp_Process *p)
 {
-int infd;
+int infd = event_stream_unixoid_unselect_process (p);
-infd = event_stream_unixoid_unselect_process (p);
 unselect_filedesc (infd);
 }
 /* This is called from GC when a process object is about to be freed.
 select_filedesc (infd, console);
 #ifdef HAVE_GPM
 /* On a stream device (ie: noninteractive), bad things can happen. */
 if (EQ (CONSOLE_TYPE (con), Qtty)) {
 mousefd = CONSOLE_TTY_MOUSE_FD (con);
-if (mousefd >= 0) {
+	/* We check filedesc_to_what_closure[fd] here because if you run
+	** XEmacs from a TTY, it will fire up GPM, select the mouse fd, then
+	** if you run gnuattach to connect to another TTY, it will fire up
+	** GPM again, and try to reselect the mouse fd.  GPM uses the same
+	** fd for every connection apparently, and select_filedesc will
+	** fail its assertion if we try to select it twice.
+	*/
+if ((mousefd >= 0) && !filedesc_to_what_closure[mousefd]) {
 select_filedesc (mousefd, console);
 }
 }
 #endif
 }
 	describe_event_window (ev->window, ev->display);
 	stderr_out ("     mode: %s\n",   XEvent_mode_to_string  (ev->mode));
 	stderr_out ("     detail: %s\n", XEvent_detail_to_string(ev->detail));
 	break;
 }
 case KeyPress:
 {
 	XKeyEvent *ev = &event->xkey;
 	unsigned int state = ev->state;
 	describe_event_window (ev->window, ev->display);
 	stderr_out ("   subwindow: %ld\n", ev->subwindow);
 	stderr_out ("   state: ");
 	/* Complete list of modifier key masks */
 	if (state & ShiftMask)   stderr_out ("Shift ");
 	if (state & Mod1Mask)    stderr_out ("Mod1 ");
 	if (state & Mod2Mask)    stderr_out ("Mod2 ");
 	if (state & Mod3Mask)    stderr_out ("Mod3 ");
 	if (state & Mod4Mask)    stderr_out ("Mod4 ");
 	if (state & Mod5Mask)    stderr_out ("Mod5 ");
 	if (! state)
 	  stderr_out ("vanilla\n");
 	else
 	  stderr_out ("\n");
 	if (x_key_is_modifier_p (ev->keycode, d))
 	  stderr_out ("   Modifier key");
 	stderr_out ("   keycode: 0x%x\n", ev->keycode);
 }
 break;
 case Expose:
 if (x_debug_events > 1)
 	{
 	  XExposeEvent *ev = &event->xexpose;
 	  describe_event_window (ev->window, ev->display);
 	  stderr_out ("    count: %d\n", ev->count);
 	}
 else
 	stderr_out ("\n");
 break;
 case GraphicsExpose:
 if (x_debug_events > 1)
 	{
 	  XGraphicsExposeEvent *ev = &event->xgraphicsexpose;
 	  describe_event_window (ev->drawable, ev->display);
 	  stderr_out ("    count: %d\n", ev->count);
 	}
 else
 	stderr_out ("\n");
 break;
 case EnterNotify:
 case LeaveNotify:
 if (x_debug_events > 1)
 	{
 	  XCrossingEvent *ev = &event->xcrossing;
 	  stderr_out("    state: %s\n", XEvent_visibility_to_string(ev->state));
 	}
 else
 	stderr_out ("\n");
 break;
 case ClientMessage:
 {
 	XClientMessageEvent *ev = &event->xclient;
 	char *name = XGetAtomName (ev->display, ev->message_type);
 	stderr_out ("%s", name);
 	}
 	XFree (name);
 	stderr_out ("\n");
 	break;
 }
 default:
 stderr_out ("\n");
 break;
 }
 void
 signal_special_Xt_user_event (Lisp_Object channel, Lisp_Object function,
 			      Lisp_Object object)
 {
-Lisp_Object event;
+Lisp_Object event = Fmake_event ();
-event = Fmake_event ();
 XEVENT (event)->event_type = misc_user_event;
 XEVENT (event)->channel = channel;
 XEVENT (event)->event.eval.function = function;
 XEVENT (event)->event.eval.object = object;
 enqueue_Xt_dispatch_event (event);
 }
 static void
 emacs_Xt_next_event (struct Lisp_Event *emacs_event)
 {
 we_didnt_get_an_event:
 }
 else if (completed_timeouts)
 Xt_timeout_to_emacs_event (emacs_event);
 else if (fake_event_occurred)
 {
-/* A dummy event, so that a cycle of the command loop will
+/* A dummy event, so that a cycle of the command loop will occur. */
-	 occur. */
 fake_event_occurred = 0;
 /* eval events have nil as channel */
 emacs_event->event_type = eval_event;
 emacs_event->event.eval.function = Qidentity;
 emacs_event->event.eval.object = Qnil;
 	 will says "yes" in this case but there isn't really any
 	 input.  Another way of fixing this problem is for the
 	 signal_event_pipe to generate actual input in the form
 	 of an identity eval event or something. (#### maybe this
 	 actually happens?) */
 if (poll_fds_for_input (process_only_mask))
 	return 1;
 pending_value = XtAppPending (Xt_app_con);
 Colormap     colormap;
 Status       status;
 String       params[1];
 Cardinal     num_params  = 1;
 XtAppContext the_app_con = XtDisplayToApplicationContext (dpy);
 if (*num_args != 2) {
 XtAppWarningMsg(the_app_con, "wrongParameters", "cvtStringToPixel",
 "XtToolkitError",
 "String to pixel conversion needs screen and colormap arguments",
 (String *)NULL, (Cardinal *)NULL);
 &screenColor);
 if (status) {
 status = allocate_nearest_color (DisplayOfScreen(screen), colormap,
 &screenColor);
 }
 if (status == 0) {
 params[0] = str;
 /* Server returns a specific error code but Xlib discards it.  Ugh */
-if (XLookupColor(DisplayOfScreen(screen), colormap, (char*)str,
+if (XLookupColor(DisplayOfScreen(screen), colormap, (char*) str,
 &exactColor, &screenColor)) {
 XtAppWarningMsg(the_app_con, "noColormap", "cvtStringToPixel",
 "XtToolkitError",
 "Cannot allocate colormap entry for \"%s\"",
 params, &num_params);
 } else {
 XtAppWarningMsg(the_app_con, "badValue", "cvtStringToPixel",
 "XtToolkitError",
 "Color name \"%s\" is not defined", params, &num_params);
 }
 *closure_ret = False;
 return False;
 } else {
 *closure_ret = (char*)True;
 done(Pixel, screenColor.pixel);
 timeout_id_tick = 1;
 pending_timeouts = 0;
 completed_timeouts = 0;
 event_stream = Xt_event_stream;
 #if defined(HAVE_XIM) || defined(USE_XFONTSET)
 Initialize_Locale();
 #endif /* HAVE_XIM || USE_XFONTSET */
 XtToolkitInitialize ();
 Xt_app_con = XtCreateApplicationContext ();
 XtAppSetFallbackResources (Xt_app_con, (String *) x_fallback_resources);
 /* In xselect.c */
 x_selection_timeout = (XtAppGetSelectionTimeout (Xt_app_con) / 1000);
 XSetErrorHandler (x_error_handler);
 XSetIOErrorHandler (x_IO_error_handler);
 XtAppSetTypeConverter (Xt_app_con, XtRString, XtRXimStyles,
 		         EmacsXtCvtStringToXIMStyles,
 			 NULL, 0,
 			 XtCacheByDisplay, EmacsFreeXIMStyles);
 #endif /* XIM_XLIB */
 }

Mercurial > hg > xemacs-beta

comparison src/event-Xt.c @ 183:e121b013d1f0 r20-3b18