falso
/
cdesktopenv
mirror of https://git.code.sf.net/p/cdesktopenv/code
1
0
Fork 0
Code Issues Releases Wiki Activity
cdesktopenv/cde/programs/dtprintinfo/libUI/MotifUI/MotifUI.C

910 lines
22 KiB
C
Raw Blame History

/*
* CDE - Common Desktop Environment
*
* Copyright (c) 1993-2012, The Open Group. All rights reserved.
*
* These libraries and programs are free software; you can
* redistribute them and/or modify them under the terms of the GNU
* Lesser General Public License as published by the Free Software
* Foundation; either version 2 of the License, or (at your option)
* any later version.
*
* These libraries and programs are distributed in the hope that
* they will be useful, but WITHOUT ANY WARRANTY; without even the
* implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
* PURPOSE. See the GNU Lesser General Public License for more
* details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with these libraries and programs; if not, write
* to the Free Software Foundation, Inc., 51 Franklin Street, Fifth
* Floor, Boston, MA 02110-1301 USA
*/
/* $TOG: MotifUI.C /main/8 1998/08/03 08:59:09 mgreess $ */
/* *
* (c) Copyright 1993, 1994 Hewlett-Packard Company *
* (c) Copyright 1993, 1994 International Business Machines Corp. *
* (c) Copyright 1993, 1994 Sun Microsystems, Inc. *
* (c) Copyright 1993, 1994 Novell, Inc. *
*/
#include "MotifUI.h"
#include "Menu.h"
#include "Dialog.h"
#include "Icon.h"
#include <stdlib.h>
#include <stdio.h>
#include <sys/stat.h>
#include <X11/cursorfont.h>
#include <X11/IntrinsicP.h>
#ifdef NO_CDE
#include "xpm.h"
#include <X11/keysym.h>
#else
#include <Dt/xpm.h>
#include <Dt/Help.h>
#endif
#include <Dt/HourGlass.h>
#include <Xm/ToggleB.h>
#include <Xm/RowColumn.h>
#include <Xm/ScrolledW.h>
#include <Xm/MainW.h>
PixmapLookupList MotifUI::pixmap_table = NULL;
XtAppContext MotifUI::appContext = NULL;
XmFontList MotifUI::userFont = NULL;
Display * MotifUI::display = NULL;
Widget MotifUI::topLevel;
Window MotifUI::root;
Font MotifUI::font;
Pixel MotifUI::black;
Pixel MotifUI::white;
int MotifUI::shadowThickness;
int MotifUI::depth;
int MotifUI::bMenuButton;
int MotifUI::n_pixmaps = 0;
PointerCursor MotifUI::pointer_style = LEFT_SLANTED_ARROW_CURSOR;
MotifUI::MotifUI(MotifUI *parent,
const char *name,
const char *category,
const char *widgetName)
: BaseUI(parent, name, category)
{
_w = NULL;
if (widgetName)
_widgetName = STRDUP(widgetName);
else
_widgetName = STRDUP(name);
}
MotifUI::~MotifUI()
{
if (_w)
XtRemoveCallback(_w, XmNdestroyCallback, &MotifUI::WidgetDestroyCB,
(XtPointer) this);
delete _widgetName;
}
void MotifUI::ThreadCB(MotifThread *_thread, BaseUI *obj, ThreadCallback cb)
{
(*cb)(obj, _thread->output, _thread->status);
delete _thread;
}
void MotifUI::Thread(const char *cmd, ThreadCallback cb, int buf_len)
{
new MotifThread(this, cmd, &(MotifUI::ThreadCB), cb, buf_len);
}
void MotifUI::Thread(int pid, int fd, ThreadCallback cb, int buf_len)
{
new MotifThread(this, pid, fd, &(MotifUI::ThreadCB), cb, buf_len);
}
void MotifUI::Thread(int socket, ThreadCallback cb, int buf_len)
{
new MotifThread(this, socket, &(MotifUI::ThreadCB), cb, buf_len);
}
void MotifUI::SetFocus()
{
DoSetFocus(_w);
}
void MotifUI::DoSetFocus(Widget w)
{
XmProcessTraversal(w, XmTRAVERSE_CURRENT);
}
boolean MotifUI::DoIsVisible()
{
boolean rc = true;
if (_w)
{
if (UIClass() == APPLICATION)
{
if (XtIsRealized(_w))
{
XWindowAttributes attributes;
XGetWindowAttributes(display, XtWindow(_w), &attributes);
if (attributes.map_state == IsUnmapped)
rc = false;
}
}
else if (XmGetVisibility(_w) == XmVISIBILITY_FULLY_OBSCURED)
rc = false;
}
return rc;
}
void MotifUI::DoMakeVisible()
{
Widget sw = XtParent(_w);
if (sw && !XmIsScrolledWindow(sw))
sw = XtParent(sw);
if (sw && !XmIsScrolledWindow(sw))
sw = XtParent(sw);
if (sw && XmIsScrolledWindow(sw) && !XmIsMainWindow(sw))
XmScrollVisible(sw, _w, 0, 0);
}
void MotifUI::DoContextualHelp()
{
Widget context_widget, shell;
#ifdef NO_CDE
XEvent event;
static Cursor cursor = (Cursor) NULL;
if (cursor == (Cursor) NULL)
cursor = XCreateFontCursor(display, XC_question_arrow);
#endif
BaseUI *window = this;
while (window->UIClass() != MAIN_WINDOW)
window = window->Parent();
shell = ((MotifUI *)window)->_w;
#ifdef NO_CDE
context_widget = XmTrackingEvent(shell, cursor, False, &event);
if (event.type == KeyPress || event.type == KeyRelease)
{
int offset;
KeySym keySym;
// Look for ESC key press and stop if we get one
if (event.xkey.state & ShiftMask)
offset = 1;
else
offset = 0;
keySym = XLookupKeysym((XKeyEvent *)&event, offset);
if (keySym == XK_Escape)
return;
}
if (context_widget != NULL)
{
#else
int returnVal = DtHelpReturnSelectedWidgetId(shell, 0, &context_widget);
if (returnVal == DtHELP_SELECT_VALID)
{
#endif
XmAnyCallbackStruct cb;
cb.reason = XmCR_HELP;
#ifdef NO_CDE
cb.event = &event;
#endif
while (context_widget != NULL)
{
// If there is no help at this widget, back track to find help
if (XtHasCallbacks(context_widget, XmNhelpCallback) ==
XtCallbackHasSome)
{
XtCallCallbacks(context_widget, XmNhelpCallback, &cb);
break;
}
else
context_widget = XtParent(context_widget);
}
}
}
void MotifUI::WidgetHelpCB(Widget,
XtPointer clientData,
XtPointer)
{
MotifUI * obj = (MotifUI *) clientData;
obj->HandleHelpRequest();
}
void MotifUI::WidgetDestroyCB(Widget,
XtPointer clientData,
XtPointer)
{
MotifUI * obj = (MotifUI *) clientData;
obj->WidgetDestroyed();
}
void MotifUI::WidgetDestroyed()
{
_w = NULL;
delete _widgetName;
}
void MotifUI::DoRefresh()
{
if (_w)
XmUpdateDisplay(_w);
}
void MotifUI::DoToFront()
{
if (_w)
{
if (XtIsShell(XtParent(_w)))
XRaiseWindow(display, XtWindow(XtParent(_w)));
else
XRaiseWindow(display, XtWindow(_w));
}
}
void MotifUI::InstallDestroyCB()
{
if (_w)
XtAddCallback(_w, XmNdestroyCallback, &MotifUI::WidgetDestroyCB,
(XtPointer) this);
}
void MotifUI::InstallHelpCB()
{
if (!_w)
return;
if (UIClass() == MENU && UISubClass() != POPUP_MENU)
XtAddCallback(((Menu*)this)->GetCascade(), XmNhelpCallback,
&MotifUI::WidgetHelpCB, (XtPointer) this);
else
XtAddCallback(_w, XmNhelpCallback, &MotifUI::WidgetHelpCB,
(XtPointer) this);
}
boolean MotifUI::SetSelected(boolean flag)
{
if (!_w)
return false;
if (GuiIsIcon(_w))
XtVaSetValues(_w, GuiNselected, flag, NULL);
else if (XmIsToggleButton(_w))
XmToggleButtonSetState(_w, flag, False);
return true;
}
boolean MotifUI::SetName(char *name)
{
if (!InnerWidget())
return false;
XmString xm_string = StringCreate(name);
XtVaSetValues(InnerWidget(), XmNlabelString, xm_string, NULL);
StringFree(xm_string);
return true;
}
boolean MotifUI::SetActivity(boolean flag)
{
if (!_w)
return false;
if (GuiIsIcon(_w))
XtVaSetValues(_w, GuiNactive, flag, NULL);
else
XtSetSensitive(_w, flag);
return true;
}
boolean MotifUI::SetVisiblity(boolean flag)
{
if (!_w)
return false;
if (flag)
XtManageChild(_w);
else
XtUnmanageChild(_w);
return true;
}
void MotifUI::GetResources(const XtResourceList resources,
const int numResources)
{
if (_w && resources)
XtGetSubresources(XtParent(_w), (XtPointer) this, _widgetName,
className(), resources, numResources, NULL, 0);
}
void MotifUI::SetDefaultResources(const Widget,
const String *resources)
{
XrmDatabase rdb = NULL;
int i;
rdb = XrmGetStringDatabase("");
i = 0;
while (resources[i])
{
char *buf = new char[1000];
sprintf(buf, "%s%s", _name, resources[i]);
XrmPutLineResource(&rdb, buf);
i++;
delete [] buf;
}
if (rdb)
{
XrmMergeDatabases(XtDatabase(display), &rdb);
XrmSetDatabase(display, rdb);
}
}
void MotifUI::NotifyDelete(BaseUI *obj)
{
MotifUI *p = (MotifUI *) obj;
if (p->_w)
{
XtRemoveCallback(_w, XmNdestroyCallback, &MotifUI::WidgetDestroyCB,
(XtPointer) this);
XtDestroyWidget(p->_w);
p->_w = NULL;
}
}
void MotifUI::Width(int width)
{
XtVaSetValues(this->BaseWidget(), XmNwidth, width, NULL);
}
int MotifUI::Width()
{
Dimension w;
XtVaGetValues(this->BaseWidget(), XmNwidth, &w, NULL);
return (int) w;
}
void MotifUI::Height(int height)
{
XtVaSetValues(this->BaseWidget(), XmNheight, height, NULL);
}
int MotifUI::Height()
{
Dimension h;
XtVaGetValues(this->BaseWidget(), XmNheight, &h, NULL);
return (int) h;
}
void MotifUI::WidthHeight(int width, int height)
{
XtVaSetValues(this->BaseWidget(), XmNwidth, width, XmNheight, height, NULL);
}
void MotifUI::WidthHeight(int *width, int *height)
{
Dimension w, h;
XtVaGetValues(this->BaseWidget(), XmNwidth, &w, XmNheight, &h, NULL);
*width = (int) w;
*height = (int) h;
}
void MotifUI::AttachAll(int offset)
{
XtVaSetValues(this->BaseWidget(),
XmNtopAttachment, XmATTACH_NONE,
XmNbottomAttachment, XmATTACH_NONE,
XmNleftAttachment, XmATTACH_NONE,
XmNrightAttachment, XmATTACH_NONE,
NULL);
XtVaSetValues(this->BaseWidget(),
XmNtopAttachment, XmATTACH_FORM, XmNtopOffset, offset,
XmNbottomAttachment, XmATTACH_FORM, XmNbottomOffset, offset,
XmNleftAttachment, XmATTACH_FORM, XmNleftOffset, offset,
XmNrightAttachment, XmATTACH_FORM, XmNrightOffset, offset,
NULL);
}
void MotifUI::AttachTop(int offset)
{
XtVaSetValues(this->BaseWidget(), XmNtopAttachment, XmATTACH_NONE, NULL);
XtVaSetValues(this->BaseWidget(), XmNtopAttachment, XmATTACH_FORM,
XmNtopOffset, offset, NULL);
}
void MotifUI::AttachBottom(int offset)
{
XtVaSetValues(this->BaseWidget(), XmNbottomAttachment, XmATTACH_NONE, NULL);
XtVaSetValues(this->BaseWidget(), XmNbottomAttachment, XmATTACH_FORM,
XmNbottomOffset, offset, NULL);
}
void MotifUI::AttachLeft(int offset)
{
XtVaSetValues(this->BaseWidget(), XmNleftAttachment, XmATTACH_NONE, NULL);
XtVaSetValues(this->BaseWidget(), XmNleftAttachment, XmATTACH_FORM,
XmNleftOffset, offset, NULL);
}
void MotifUI::AttachRight(int offset)
{
XtVaSetValues(this->BaseWidget(), XmNrightAttachment, XmATTACH_NONE, NULL);
XtVaSetValues(this->BaseWidget(), XmNrightAttachment, XmATTACH_FORM,
XmNrightOffset, offset, NULL);
}
void MotifUI::AttachTop(BaseUI *obj, int offset, boolean opposite)
{
XtVaSetValues(this->BaseWidget(), XmNtopAttachment, XmATTACH_NONE, NULL);
if (obj)
{
Widget w = ((MotifUI *)obj)->BaseWidget();
int attachment;
if (opposite)
attachment = XmATTACH_OPPOSITE_WIDGET;
else
attachment = XmATTACH_WIDGET;
XtVaSetValues(this->BaseWidget(), XmNtopAttachment, attachment,
XmNtopWidget, w, XmNtopOffset, offset, NULL);
}
}
void MotifUI::AttachBottom(BaseUI *obj, int offset, boolean opposite)
{
XtVaSetValues(this->BaseWidget(), XmNbottomAttachment, XmATTACH_NONE, NULL);
if (obj)
{
Widget w = ((MotifUI *)obj)->BaseWidget();
int attachment;
if (opposite)
attachment = XmATTACH_OPPOSITE_WIDGET;
else
attachment = XmATTACH_WIDGET;
XtVaSetValues(this->BaseWidget(), XmNbottomAttachment, attachment,
XmNbottomWidget, w, XmNbottomOffset, offset, NULL);
}
}
void MotifUI::AttachLeft(BaseUI *obj, int offset, boolean opposite)
{
XtVaSetValues(this->BaseWidget(), XmNleftAttachment, XmATTACH_NONE, NULL);
if (obj)
{
int attachment;
if (opposite)
attachment = XmATTACH_OPPOSITE_WIDGET;
else
attachment = XmATTACH_WIDGET;
Widget w = ((MotifUI *)obj)->BaseWidget();
XtVaSetValues(this->BaseWidget(), XmNleftAttachment, attachment,
XmNleftWidget, w, XmNleftOffset, offset, NULL);
}
}
void MotifUI::AttachRight(BaseUI *obj, int offset, boolean opposite)
{
XtVaSetValues(this->BaseWidget(), XmNrightAttachment, XmATTACH_NONE, NULL);
if (obj)
{
Widget w = ((MotifUI *)obj)->BaseWidget();
int attachment;
if (opposite)
attachment = XmATTACH_OPPOSITE_WIDGET;
else
attachment = XmATTACH_WIDGET;
XtVaSetValues(this->BaseWidget(), XmNrightAttachment, attachment,
XmNrightWidget, w, XmNrightOffset, offset, NULL);
}
}
void MotifUI::StringWidthHeight(const char *string, int *width, int *height)
{
Dimension w, h;
XmString xm_string = StringCreate((char *)string);
XmStringExtent(userFont, xm_string, &w, &h);
*width = w;
*height = h;
StringFree(xm_string);
}
int MotifUI::StringWidth(const char *string)
{
int dummy;
int width;
StringWidthHeight(string, &width, &dummy);
return width;
}
int MotifUI::StringHeight(const char *string)
{
int dummy;
int height;
StringWidthHeight(string, &dummy, &height);
return height;
}
boolean MotifUI::SetOrder(int new_position)
{
if (XmIsRowColumn(((MotifUI *)Parent())->InnerWidget()))
XtVaSetValues(BaseWidget(), XmNpositionIndex, new_position, NULL);
return true;
}
void MotifUI::Dump(boolean verbose,
int level)
{
if (verbose)
{
BaseUI::Dump(true, level);
int i;
for (i = -2; i < level; i++) printf(" ");
printf("BaseWidget : %08lx\n", _w);
}
else
BaseUI::Dump(false, level);
}
// Time out stuff
typedef struct
{
TimeOutCallback fp;
BaseUI *obj;
void *callback_data;
} TimeOutCallbackData;
static void
ObjectTimeProc(XtPointer callback_data, XtIntervalId * /*id*/)
{
TimeOutCallbackData *data = (TimeOutCallbackData *) callback_data;
(*data->fp)(data->obj, data->callback_data);
delete data;
data = NULL;
}
void MotifUI::SetAddTimeOut(TimeOutCallback timeoutCB,
void *callback_data,
long interval)
{
if (!_w)
return;
TimeOutCallbackData * data = new TimeOutCallbackData;
data->fp = timeoutCB;
data->obj = this;
data->callback_data = callback_data;
XtAppAddTimeOut(appContext, (unsigned long) interval, ObjectTimeProc, data);
}
void MotifUI::FillBackground(Widget widget, Pixmap pixmap, Pixmap mask)
{
static Pixmap temp = 0L;
static GC gc = 0L;
static unsigned int old_width = 0, old_height = 0, old_depth = 0;
unsigned int width, height, junk, dep;
Window root;
XGCValues xgc;
XGetGeometry(display, pixmap, &root, (int *) &junk,
(int *) &junk, &width, &height, &junk, &dep);
if (temp &&
(old_width < width || old_height < height || old_depth != dep))
{
// Free resources
XFreeGC(display, gc);
XFreePixmap(display, temp);
temp = 0L;
gc = 0L;
}
old_width = width;
old_height = height;
old_depth = dep;
if (dep == 1 && UIClass() == MAIN_WINDOW)
XtVaGetValues(widget, XmNforeground, &xgc.foreground, NULL);
else
XtVaGetValues(widget, XmNbackground, &xgc.foreground, NULL);
if (!temp)
{
temp = XCreatePixmap(display, RootWindowOfScreen(XtScreen(widget)),
width, height, dep);
xgc.function = GXcopy;
gc = XCreateGC(display, pixmap, GCForeground|GCFunction, &xgc);
}
else
XSetForeground(display, gc, xgc.foreground);
XFillRectangle(display, temp, gc, 0, 0, width, height);
if (mask != XmUNSPECIFIED_PIXMAP)
XSetClipMask(display, gc, mask);
else
XSetClipMask(display, gc, None);
XCopyArea(display, pixmap, temp, gc, 0, 0, width, height, 0, 0);
XSetClipMask(display, gc, None);
XCopyArea(display, temp, pixmap, gc, 0, 0, width, height, 0, 0);
}
// Pixmap caching utility
void MotifUI::GetPixmaps(Widget w,
char *name,
Pixmap *pixmap,
Pixmap *mask)
{
// Try to find pixmap in cache
PixmapLookupList pixmaps = pixmap_table;
int i;
for (i = 0; i < n_pixmaps; i++, pixmaps++)
if (!strcmp((**pixmaps).name, name))
{
*pixmap = (**pixmaps).pixmap;
if (mask)
*mask = (**pixmaps).mask;
return;
}
Pixmap _mask;
char *s;
SubstitutionRec subs[1];
char *bmPath;
char *PIXMAP_DIR = "/usr/dt/appconfig/icons/%L/%B:"
"/usr/dt/appconfig/icons/C/%B:"
"/usr/include/X11/bitmaps/%B";
if (*name == '/')
s = name;
else
{
#ifdef NO_CDE
if ((s = getenv("XBMLANGPATH")) && *s)
#else
if ((s = getenv("XMICONSEARCHPATH")) && *s)
#endif
{
bmPath = new char [strlen(s) + strlen(PIXMAP_DIR) + 2];
sprintf(bmPath, "%s:%s", PIXMAP_DIR, s);
}
else
bmPath = PIXMAP_DIR;
subs[0].match = 'B';
subs[0].substitution = name;
s = XtFindFile(bmPath, subs, XtNumber(subs), NULL);
if (bmPath != PIXMAP_DIR)
delete [] bmPath;
}
struct stat statbuf;
if (!s || stat(s, &statbuf) < 0)
{
*pixmap = XmUNSPECIFIED_PIXMAP;
if (mask)
*mask = XmUNSPECIFIED_PIXMAP;
return;
}
int len = strlen(s);
if (!strcmp(s + len - 3, ".pm"))
{
XpmAttributes attributes;
memset((char *)&attributes, 0, sizeof(XpmAttributes));
#ifdef NO_CDE
XpmReadFileToPixmap(display, root, s, pixmap, &_mask, &attributes);
#else
_DtXpmReadFileToPixmap(display, root, s, pixmap, &_mask, &attributes);
#endif
if (_mask)
FillBackground(w, *pixmap, _mask);
#ifdef NO_CDE
XpmFreeAttributes(&attributes);
#else
_DtXpmFreeAttributes(&attributes);
#endif
}
else
{
if (UIClass() == MAIN_WINDOW)
*pixmap = XmGetPixmapByDepth(XtScreen(w), s, white, black, depth);
else
*pixmap = XmGetPixmapByDepth(XtScreen(w), s, black, white, depth);
char *s1 = new char [len + 3];
strcpy(s1, s);
strcpy(s1 + len - 3, "_m.bm");
if (stat(s1, &statbuf) < 0)
_mask = XmUNSPECIFIED_PIXMAP;
else
{
_mask = XmGetPixmapByDepth(XtScreen(w), s1, white, black, 1);
FillBackground(w, *pixmap, _mask);
}
delete [] s1;
}
if (mask)
*mask = _mask;
if (s != name)
XtFree(s);
// Add pixmap to table
if (!(n_pixmaps % 8))
{
pixmaps = new PixmapLookup [n_pixmaps + 8];
for (i = 0; i < n_pixmaps; i++)
pixmaps[i] = pixmap_table[i];
for (i = n_pixmaps; i < n_pixmaps + 8; i++)
pixmaps[i] = new PixmapLookupStruct;
delete []pixmap_table;
pixmap_table = pixmaps;
}
pixmap_table[n_pixmaps]->name = strdup(name);
pixmap_table[n_pixmaps]->pixmap = *pixmap;
pixmap_table[n_pixmaps]->mask = _mask;
n_pixmaps++;
}
PointerCursor MotifUI::PointerShape()
{
return pointer_style;
}
void MotifUI::PointerShape(PointerCursor style)
{
static Cursor left = (Cursor) 0L;
static Cursor right = (Cursor) 0L;
static Cursor watch = (Cursor) 0L;
static Cursor hour_glass = (Cursor) 0L;
static Cursor ibeam = (Cursor) 0L;
static Cursor cross_hair = (Cursor) 0L;
if (!_w)
return;
Cursor cursor;
switch (pointer_style = style)
{
case LEFT_SLANTED_ARROW_CURSOR:
if (!left)
left = XCreateFontCursor(display, XC_left_ptr);
cursor = left;
break;
case RIGHT_SLANTED_ARROW_CURSOR:
if (!right)
right = XCreateFontCursor(display, XC_right_ptr);
cursor = right;
break;
case WATCH_CURSOR:
if (!watch)
watch = XCreateFontCursor(display, XC_watch);
cursor = watch;
break;
case HOUR_GLASS_CURSOR:
if (!hour_glass)
hour_glass = _DtGetHourGlassCursor(display);
cursor = hour_glass;
break;
case IBEAM_CURSOR:
if (!ibeam)
ibeam = XCreateFontCursor(display, XC_xterm);
cursor = ibeam;
break;
case CROSS_HAIRS_CURSOR:
if (!cross_hair)
cross_hair = XCreateFontCursor(display, XC_crosshair);
cursor = cross_hair;
break;
default: cursor = None; break;
}
if (XtIsRealized(_w))
XDefineCursor(display, XtWindow(_w), cursor);
}
static int G_width;
static void VerbosePass1(Widget w, int level)
{
int i;
if (level == 0)
G_width = 0;
int new_width = (level * 3) + strlen(XrmQuarkToString(w->core.xrm_name)) +
strlen(w->core.widget_class->core_class.class_name) + 3;
if (new_width > G_width)
G_width = new_width;
if (XtIsWidget(w))
for (i = 0; i < w->core.num_popups; i++)
VerbosePass1(w->core.popup_list[i], level + 1);
if (XtIsComposite(w))
{
CompositeWidget cw = (CompositeWidget) w;
for (i = 0; i < cw->composite.num_children; i++)
VerbosePass1(cw->composite.children[i], level + 1);
}
}
void MotifUI::DumpWidget(Widget w, boolean verbose, int level)
{
int i;
for (i = 0; i < level; i++)
printf(" ");
printf("%s : %s", XrmQuarkToString(w->core.xrm_name),
w->core.widget_class->core_class.class_name);
if (verbose)
{
int n = (level * 3) + strlen(XrmQuarkToString(w->core.xrm_name)) +
strlen(w->core.widget_class->core_class.class_name) + 3;
for ( ; n < G_width; n++)
printf(" ");
if (XtIsManaged(w))
printf(" Managed ");
else
printf(" Unmanaged");
if (XtIsSensitive(w))
printf(" Sensitive ");
else
printf(" Insensitive");
if (XtIsRealized(w))
printf(" Realized ");
else
printf(" Unrealized");
if (w->core.visible)
printf(" Visible\n");
else
printf(" Invisible\n");
}
else
printf("\n");
}
void MotifUI::DumpWidgets(Widget w, boolean verbose, int level)
{
DumpWidget(w, verbose, level);
int i;
if (XtIsWidget(w))
{
for (i = 0; i < w->core.num_popups; i++)
DumpWidgets(w->core.popup_list[i], verbose, level + 1);
}
if (XtIsComposite(w))
{
CompositeWidget cw = (CompositeWidget) w;
for (i = 0; i < cw->composite.num_children; i++)
DumpWidgets(cw->composite.children[i], verbose, level + 1);
}
}
void MotifUI::DumpUIHierarchy(boolean verbose, int level)
{
if (verbose)
VerbosePass1(_w, 0);
DumpWidgets(_w, verbose, level);
}
Reference in New Issue View Git Blame Copy Permalink