lwlib/lwlib-utils.c

   1 /* Defines some widget utility functions.
   2
   3 Copyright (C) 1992 Lucid, Inc.
   4 Copyright (C) 1994, 2001-2011 Free Software Foundation, Inc.
   5
   6 This file is part of the Lucid Widget Library.
   7
   8 The Lucid Widget Library is free software; you can redistribute it and/or
   9 modify it under the terms of the GNU General Public License as published by
  10 the Free Software Foundation; either version 1, or (at your option)
  11 any later version.
  12
  13 The Lucid Widget Library is distributed in the hope that it will be useful,
  14 but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 GNU General Public License for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with GNU Emacs; see the file COPYING.  If not, write to
  20 the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  21 Boston, MA 02110-1301, USA.  */
  22
  23 #ifdef HAVE_CONFIG_H
  24 #include <config.h>
  25 #endif
  26
  27 #include <setjmp.h>
  28 #include <lisp.h>
  29
  30 #include <X11/Xatom.h>
  31 #include <X11/IntrinsicP.h>
  32 #include <X11/ObjectP.h>
  33 #include "lwlib-utils.h"
  34 #include "lwlib.h"
  35
  36 /* Redisplay the contents of the widget, without first clearing it. */
  37 void
  38 XtNoClearRefreshWidget (Widget widget)
  39 {
  40   XEvent event;
  41
  42   event.type = Expose;
  43   event.xexpose.serial = 0;
  44   event.xexpose.send_event = 0;
  45   event.xexpose.display = XtDisplay (widget);
  46   event.xexpose.window = XtWindow (widget);
  47   event.xexpose.x = 0;
  48   event.xexpose.y = 0;
  49   event.xexpose.width = widget->core.width;
  50   event.xexpose.height = widget->core.height;
  51   event.xexpose.count = 0;
  52
  53   (*widget->core.widget_class->core_class.expose)
  54     (widget, &event, (Region)NULL);
  55 }
  56
  57
  58 /*
  59  * Apply a function to all the subwidgets of a given widget recursively.
  60 */
  61 void
  62 XtApplyToWidgets (Widget w, XtApplyToWidgetsProc proc, XtPointer arg)
  63 {
  64   if (XtIsComposite (w))
  65     {
  66       CompositeWidget cw = (CompositeWidget) w;
  67       /* We have to copy the children list before mapping over it, because
  68          the procedure might add/delete elements, which would lose badly.
  69          */
  70       int nkids = cw->composite.num_children;
  71       Widget *kids = (Widget *) xmalloc (sizeof (Widget) * nkids);
  72       int i;
  73       memcpy ((char *) kids, (char *) cw->composite.children,
  74               sizeof (Widget) * nkids);
  75       for (i = 0; i < nkids; i++)
  76 /* This prevent us from using gadgets, why is it here? */
  77 /*      if (XtIsWidget (kids [i])) */
  78           {
  79             /* do the kiddies first in case we're destroying */
  80             XtApplyToWidgets (kids [i], proc, arg);
  81             proc (kids [i], arg);
  82           }
  83       free (kids);
  84     }
  85 }
  86
  87
  88 /*
  89  * Apply a function to all the subwidgets of a given widget recursively.
  90  * Stop as soon as the function returns non NULL and returns this as a value.
  91  */
  92 void *
  93 XtApplyUntilToWidgets (Widget w, XtApplyUntilToWidgetsProc proc, XtPointer arg)
  94 {
  95   void* result;
  96   if (XtIsComposite (w))
  97     {
  98       CompositeWidget cw = (CompositeWidget)w;
  99       int i;
 100       for (i = 0; i < cw->composite.num_children; i++)
 101         if (XtIsWidget (cw->composite.children [i])){
 102           result = proc (cw->composite.children [i], arg);
 103           if (result)
 104             return result;
 105           result = XtApplyUntilToWidgets (cw->composite.children [i], proc,
 106                                           arg);
 107           if (result)
 108             return result;
 109         }
 110     }
 111   return NULL;
 112 }
 113
 114
 115 /*
 116  * Returns a copy of the list of all children of a composite widget
 117  */
 118 Widget *
 119 XtCompositeChildren (Widget widget, unsigned int *number)
 120 {
 121   CompositeWidget cw = (CompositeWidget)widget;
 122   Widget* result;
 123   int n;
 124   int i;
 125
 126   if (!XtIsComposite (widget))
 127     {
 128       *number = 0;
 129       return NULL;
 130     }
 131   n = cw->composite.num_children;
 132   result = (Widget*)XtMalloc (n * sizeof (Widget));
 133   *number = n;
 134   for (i = 0; i < n; i++)
 135     result [i] = cw->composite.children [i];
 136   return result;
 137 }
 138
 139 Boolean
 140 XtWidgetBeingDestroyedP (Widget widget)
 141 {
 142   return widget->core.being_destroyed;
 143 }
 144
 145 void
 146 XtSafelyDestroyWidget (Widget widget)
 147 {
 148 #if 0
 149
 150   /* this requires IntrinsicI.h (actually, InitialI.h) */
 151
 152   XtAppContext app = XtWidgetToApplicationContext(widget);
 153
 154   if (app->dispatch_level == 0)
 155     {
 156       app->dispatch_level = 1;
 157       XtDestroyWidget (widget);
 158       /* generates an event so that the event loop will be called */
 159       XChangeProperty (XtDisplay (widget), XtWindow (widget),
 160                        XA_STRING, XA_STRING, 32, PropModeAppend, NULL, 0);
 161       app->dispatch_level = 0;
 162     }
 163   else
 164     XtDestroyWidget (widget);
 165
 166 #else
 167   abort ();
 168 #endif
 169 }