lwlib/lwlib-Xlw.c

   1 /* The lwlib interface to "xlwmenu" menus.
   2    Copyright (C) 1992 Lucid, Inc.
   3
   4 This file is part of the Lucid Widget Library.
   5
   6 The Lucid Widget Library is free software; you can redistribute it and/or
   7 modify it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 1, or (at your option)
   9 any later version.
  10
  11 The Lucid Widget Library is distributed in the hope that it will be useful,
  12 but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 GNU General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GNU Emacs; see the file COPYING.  If not, write to
  18 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  19 Boston, MA 02111-1307, USA.  */
  20
  21 #ifdef HAVE_CONFIG_H
  22 #include <config.h>
  23 #endif
  24
  25 #include "lwlib-Xlw.h"
  26 #include <X11/StringDefs.h>
  27 #include <X11/IntrinsicP.h>
  28 #include <X11/ObjectP.h>
  29 #include <X11/CompositeP.h>
  30 #include <X11/Shell.h>
  31 #include "xlwmenu.h"
  32
  33 \f/* Menu callbacks */
  34
  35 /* Callback XtNhighlightCallback for Lucid menus.  W is the menu
  36    widget, CLIENT_DATA contains a pointer to the widget_instance
  37    for the menu, CALL_DATA contains a pointer to the widget_value
  38    structure for the highlighted menu item.  The latter may be null
  39    if there isn't any highlighted menu item.  */
  40
  41 static void
  42 highlight_hook (w, client_data, call_data)
  43      Widget w;
  44      XtPointer client_data;
  45      XtPointer call_data;
  46 {
  47   widget_instance *instance = (widget_instance *) client_data;
  48
  49   if (instance->info->highlight_cb
  50       && !w->core.being_destroyed)
  51     instance->info->highlight_cb (w, instance->info->id, call_data);
  52 }
  53
  54 static void
  55 pre_hook (w, client_data, call_data)
  56      Widget w;
  57      XtPointer client_data;
  58      XtPointer call_data;
  59 {
  60   widget_instance* instance = (widget_instance*)client_data;
  61   widget_value* val;
  62
  63   if (w->core.being_destroyed)
  64     return;
  65
  66   val = lw_get_widget_value_for_widget (instance, w);
  67   if (instance->info->pre_activate_cb)
  68     instance->info->pre_activate_cb (w, instance->info->id,
  69                                      val ? val->call_data : NULL);
  70 }
  71
  72 static void
  73 pick_hook (w, client_data, call_data)
  74      Widget w;
  75      XtPointer client_data;
  76      XtPointer call_data;
  77 {
  78   widget_instance* instance = (widget_instance*)client_data;
  79   widget_value* contents_val = (widget_value*)call_data;
  80   widget_value* widget_val;
  81   XtPointer widget_arg;
  82
  83   if (w->core.being_destroyed)
  84     return;
  85
  86   if (instance->info->selection_cb && contents_val && contents_val->enabled
  87       && !contents_val->contents)
  88     instance->info->selection_cb (w, instance->info->id,
  89                                   contents_val->call_data);
  90
  91   widget_val = lw_get_widget_value_for_widget (instance, w);
  92   widget_arg = widget_val ? widget_val->call_data : NULL;
  93   if (instance->info->post_activate_cb)
  94     instance->info->post_activate_cb (w, instance->info->id, widget_arg);
  95
  96 }
  97
  98 \f/* creation functions */
  99
 100 static Widget
 101 xlw_create_menubar (instance)
 102      widget_instance* instance;
 103 {
 104   Widget widget;
 105   Arg al[5];
 106   int ac = 0;
 107
 108   XtSetArg (al[ac], XtNmenu, instance->info->val); ac++;
 109 #ifdef emacs
 110   XtSetArg (al[ac], XtNshowGrip, 0); ac++;
 111   XtSetArg (al[ac], XtNresizeToPreferred, 1); ac++;
 112   XtSetArg (al[ac], XtNallowResize, 1); ac++;
 113 #endif
 114
 115   /* This used to use XtVaCreateWidget, but an old Xt version
 116      has a bug in XtVaCreateWidget that frees instance->info->name.  */
 117   widget
 118     = XtCreateWidget (instance->info->name, xlwMenuWidgetClass,
 119                       instance->parent, al, ac);
 120
 121   XtAddCallback (widget, XtNopen, pre_hook, (XtPointer)instance);
 122   XtAddCallback (widget, XtNselect, pick_hook, (XtPointer)instance);
 123   XtAddCallback (widget, XtNhighlightCallback, highlight_hook,
 124                  (XtPointer)instance);
 125   return widget;
 126 }
 127
 128 static Widget
 129 xlw_create_popup_menu (instance)
 130      widget_instance* instance;
 131 {
 132   Widget popup_shell
 133     = XtCreatePopupShell (instance->info->name, overrideShellWidgetClass,
 134                           instance->parent, NULL, 0);
 135
 136   Widget widget;
 137   Arg al[2];
 138   int ac = 0;
 139
 140   XtSetArg (al[ac], XtNmenu, instance->info->val); ac++;
 141   XtSetArg (al[ac], XtNhorizontal, False); ac++;
 142
 143   /* This used to use XtVaManagedCreateWidget, but an old Xt version
 144      has a bug in XtVaManagedCreateWidget that frees instance->info->name.  */
 145   widget
 146     = XtCreateManagedWidget ("popup", xlwMenuWidgetClass,
 147                              popup_shell, al, ac);
 148
 149   XtAddCallback (widget, XtNselect, pick_hook, (XtPointer)instance);
 150   XtAddCallback (widget, XtNhighlightCallback, highlight_hook,
 151                  (XtPointer)instance);
 152   return popup_shell;
 153 }
 154
 155 widget_creation_entry
 156 xlw_creation_table [] =
 157 {
 158   {"menubar", xlw_create_menubar},
 159   {"popup", xlw_create_popup_menu},
 160   {NULL, NULL}
 161 };
 162
 163 Boolean
 164 lw_lucid_widget_p (widget)
 165      Widget widget;
 166 {
 167   WidgetClass the_class = XtClass (widget);
 168
 169   if (the_class == xlwMenuWidgetClass)
 170     return True;
 171   if (the_class == overrideShellWidgetClass)
 172     return (XtClass (((CompositeWidget)widget)->composite.children [0])
 173             == xlwMenuWidgetClass);
 174   return False;
 175 }
 176
 177 void
 178 xlw_update_one_widget (instance, widget, val, deep_p)
 179      widget_instance* instance;
 180      Widget widget;
 181      widget_value* val;
 182      Boolean deep_p;
 183 {
 184   XlwMenuWidget mw;
 185   Arg al[1];
 186
 187   if (XtIsShell (widget))
 188     mw = (XlwMenuWidget)((CompositeWidget)widget)->composite.children [0];
 189   else
 190     mw = (XlwMenuWidget)widget;
 191
 192   /* This used to use XtVaSetValues, but some old Xt versions
 193      that have a bug in XtVaCreateWidget might have it here too.  */
 194   XtSetArg (al[0], XtNmenu, instance->info->val);
 195
 196   XtSetValues (widget, al, 1);
 197 }
 198
 199 void
 200 xlw_update_one_value (instance, widget, val)
 201      widget_instance* instance;
 202      Widget widget;
 203      widget_value* val;
 204 {
 205   return;
 206 }
 207
 208 void
 209 xlw_pop_instance (instance, up)
 210      widget_instance* instance;
 211      Boolean up;
 212 {
 213 }
 214
 215 void
 216 xlw_popup_menu (widget, event)
 217      Widget widget;
 218      XEvent *event;
 219 {
 220   XButtonPressedEvent dummy;
 221   XlwMenuWidget mw;
 222
 223   if (!XtIsShell (widget))
 224     return;
 225
 226   mw = (XlwMenuWidget)((CompositeWidget)widget)->composite.children [0];
 227
 228   if (event)
 229     pop_up_menu (mw, (XButtonPressedEvent*) event);
 230   else
 231     {
 232       dummy.type = ButtonPress;
 233       dummy.serial = 0;
 234       dummy.send_event = 0;
 235       dummy.display = XtDisplay (widget);
 236       dummy.window = XtWindow (XtParent (widget));
 237       dummy.time = CurrentTime;
 238       dummy.button = 0;
 239       XQueryPointer (dummy.display, dummy.window, &dummy.root,
 240                      &dummy.subwindow, &dummy.x_root, &dummy.y_root,
 241                      &dummy.x, &dummy.y, &dummy.state);
 242
 243       pop_up_menu (mw, &dummy);
 244     }
 245 }
 246
 247 \f/* Destruction of instances */
 248 void
 249 xlw_destroy_instance (instance)
 250      widget_instance* instance;
 251 {
 252   if (instance->widget)
 253     XtDestroyWidget (instance->widget);
 254 }
 255