lwlib/lwlib-utils.c

   1 /* Defines some widget utility functions.
   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 /* Definitions of these in config.h can cause
  26    declaration conflicts later on between declarations for index
  27    and declarations for strchr.  This file doesn't use
  28    index and rindex, so cancel them.  */
  29 #undef index
  30 #undef rindex
  31
  32 #include <X11/Xatom.h>
  33 #include <X11/IntrinsicP.h>
  34 #include <X11/ObjectP.h>
  35 #include "lwlib-utils.h"
  36
  37 /* Redisplay the contents of the widget, without first clearing it. */
  38 void
  39 XtNoClearRefreshWidget (widget)
  40      Widget widget;
  41 {
  42   XEvent event;
  43
  44   event.type = Expose;
  45   event.xexpose.serial = 0;
  46   event.xexpose.send_event = 0;
  47   event.xexpose.display = XtDisplay (widget);
  48   event.xexpose.window = XtWindow (widget);
  49   event.xexpose.x = 0;
  50   event.xexpose.y = 0;
  51   event.xexpose.width = widget->core.width;
  52   event.xexpose.height = widget->core.height;
  53   event.xexpose.count = 0;
  54
  55   (*widget->core.widget_class->core_class.expose)
  56     (widget, &event, (Region)NULL);
  57 }
  58
  59
  60 /*
  61  * Apply a function to all the subwidgets of a given widget recursively.
  62 */
  63 void
  64 XtApplyToWidgets (w, proc, arg)
  65      Widget w;
  66      XtApplyToWidgetsProc proc;
  67      XtPointer arg;
  68 {
  69   if (XtIsComposite (w))
  70     {
  71       CompositeWidget cw = (CompositeWidget) w;
  72       /* We have to copy the children list before mapping over it, because
  73          the procedure might add/delete elements, which would lose badly.
  74          */
  75       int nkids = cw->composite.num_children;
  76       Widget *kids = (Widget *) malloc (sizeof (Widget) * nkids);
  77       int i;
  78       lwlib_bcopy (cw->composite.children, kids, sizeof (Widget) * nkids);
  79       for (i = 0; i < nkids; i++)
  80 /* This prevent us from using gadgets, why is it here? */
  81 /*      if (XtIsWidget (kids [i])) */
  82           {
  83             /* do the kiddies first in case we're destroying */
  84             XtApplyToWidgets (kids [i], proc, arg);
  85             proc (kids [i], arg);
  86           }
  87       free (kids);
  88     }
  89 }
  90
  91
  92 /*
  93  * Apply a function to all the subwidgets of a given widget recursively.
  94  * Stop as soon as the function returns non NULL and returns this as a value.
  95  */
  96 void *
  97 XtApplyUntilToWidgets (w, proc, arg)
  98      Widget w;
  99      XtApplyUntilToWidgetsProc proc;
 100      XtPointer arg;
 101 {
 102   void* result;
 103   if (XtIsComposite (w))
 104     {
 105       CompositeWidget cw = (CompositeWidget)w;
 106       int i;
 107       for (i = 0; i < cw->composite.num_children; i++)
 108         if (XtIsWidget (cw->composite.children [i])){
 109           result = proc (cw->composite.children [i], arg);
 110           if (result)
 111             return result;
 112           result = XtApplyUntilToWidgets (cw->composite.children [i], proc,
 113                                           arg);
 114           if (result)
 115             return result;
 116         }
 117     }
 118   return NULL;
 119 }
 120
 121
 122 /*
 123  * Returns a copy of the list of all children of a composite widget
 124  */
 125 Widget *
 126 XtCompositeChildren (widget, number)
 127      Widget widget;
 128      unsigned int* number;
 129 {
 130   CompositeWidget cw = (CompositeWidget)widget;
 131   Widget* result;
 132   int n;
 133   int i;
 134
 135   if (!XtIsComposite (widget))
 136     {
 137       *number = 0;
 138       return NULL;
 139     }
 140   n = cw->composite.num_children;
 141   result = (Widget*)XtMalloc (n * sizeof (Widget));
 142   *number = n;
 143   for (i = 0; i < n; i++)
 144     result [i] = cw->composite.children [i];
 145   return result;
 146 }
 147
 148 Boolean
 149 XtWidgetBeingDestroyedP (widget)
 150      Widget widget;
 151 {
 152   return widget->core.being_destroyed;
 153 }
 154
 155 void
 156 XtSafelyDestroyWidget (widget)
 157      Widget widget;
 158 {
 159 #if 0
 160
 161   /* this requires IntrinsicI.h (actually, InitialI.h) */
 162
 163   XtAppContext app = XtWidgetToApplicationContext(widget);
 164
 165   if (app->dispatch_level == 0)
 166     {
 167       app->dispatch_level = 1;
 168       XtDestroyWidget (widget);
 169       /* generates an event so that the event loop will be called */
 170       XChangeProperty (XtDisplay (widget), XtWindow (widget),
 171                        XA_STRING, XA_STRING, 32, PropModeAppend, NULL, 0);
 172       app->dispatch_level = 0;
 173     }
 174   else
 175     XtDestroyWidget (widget);
 176
 177 #else
 178   abort ();
 179 #endif
 180 }