--- /dev/null
+/* External client widget.
+ Copyright (C) 1993, 1994 Sun Microsystems, Inc.
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Library General Public
+License as published by the Free Software Foundation; either
+version 2 of the License, or (at your option) any later version.
+
+This library 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
+Library General Public License for more details.
+
+You should have received a copy of the GNU Library General Public
+License along with this library; if not, write to
+the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+Boston, MA 02111-1307, USA. */
+
+/* Synched up with: Not in FSF. */
+
+/* Written by Ben Wing, September 1993. */
+
+#ifdef emacs
+
+#include <config.h>
+
+#ifndef EXTERNAL_WIDGET
+ERROR! This ought not be getting compiled if EXTERNAL_WIDGET is undefined
+#endif
+
+#endif /* emacs */
+
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#ifdef EXTW_USES_MOTIF
+# include <Xm/XmP.h>
+# include <Xm/PrimitiveP.h>
+# include <X11/keysym.h>
+#else
+# include "xintrinsicp.h"
+# include <X11/StringDefs.h>
+#endif
+
+#include "ExternalClientP.h"
+#include "extw-Xt.h"
+
+#ifdef TOOLTALK
+#include TT_C_H_PATH
+#endif
+
+/* This is the client widget, used to communicate with an ExternalShell
+ widget. */
+
+#define NOTIFY(w, type, l0, l1, l2) \
+ extw_send_notify_3(XtDisplay((Widget)(w)), XtWindow((Widget)(w)),\
+ type, l0, l1, l2)
+
+static void externalClientInitialize (Widget req, Widget new, ArgList args,
+ Cardinal *num_args);
+static void externalClientRealize (Widget widget, XtValueMask *mask,
+ XSetWindowAttributes *attrs);
+static void Destroy (Widget w);
+static void EventHandler (Widget wid, XtPointer closure, XEvent *event,
+ Boolean *continue_to_dispatch);
+static void MaskableEventHandler (Widget wid, XtPointer closure, XEvent *event,
+ Boolean *continue_to_dispatch);
+static XtGeometryResult QueryGeometry(Widget, XtWidgetGeometry *,
+ XtWidgetGeometry *);
+static void ExternalClientFocusIn (Widget, XEvent *, String *, Cardinal *);
+static void ExternalClientFocusOut (Widget, XEvent *, String *, Cardinal *);
+static void ExternalClientEnter (Widget, XEvent *, String *, Cardinal *);
+static void ExternalClientLeave (Widget, XEvent *, String *, Cardinal *);
+
+static int my_error_handler(Display *display, XErrorEvent *xev);
+static int (*error_old_handler)(Display *, XErrorEvent *);
+
+static XtResource resources[] = {
+#define offset(field) XtOffset(ExternalClientWidget, externalClient.field)
+ { XtNshellTimeout, XtCShellTimeout, XtRInt, sizeof(int),
+ offset(shell_timeout), XtRImmediate,(XtPointer)DEFAULT_WM_TIMEOUT},
+ { XtNdeadShell, XtCDeadShell, XtRBoolean, sizeof(Boolean),
+ offset(dead_shell), XtRImmediate, (XtPointer)False},
+#ifdef EXTW_USES_MOTIF
+ { XmNnavigationType, XmCNavigationType, XmRNavigationType,
+ sizeof(XmNavigationType), XtOffset(ExternalClientWidget,
+ primitive.navigation_type), XtRImmediate,
+ (XtPointer)XmTAB_GROUP},
+#endif
+ { XtNemacsProcID, XtCEmacsProcID, XtRString, sizeof(String),
+ offset(emacs_procid), XtRImmediate, (XtPointer)NULL},
+ { XtNshellReadyCallback, XtCCallback, XtRCallback, sizeof(XtCallbackList),
+ offset(shell_ready_callback), XtRImmediate, (XtPointer)NULL},
+ { XtNshellName, XtCShellName, XtRString, sizeof(String),
+ offset(shell_name), XtRImmediate, (XtPointer)NULL},
+ { XtNuseToolTalk, XtCUseToolTalk, XtRBoolean, sizeof(Boolean),
+ offset(use_tooltalk), XtRImmediate, (XtPointer)False}
+};
+
+static XtActionsRec actions[] = {
+ {"focusIn", ExternalClientFocusIn},
+ {"focusOut", ExternalClientFocusOut},
+ {"enter", ExternalClientEnter},
+ {"leave", ExternalClientLeave},
+};
+
+ExternalClientClassRec externalClientClassRec = {
+ { /*
+ * core_class fields
+ */
+#ifdef EXTW_USES_MOTIF
+ /* superclass */ (WidgetClass) &xmPrimitiveClassRec,
+#else
+ /* superclass */ (WidgetClass) &coreClassRec,
+#endif
+ /* class_name */ "ExternalClient",
+ /* size */ sizeof(ExternalClientRec),
+ /* Class Initializer */ NULL,
+ /* class_part_initialize*/ NULL, /* XtInheritClassPartInitialize, */
+ /* Class init'ed ? */ FALSE,
+ /* initialize */ externalClientInitialize,
+ /* initialize_notify */ NULL,
+ /* realize */ externalClientRealize,
+ /* actions */ actions,
+ /* num_actions */ XtNumber (actions),
+ /* resources */ resources,
+ /* resource_count */ XtNumber (resources),
+ /* xrm_class */ NULLQUARK,
+ /* compress_motion */ FALSE,
+ /* compress_exposure */ TRUE,
+ /* compress_enterleave*/ FALSE,
+ /* visible_interest */ TRUE,
+ /* destroy */ Destroy, /* XtInheritDestroy, */
+ /* resize */ XtInheritResize,
+ /* expose */ NULL,
+ /* set_values */ NULL, /* XtInheritSetValues, */
+ /* set_values_hook */ NULL,
+ /* set_values_almost */ XtInheritSetValuesAlmost,
+ /* get_values_hook */ NULL,
+ /* accept_focus */ NULL,
+ /* intrinsics version */ XtVersion,
+ /* callback offsets */ NULL,
+ /* tm_table */ "", /* MUST NOT BE NULL or
+ XtInheritTranslations in Motif!!!!!
+ Otherwise keyboard focus translations
+ will not work. */
+ /* query_geometry */ QueryGeometry,
+ /* display_accelerator*/ NULL,
+ /* extension */ NULL
+ },
+#ifdef EXTW_USES_MOTIF
+ {
+ XmInheritBorderHighlight,/* Primitive border_highlight */
+ XmInheritBorderHighlight,/* Primitive border_unhighlight */
+ XtInheritTranslations, /* translations */
+ NULL, /* arm_and_activate */
+ NULL, /* get resources */
+ 0, /* num get_resources */
+ NULL, /* extension */
+ },
+#endif
+ {
+ 0
+ }
+};
+
+WidgetClass externalClientWidgetClass = (WidgetClass) &externalClientClassRec;
+
+static void
+externalClientInitialize (Widget req, Widget new, ArgList args,
+ Cardinal *num_args)
+{
+ ExternalClientWidget ecw = (ExternalClientWidget) new;
+ static int error_handler_added = 0;
+
+ extw_initialize_atoms (XtDisplay (new));
+ extw_which_side = extw_client_send;
+
+#ifdef EXTW_USES_MOTIF
+
+ /* yes I know this is horrible. However, the XmPrimitive class adds
+ the Tab translation in its initialization routine, so we have to
+ override it here. This is all the fault of Xt, which doesn't
+ provide a proper inheritance mechanism for translations.
+
+ -- BPW
+
+ */
+
+ XtOverrideTranslations (new,
+ XtParseTranslationTable ("None<Key>Tab:\n"
+ "<FocusIn>:focusIn()\n"
+ "<FocusOut>:focusOut()\n"
+ "<Enter>:enter()\n"
+ "<Leave>:leave()\n"));
+
+#endif
+
+ XtAddEventHandler (new, 0, TRUE, EventHandler, (XtPointer) NULL);
+
+ ecw->externalClient.shell_ready = False;
+ ecw->externalClient.has_focus = False;
+
+ if (!error_handler_added)
+ {
+ error_handler_added = 1;
+ error_old_handler = XSetErrorHandler (my_error_handler);
+ }
+}
+
+
+#ifdef TOOLTALK
+static Tt_callback_action
+tt_callback(Tt_message m, Tt_pattern p)
+{
+ ExternalClientWidget ecw = (ExternalClientWidget)tt_message_user (m, 0);
+
+ switch (tt_message_state(m))
+ {
+ case TT_FAILED:
+ /* handle errors here */
+ break;
+ case TT_HANDLED:
+ ecw->externalClient.shell_name = tt_message_arg_val (m, 2);
+ XtCallCallbackList ((Widget) ecw,
+ ecw->externalClient.shell_ready_callback, NULL);
+ break;
+ }
+
+ tt_message_destroy (m);
+ return TT_CALLBACK_PROCESSED;
+}
+
+static void
+send_tooltalk_handshake (ExternalClientWidget ecw, Window win, char *name)
+{
+ Tt_message m = tt_message_create ();
+
+ tt_message_op_set (m, "emacs-make-client-screen");
+ tt_message_scope_set (m, TT_SESSION);
+ tt_message_class_set (m, TT_REQUEST);
+ tt_message_arg_add (m, TT_IN, "string", name);
+ tt_message_iarg_add (m, TT_IN, "int", win);
+ tt_message_arg_add (m, TT_OUT, "string", NULL);
+ tt_message_user_set (m, 0, (void *)ecw);
+ tt_message_callback_add (m, tt_callback);
+ if (ecw->externalClient.emacs_procid)
+ {
+ tt_message_address_set (m, TT_HANDLER);
+ tt_message_handler_set (m, ecw->externalClient.emacs_procid);
+ }
+ else
+ tt_message_address_set (m, TT_PROCEDURE);
+ tt_message_send (m);
+}
+
+#endif
+
+
+static void
+externalClientRealize (Widget w, XtValueMask *vm, XSetWindowAttributes *attrs)
+{
+ ExternalClientWidget ecw = (ExternalClientWidget)w;
+
+#ifdef EXTW_USES_MOTIF
+ (*xmPrimitiveWidgetClass->core_class.realize) (w, vm, attrs);
+#else
+ (*coreWidgetClass->core_class.realize) (w, vm, attrs);
+#endif
+
+#ifdef TOOLTALK
+
+ /* Make sure that the server actually knows about this window id before
+ * telling Emacs about it.
+ */
+ if (ecw->externalClient.use_tooltalk)
+ {
+ XSync (XtDisplay (w), False);
+ send_tooltalk_handshake (ecw, XtWindow (w), XtName (w));
+ }
+#endif
+}
+
+
+/***********************************************************************/
+
+/* window-to-widget list. */
+
+struct ww_list
+{
+ Window win;
+ Widget wid;
+ struct ww_list *next;
+};
+
+struct ww_list ww_list[1];
+
+static int
+add_ww (Window win, Widget wid)
+{
+ struct ww_list *ww = (struct ww_list *) malloc (sizeof (struct
+ ww_list));
+ if (!ww)
+ return 0;
+ ww->win = win;
+ ww->wid = wid;
+ ww->next = ww_list->next;
+ ww_list->next = ww;
+ return 1;
+}
+
+static Widget
+remove_ww (Window win)
+{
+ struct ww_list *w1, *w2;
+ Widget wid = 0;
+
+ for (w1=ww_list, w2=w1->next; w2; w1=w2, w2=w2->next)
+ if (w2->win == win)
+ {
+ w1->next = w2->next;
+ wid = w2->wid;
+ free (w2);
+ break;
+ }
+ return wid;
+}
+
+/***********************************************************************/
+
+/* stolen outright from Intrinsic.c */
+
+static void ComputeWindowAttributes(widget,value_mask,values)
+ Widget widget;
+ XtValueMask *value_mask;
+ XSetWindowAttributes *values;
+{
+ *value_mask = CWEventMask | CWColormap;
+ (*values).event_mask = XtBuildEventMask(widget);
+ (*values).colormap = widget->core.colormap;
+ if (widget->core.background_pixmap != XtUnspecifiedPixmap) {
+ *value_mask |= CWBackPixmap;
+ (*values).background_pixmap = widget->core.background_pixmap;
+ } else {
+ *value_mask |= CWBackPixel;
+ (*values).background_pixel = widget->core.background_pixel;
+ }
+ if (widget->core.border_pixmap != XtUnspecifiedPixmap) {
+ *value_mask |= CWBorderPixmap;
+ (*values).border_pixmap = widget->core.border_pixmap;
+ } else {
+ *value_mask |= CWBorderPixel;
+ (*values).border_pixel = widget->core.border_pixel;
+ }
+ if (widget->core.widget_class->core_class.expose == (XtExposeProc) NULL) {
+ /* Try to avoid redisplay upon resize by making bit_gravity the same
+ as the default win_gravity */
+ *value_mask |= CWBitGravity;
+ (*values).bit_gravity = NorthWestGravity;
+ }
+} /* ComputeWindowAttributes */
+
+static void
+end_connection (ExternalClientWidget w)
+{
+ XSetWindowAttributes xswa;
+ XtValueMask mask;
+ Widget wid = (Widget) w;
+
+ w->externalClient.shell_ready = False;
+ XtRemoveEventHandler (wid, w->externalClient.event_mask,
+ FALSE, MaskableEventHandler, (XtPointer) NULL);
+ ComputeWindowAttributes (wid, &mask, &xswa);
+ XChangeWindowAttributes (XtDisplay (wid), XtWindow (wid), mask, &xswa);
+ XClearArea (XtDisplay (wid), XtWindow (wid), 0, 0, 0, 0, True);
+}
+
+static int
+my_error_handler (Display *display, XErrorEvent *xev)
+{
+ Widget wid;
+
+ if (xev->error_code != BadWindow)
+ goto call_old;
+ wid = remove_ww (xev->resourceid);
+ if (wid)
+ {
+ end_connection ((ExternalClientWidget) wid);
+ return 0;
+ }
+
+ call_old:
+ return error_old_handler (display, xev);
+}
+
+static void
+MaskableEventHandler (Widget wid, XtPointer closure, XEvent *event,
+ Boolean *continue_to_dispatch)
+ /* closure and continue_to_dispatch unused */
+{
+ ExternalClientWidget w = (ExternalClientWidget) wid;
+
+ if (w->externalClient.shell_ready)
+ {
+ if (event->type == KeyPress || event->type == KeyRelease ||
+ event->type == ButtonPress || event->type == ButtonRelease ||
+ event->type == MotionNotify)
+ event->xkey.subwindow = 0;
+#ifdef EXTW_USES_MOTIF
+ /* hackkkkkkkkkkkkkk! Suppress CTRL-TAB, SHIFT-TAB, etc. so that
+ Emacs doesn't attempt to interpret focus-change keystrokes. */
+ if (event->type == KeyPress &&
+ XLookupKeysym ((XKeyEvent *) event, 0) == XK_Tab &&
+ (event->xkey.state & ControlMask ||
+ event->xkey.state & ShiftMask))
+ return;
+#endif
+ event->xany.window = w->core.window;
+ XSendEvent (XtDisplay (wid), w->externalClient.event_window, FALSE, 0,
+ event);
+ XSync (XtDisplay (wid), 0); /* make sure that any BadWindow errors
+ (meaning the server died) get handled
+ before XSendEvent is called again. */
+
+ }
+}
+
+static void
+EventHandler (Widget wid, XtPointer closure, XEvent *event,
+ Boolean *continue_to_dispatch)
+ /* closure and continue_to_dispatch unused */
+{
+ ExternalClientWidget w = (ExternalClientWidget) wid;
+
+ if (w->core.window != event->xany.window)
+ {
+ XtAppErrorMsg (XtWidgetToApplicationContext (wid),
+ "invalidWindow","eventHandler",XtCXtToolkitError,
+ "Event with wrong window",
+ (String *)NULL, (Cardinal *)NULL);
+ return;
+ }
+
+ if (event->type == ClientMessage &&
+ event->xclient.message_type == a_EXTW_NOTIFY &&
+ event->xclient.data.l[0] == extw_shell_send)
+ switch (event->xclient.data.l[1])
+ {
+
+ case extw_notify_qg:
+ /* shell is alive again. */
+
+ w->externalClient.dead_shell = False;
+ break;
+
+ case extw_notify_gm:
+ {
+ XtWidgetGeometry xwg, xwg_return;
+ XtGeometryResult result;
+
+ extw_get_geometry_value (XtDisplay (wid), XtWindow (wid),
+ a_EXTW_GEOMETRY_MANAGER, &xwg);
+ result = XtMakeGeometryRequest (wid, &xwg, &xwg_return);
+
+ extw_send_geometry_value (XtDisplay (wid), XtWindow (wid),
+ a_EXTW_GEOMETRY_MANAGER, extw_notify_gm,
+ result == XtGeometryAlmost ? &xwg_return :
+ NULL, result);
+ break;
+ }
+
+ case extw_notify_init:
+ w->externalClient.shell_ready = True;
+ w->externalClient.event_window = event->xclient.data.l[2];
+ w->externalClient.event_mask = event->xclient.data.l[3];
+ add_ww (w->externalClient.event_window, (Widget) w);
+
+ XtAddEventHandler (wid, w->externalClient.event_mask,
+ FALSE, MaskableEventHandler, (XtPointer) NULL);
+#ifdef EXTW_USES_MOTIF
+ NOTIFY (w, extw_notify_init,
+ EXTW_TYPE_MOTIF,
+ 0, 0);
+#else
+ NOTIFY (w, extw_notify_init,
+ EXTW_TYPE_XT,
+ 0, 0);
+#endif
+ break;
+
+ case extw_notify_end:
+ end_connection (w);
+ remove_ww (w->externalClient.event_window);
+ break;
+
+ case extw_notify_set_focus:
+#ifdef EXTW_USES_MOTIF
+ XmProcessTraversal (wid, XmTRAVERSE_CURRENT);
+#else
+ XtSetKeyboardFocus (wid, None);
+#endif
+ break;
+
+ }
+}
+
+static void Destroy(wid)
+ Widget wid;
+{
+ ExternalClientWidget w = (ExternalClientWidget)wid;
+
+ NOTIFY(w, extw_notify_end, 0, 0, 0);
+}
+
+static XtGeometryResult QueryGeometry(gw, request, reply)
+ Widget gw;
+ XtWidgetGeometry *request, *reply;
+{
+ ExternalClientWidget w = (ExternalClientWidget)gw;
+ XEvent event;
+ unsigned long request_num;
+ Display *display = XtDisplay(gw);
+ XtWidgetGeometry req = *request; /* don't modify caller's structure */
+
+ if (!XtIsRealized((Widget)w) || !w->externalClient.shell_ready)
+ return XtGeometryYes;
+
+ if (w->externalClient.dead_shell == TRUE)
+ /* The shell is sick. */
+ return XtGeometryNo;
+
+ req.sibling = None;
+ req.request_mode &= ~CWSibling;
+ request_num = NextRequest(display);
+ extw_send_geometry_value(XtDisplay(gw), XtWindow(gw), a_EXTW_QUERY_GEOMETRY,
+ extw_notify_qg, &req, 0);
+
+ if (extw_wait_for_response(gw, &event, request_num, extw_notify_qg,
+ w->externalClient.shell_timeout)) {
+ XtGeometryResult result = (XtGeometryResult) event.xclient.data.l[0];
+
+ if (result == XtGeometryAlmost) {
+ extw_get_geometry_value(XtDisplay(gw), XtWindow(gw),
+ a_EXTW_QUERY_GEOMETRY, reply);
+ }
+ return result;
+ } else {
+ w->externalClient.dead_shell = TRUE; /* timed out; must be broken */
+ return XtGeometryNo;
+ }
+}
+
+static void ExternalClientFocusIn (Widget w, XEvent *event, String *params,
+ Cardinal *num_params)
+{
+ ExternalClientWidget ecw = (ExternalClientWidget) w;
+
+ if (event->xfocus.send_event && !ecw->externalClient.has_focus) {
+ ecw->externalClient.has_focus = True;
+ NOTIFY(ecw, extw_notify_focus_in, 0, 0, 0);
+ }
+#ifdef EXTW_USES_MOTIF
+ _XmPrimitiveFocusIn (w, event, params, num_params);
+#endif
+}
+
+static void ExternalClientFocusOut (Widget w, XEvent *event, String *params,
+ Cardinal *num_params)
+{
+ ExternalClientWidget ecw = (ExternalClientWidget) w;
+
+ if (event->xfocus.send_event && ecw->externalClient.has_focus) {
+ ecw->externalClient.has_focus = False;
+ NOTIFY(ecw, extw_notify_focus_out, 0, 0, 0);
+ }
+#ifdef EXTW_USES_MOTIF
+ _XmPrimitiveFocusOut(w, event, params, num_params);
+#endif
+}
+
+static void ExternalClientEnter (Widget w, XEvent *event, String *params,
+ Cardinal *num_params)
+{
+ ExternalClientWidget ecw = (ExternalClientWidget) w;
+
+ if (
+#ifdef EXTW_USES_MOTIF
+ _XmGetFocusPolicy (w) != XmEXPLICIT &&
+#endif
+ !ecw->externalClient.has_focus &&
+ event->xcrossing.focus && event->xcrossing.detail != NotifyInferior) {
+ ecw->externalClient.has_focus = True;
+ NOTIFY(ecw, extw_notify_focus_in, 0, 0, 0);
+ }
+#ifdef EXTW_USES_MOTIF
+ _XmPrimitiveEnter (w, event, params, num_params);
+#endif
+}
+
+static void ExternalClientLeave (Widget w, XEvent *event, String *params,
+ Cardinal *num_params)
+{
+ ExternalClientWidget ecw = (ExternalClientWidget) w;
+
+ if (
+#ifdef EXTW_USES_MOTIF
+ _XmGetFocusPolicy (w) != XmEXPLICIT &&
+#endif
+ ecw->externalClient.has_focus &&
+ event->xcrossing.focus && event->xcrossing.detail != NotifyInferior) {
+ ecw->externalClient.has_focus = False;
+ NOTIFY(ecw, extw_notify_focus_out, 0, 0, 0);
+ }
+#ifdef EXTW_USES_MOTIF
+ _XmPrimitiveLeave (w, event, params, num_params);
+#endif
+}
projects / chise / xemacs-chise.git / blobdiff