static void
_XmFastExpose(Widget widg)
{
register int i;
register Widget child;
XmGrabShellWidget gs = (XmGrabShellWidget)widg;
_XmProcessLock();
(*(XtClass(widg)->core_class.expose)) (widg, NULL, NULL);
_XmProcessUnlock();
/* Process each windowed child */
for (i = 0; i < gs->composite.num_children; i++)
{
child = gs->composite.children[i];
if (XtIsWidget(child) && XtIsManaged(child)) {
_XmProcessLock();
(*(XtClass(child)->core_class.expose)) (child, NULL, NULL);
_XmProcessUnlock();
}
}
XFlush(XtDisplay(widg));
DrawBorder(widg);
}
/* ARGSUSED */
static void
DisplayDestroy(
Widget w )
{
XmDisplay dd = (XmDisplay) w ;
XContext context;
_XmProcessLock();
context = displayContext;
_XmProcessUnlock();
XtFree((char *) dd->display.modals);
if (((XmDisplayInfo *)(dd->display.displayInfo))
->excParentPane.pane != (Widget *)NULL)
XtFree((char *) ((XmDisplayInfo *)(dd->display.displayInfo))
->excParentPane.pane);
XtFree((char *) dd->display.displayInfo);
/* Destroy the DropSiteManager object. */
if (dd->display.dsm != NULL)
XtDestroyWidget((Widget) dd->display.dsm);
_XmVirtKeysDestroy (w);
XDeleteContext( XtDisplay( w), None, context) ;
}
/*
* Marked tabs have mark cleared but aren't actually freed.
*/
void
XmTabListFree(XmTabList tablist)
{
int i;
XmTab tab, next;
_XmProcessLock();
if (tablist == NULL) {
_XmProcessUnlock();
return;
}
tab = _XmTabLStart(tablist);
for (i = 1; i < _XmTabLCount(tablist); i++)
{
next = _XmTabNext(tab);
if (_XmTabMark(tab)) _XmTabMark(tab) = FALSE;
else XmTabFree(tab);
tab = next;
}
if (_XmTabMark(tab)) _XmTabMark(tab) = FALSE;
else XmTabFree(tab);
_XmProcessUnlock();
XtFree((char *)tablist);
}
XmTab
XmTabCreate(float value,
unsigned char units,
XmOffsetModel offset_model,
unsigned char alignment,
char *decimal)
{
XmTab tab;
_XmProcessLock();
tab = (XmTab)XtMalloc(sizeof(_XmTabRec));
_XmTabMark(tab) = FALSE;
if (value >= 0)
{
_XmTabValue(tab) = value;
}
else
{
_XmTabValue(tab) = 0.0;
XmeWarning(NULL, NEGATIVE_VALUE_MSG);
}
_XmTabUnits(tab) = units;
_XmTabModel(tab) = offset_model;
_XmTabAlign(tab) = alignment;
_XmTabDecimal(tab) = XtNewString(decimal);
_XmProcessUnlock();
return(tab);
}
/*ARGSUSED*/
static Boolean
SetValues(Widget old,
Widget ref,
Widget new_w,
ArgList args,
Cardinal *num_args)
{
XmExtObject ne = (XmExtObject) new_w;
Widget resParent = ne->ext.logicalParent;
XmWidgetExtData ext = _XmGetWidgetExtData(resParent, ne->ext.extensionType);
Cardinal extSize;
if (resParent)
{
_XmProcessLock();
extSize = XtClass(new_w)->core_class.widget_size;
ext->widget = new_w;
ext->oldWidget = (Widget) _XmExtObjAlloc(extSize);
memcpy((char *)ext->oldWidget, (char *)old, extSize);
ext->reqWidget = (Widget) _XmExtObjAlloc(extSize);
memcpy((char *)ext->reqWidget, (char *)ref, extSize);
_XmProcessUnlock();
/* Convert the necessary fields from unit values to pixel values. */
_XmExtImportArgs(new_w, args, num_args);
}
return FALSE;
}
/*ARGSUSED*/
static XtGeometryResult
GeometryManager(
Widget wid,
XtWidgetGeometry *request,
XtWidgetGeometry *reply ) /* unused */
{
XmGrabShellWidget gs = (XmGrabShellWidget) XtParent(wid);
XtWidgetGeometry modified;
int bw;
XtGeometryResult ret_val;
/* Copy the existing request */
modified = *request;
bw = XtBorderWidth(wid);
/* Add shell's shadow thickness and child's borderwidth */
modified.width += 2*bw + 2*gs->grab_shell.shadow_thickness;
modified.height += 2*bw + 2*gs->grab_shell.shadow_thickness;
_XmProcessLock();
/* Send to vendor shell for final */
ret_val = ((VendorShellClassRec *) vendorShellWidgetClass) ->
composite_class.geometry_manager(wid,&modified,reply);
_XmProcessUnlock();
return ret_val;
}
static void
Initialize(Widget req,
Widget new_w,
ArgList args,
Cardinal *num_args)
{
XmExtObject ne = (XmExtObject) new_w;
XmExtObjectClass ec = (XmExtObjectClass) XtClass(new_w);
Widget resParent = ne->ext.logicalParent;
XmWidgetExtData extData;
XmBaseClassExt *wcePtr = _XmGetBaseClassExtPtr(ec, XmQmotif);
if (!(*wcePtr)->use_sub_resources)
{
if (resParent)
{
extData = (XmWidgetExtData) XtCalloc(1, sizeof(XmWidgetExtDataRec));
_XmPushWidgetExtData(resParent, extData, ne->ext.extensionType);
extData->widget = new_w;
_XmProcessLock();
extData->reqWidget = (Widget)
_XmExtObjAlloc(XtClass(new_w)->core_class.widget_size);
memcpy((char *)extData->reqWidget, (char *)req,
XtClass(new_w)->core_class.widget_size);
_XmProcessUnlock();
/* Convert the fields from unit values to pixel values */
_XmExtImportArgs(new_w, args, num_args);
}
}
}
/* ARGSUSED */
static void
Destroy(
Widget w )
{
XmPrintShellWidget print_shell = (XmPrintShellWidget) w ;
/* need to remove the pixmap from this shell: no sharing
between diff shell and the same shell pointer id can
come up next time */
_XmCleanPixmapCache (XtScreen(w), w);
if (!print_shell->print.xp_connected)
return ;
/*** remove entry in the widget/XPContext table, used in
the event dispatch mechanism */
DeleteFromTable(XpGetContext(XtDisplay(w)), w);
_XmProcessLock();
/* unmark the screen of this print shell in this context */
XDeleteContext(XtDisplay(w), (XID)XtScreen(w),
_XmPrintScreenToShellContext);
/* also maintain a counter of all shells alive */
_XmPrintShellCounter -- ;
_XmProcessUnlock();
}
/*
* This routine uses the mark bit of tabs so that replaced tabs can
* be copied upon replacement and not copied when the rest of the tabs
* are copied or freed when the old tabs are freed.
*/
XmTabList
XmTabListReplacePositions(XmTabList oldlist,
Cardinal *position_list,
XmTab *tabs,
Cardinal tab_count)
{
unsigned int i;
unsigned int cur_pos;
XmTab cur_tab, tab, prev, next;
XmTabList tl;
_XmProcessLock();
if ((oldlist == NULL) ||
(position_list == NULL) ||
(tabs == NULL) || (tab_count == 0)) {
_XmProcessUnlock();
return(oldlist);
}
tl = (XmTabList)XtMalloc(sizeof(_XmTabListRec));
_XmTabLCount(tl) = _XmTabLCount(oldlist);
cur_tab = _XmTabLStart(tl) = _XmTabLStart(oldlist);
cur_pos = 0;
/* Make the replacement in the old list, then copy and free. */
for (i = 0; i < tab_count; i++)
{
cur_tab = GetNthTab(tl, position_list[i],
cur_tab, cur_pos);
cur_pos = position_list[i];
prev = _XmTabPrev(cur_tab);
next = _XmTabNext(cur_tab);
/* replace tab copying */
tab = _XmTabCopy(tabs[i]);
if (prev == cur_tab) { /* only one tab in list */
_XmTabPrev(tab) = _XmTabNext(tab) = tab;
} else {
_XmTabNext(prev) = tab;
_XmTabPrev(tab) = prev;
_XmTabNext(tab) = next;
_XmTabPrev(next) = tab;
}
if (cur_tab == _XmTabLStart(tl))
_XmTabLStart(tl) = tab;
XmTabFree(cur_tab);
cur_tab = tab;
}
XtFree((char *)oldlist);
_XmProcessUnlock();
return(tl);
}
void
XmTabSetValue(XmTab tab,
float value)
{
_XmProcessLock();
if (value >= 0) _XmTabValue(tab) = value;
else XmeWarning(NULL, NEGATIVE_VALUE_MSG);
_XmProcessUnlock();
}
/*ARGSUSED*/
static void
ArmAndActivate(
Widget wid,
XEvent *event,
String *params, /* unused */
Cardinal *num_params) /* unused */
{
XmArrowButtonWidget ab = (XmArrowButtonWidget) wid;
XmArrowButtonCallbackStruct call_value;
XtExposeProc expose;
ab->arrowbutton.selected = TRUE;
_XmProcessLock();
expose = ab->core.widget_class->core_class.expose;
_XmProcessUnlock();
(*(expose)) ((Widget) ab, event, FALSE);
XFlush (XtDisplay (ab));
if (ab->arrowbutton.arm_callback)
{
call_value.reason = XmCR_ARM;
call_value.event = event;
XtCallCallbackList((Widget)ab, ab->arrowbutton.arm_callback, &call_value);
}
call_value.reason = XmCR_ACTIVATE;
call_value.event = event;
call_value.click_count = 1; /* always 1 in kselect */
if (ab->arrowbutton.activate_callback)
{
XFlush (XtDisplay (ab));
XtCallCallbackList((Widget)ab,ab->arrowbutton.activate_callback,
&call_value);
}
ab->arrowbutton.selected = FALSE;
if (ab->arrowbutton.disarm_callback)
{
XFlush (XtDisplay (ab));
call_value.reason = XmCR_DISARM;
XtCallCallbackList((Widget) ab, ab->arrowbutton.disarm_callback,
&call_value);
}
/* If the button is still around, show it released after a short delay */
if (ab->core.being_destroyed == False)
{
ab->arrowbutton.timer =
XtAppAddTimeOut(XtWidgetToApplicationContext((Widget)ab),
(unsigned long) DELAY_DEFAULT,
ArmTimeout, (XtPointer)ab);
}
}
/*
* This copying routine also works with the internal marking scheming used
* by the insert and replace routines.
*/
XmTabList
XmTabListCopy(XmTabList tablist,
int offset,
Cardinal count)
{
XmTabList tl;
XmTab old_tab, tab, next_tab;
unsigned int i;
_XmProcessLock();
if (tablist == NULL) {
_XmProcessUnlock();
return(NULL);
}
tl = (XmTabList)XtMalloc(sizeof(_XmTabListRec));
/* Zero count implies copy from offset to end/beginning */
if (count == 0) count = (_XmTabLCount(tablist) - abs(offset));
if (count > _XmTabLCount(tablist)) count = _XmTabLCount(tablist);
old_tab = GetNthTab(tablist, offset, NULL, 0);
/* If marked, routine called by insert/replace. Don't copy. */
tab = _XmTabMark(old_tab) ? old_tab : _XmTabCopy(old_tab);
/* Add first. */
_XmTabLCount(tl) = count;
_XmTabLStart(tl) = tab;
/* Add rest. */
for (i = 1; i < count; i++)
{
old_tab = (offset >= 0) ? _XmTabNext(old_tab) : _XmTabPrev(old_tab);
/* See above. Don't copy if marked. */
next_tab = _XmTabMark(old_tab)? old_tab : _XmTabCopy(old_tab);
_XmTabNext(tab) = next_tab;
_XmTabPrev(next_tab) = tab;
tab = next_tab;
}
/* Complete circle. */
_XmTabNext(tab) = _XmTabLStart(tl);
_XmTabPrev(_XmTabLStart(tl)) = tab;
_XmProcessUnlock();
return(tl);
}
/************************************************************************
*
* DisplayInsertChild
*
************************************************************************/
static void
DisplayInsertChild(
Widget w )
{
if (XtIsRectObj(w)) {
XtWidgetProc insert_child;
_XmProcessLock();
insert_child = ((CompositeWidgetClass)compositeWidgetClass)
->composite_class.insert_child;
_XmProcessUnlock();
(*insert_child)(w);
}
}
Cardinal
XmTabListTabCount(XmTabList tablist)
{
Cardinal ret_val;
_XmProcessLock();
if (tablist == NULL) {
_XmProcessUnlock();
return 0;
}
ret_val = _XmTabLCount(tablist);
_XmProcessUnlock();
return ret_val;
}
/************************************************************************
*
* DisplayDeleteChild
*
************************************************************************/
static void
DisplayDeleteChild(
Widget w )
{
if (XtIsRectObj(w)) {
XtWidgetProc delete_child;
_XmProcessLock();
delete_child = ((CompositeWidgetClass)compositeWidgetClass)
->composite_class.delete_child;
_XmProcessUnlock();
(*delete_child)(w);
}
}
XtPointer
XmeTraitGet(XtPointer obj, XrmQuark name)
{
XtPointer trait;
XmTraitEntryRec entry;
entry.obj = obj;
entry.name = name;
_XmProcessLock();
trait = _XmGetHashEntry(TraitTable, &entry);
_XmProcessUnlock();
return(trait);
}
XmTab
XmTabListGetTab(XmTabList tablist,
Cardinal position)
{
XmTab ret_val;
_XmProcessLock();
if (tablist == NULL || abs(position) >= _XmTabLCount(tablist)) {
_XmProcessUnlock();
return((XmTab)NULL);
}
ret_val = _XmTabCopy(GetNthTab(tablist, position, NULL, 0));
_XmProcessUnlock();
return ret_val;
}
static void
SetValuesAlmost (Widget gold, Widget gset,
XtWidgetGeometry *req, XtWidgetGeometry *reply)
{
XtAlmostProc set_val_al;
if (reply->request_mode == 0) { /* got turned down, so cope */
Resize (gset);
}
_XmProcessLock();
set_val_al = *SUPERCLASS->core_class.set_values_almost;
_XmProcessUnlock();
(*set_val_al)(gold, gset, req, reply);
}
/*
* fetch the next 'segment' of the external TCS
*/
Boolean
XmStringGetNextSegment(XmStringContext context,
char **text,
XmStringTag *tag,
XmStringDirection *direction,
Boolean *separator )
{
short char_count;
Boolean ret_val;
_XmProcessLock();
ret_val = _XmStringGetNextSegment((_XmStringContext)context,
tag, direction, text, &char_count, separator);
_XmProcessUnlock();
return ret_val;
}
static void
InsertChild(Widget w)
{
if (_XmGadgetWarning(w))
return;
{
XtWidgetProc insert_child;
_XmProcessLock();
insert_child = ( (CompositeWidgetClass) SUPERCLASS)->composite_class.insert_child;
_XmProcessUnlock();
(*insert_child)(w);
}
}
/*
* as close as we can come to Latin1Create without knowing the charset of
* Latin1. This imposes the semantic of \n meaning separator.
*/
XmString
XmStringLtoRCreate(
char *text,
XmStringTag tag )
{
char *start, *end;
Boolean done;
XmString string;
_XmProcessLock();
if (!text) {
_XmProcessUnlock();
return (NULL);
}
start = text;
done = FALSE;
/* Set the direction once only at the beginning. */
string = XmStringDirectionCreate(XmSTRING_DIRECTION_L_TO_R);
while ( ! done) /* loop thu local copy */
{ /* looking for \n */
end = start;
while ((*end != '\0') && (*end != '\n')) end++;
if (*end == '\0')
done = TRUE; /* we are at the end */
/* Don't convert empty string unless it's an initial newline. */
/* Done so StringHeight has clue to size of empty lines. */
if ((start != end) || (start == text))
string = XmStringConcatAndFree (string,
_XmStringNCreate(start, tag,
(int)(end - start))); /* Wyoming 64-bit fix */
/* Make a separator if this isn't the last segment. */
if (!done) {
string = XmStringConcatAndFree(string, XmStringSeparatorCreate());
start = ++end; /* start at next char */
}
}
_XmProcessUnlock();
return (string);
}
Boolean
XmeUseColorObj( void )
{
XmColorObj tmpColorObj = _XmDefaultColorObj;
_XmProcessLock();
if (!tmpColorObj ||
!tmpColorObj->color_obj.colorIsRunning ||
!tmpColorObj->color_obj.useColorObj) {
_XmProcessUnlock();
return False;
}
else {
_XmProcessUnlock();
return True;
}
}
/************************************************************************
* *
* Relayout the main window. *
* *
************************************************************************/
static void
Resize(
Widget wid )
{
CompositeWidgetClass superclass = (CompositeWidgetClass)
xmMainWindowClassRec.core_class.superclass ;
XtWidgetProc resize;
Layout((XmMainWindowWidget) wid);
/* call our superclass layout now that MainWindow has updated
some internal positional fields: offset, pads */
_XmProcessLock();
resize = superclass->core_class.resize;
_XmProcessUnlock();
(*resize)(wid);
}
static void
GetValuesPrehook(Widget new_w,
ArgList args,
Cardinal *num_args)
{
XmExtObjectClass ec = (XmExtObjectClass) XtClass(new_w);
XmBaseClassExt *wcePtr = _XmGetBaseClassExtPtr(ec, XmQmotif);
if ((*wcePtr)->use_sub_resources)
{
_XmProcessLock();
XtGetSubvalues((XtPointer)new_w,
(*wcePtr)->ext_resources,
(*wcePtr)->num_ext_resources,
args, *num_args);
_XmProcessUnlock();
}
}
float
XmTabGetValues(XmTab tab,
unsigned char *units,
XmOffsetModel *offset,
unsigned char *alignment,
char **decimal)
{
float ret_val;
_XmProcessLock();
if (units != NULL) *units = _XmTabUnits(tab);
if (offset != NULL) *offset = _XmTabModel(tab);
if (alignment != NULL) *alignment = _XmTabAlign(tab);
if (decimal != NULL) *decimal = _XmTabDecimal(tab);
ret_val = _XmTabValue(tab);
_XmProcessUnlock();
return ret_val;
}
void
XmeFlushIconFileCache(String path)
{
Cardinal dirNameLen;
Cardinal i;
_XmProcessLock();
/*
* loop thru the dir list. if no path was specified then flush the
* entire cache.
*/
if (path)
dirNameLen = strlen(path);
else
dirNameLen = 0;
for (i = 0; i < cacheList.numDirs; i++) {
DtValidCachedDir currDir;
currDir = (DtValidCachedDir)cacheList.dirs[i];
if (!path ||
((currDir->dirNameLen == dirNameLen) &&
(strncmp(currDir->dirName, path, dirNameLen) == 0))) {
XtFree(currDir->dirName);
XtFree((char *)currDir);
if (path) {
/* ripple down the dir array */
for (; i < cacheList.numDirs - 1; i++)
cacheList.dirs[i] = cacheList.dirs[i+1];
cacheList.numDirs--;
_XmProcessUnlock();
return;
}
}
}
if (path && (i == cacheList.numDirs)) {
_XmProcessUnlock();
return;
}
cacheList.numDirs = 0;
/* don't free the dirList itself */
_XmProcessUnlock();
}
XmStringComponentType
XmStringGetNextComponent(
XmStringContext context,
char **text,
XmStringTag *str_tag,
XmStringDirection *direction,
XmStringComponentType *unknown_tag,
unsigned short *unknown_length,
unsigned char **unknown_value )
{
XmStringComponentType type;
unsigned int len;
XtPointer val;
_XmProcessLock();
type = XmeStringGetComponent((_XmStringContext) context, True, True, &len, &val);
/* Case on return type */
/* Set appropriate return value and return. */
switch (type)
{
case XmSTRING_COMPONENT_DIRECTION:
*direction = *(XmStringDirection *)val;
XtFree((char *)val);
break;
case XmSTRING_COMPONENT_TAG:
*str_tag = (XmStringTag)val;
break;
case XmSTRING_COMPONENT_TEXT:
case XmSTRING_COMPONENT_LOCALE_TEXT:
*text = (char *)val;
break;
case XmSTRING_COMPONENT_SEPARATOR:
case XmSTRING_COMPONENT_END:
break;
default:
*unknown_tag = type;
*unknown_length = len;
*unknown_value = (unsigned char *)val;
type = XmSTRING_COMPONENT_UNKNOWN;
}
_XmProcessUnlock();
return(type);
}
static void
Redisplay(
Widget wid,
XEvent *event,
Region region )
{
XmArrowButtonWidget aw = (XmArrowButtonWidget) wid;
int iwidth, iheight;
XtExposeProc expose;
iwidth = (int) aw->core.width - 2 * aw->primitive.highlight_thickness;
iheight = (int) aw->core.height - 2 * aw->primitive.highlight_thickness;
/* Draw the arrow */
if ((iwidth > 0) && (iheight > 0))
{
if (aw->primitive.shadow_thickness > 0)
XmeDrawShadows(XtDisplay (aw), XtWindow (aw),
aw->primitive.top_shadow_GC,
aw->primitive.bottom_shadow_GC,
aw->primitive.highlight_thickness,
aw->primitive.highlight_thickness,
aw->core.width - 2 * aw->primitive.highlight_thickness,
aw->core.height - 2 * aw->primitive.highlight_thickness,
aw->primitive.shadow_thickness,
XmSHADOW_OUT);
if (aw->arrowbutton.selected && XtIsSensitive(wid))
DrawArrow(aw, aw->primitive.bottom_shadow_GC,
aw->primitive.top_shadow_GC, aw->arrowbutton.arrow_GC);
else
DrawArrow(aw, aw->primitive.top_shadow_GC,
aw->primitive.bottom_shadow_GC,
(XtIsSensitive(wid) ?
aw->arrowbutton.arrow_GC : aw->arrowbutton.insensitive_GC));
}
/* Envelop our superclass expose method */
_XmProcessLock();
expose = xmPrimitiveClassRec.core_class.expose;
_XmProcessUnlock();
(*(expose)) ((Widget) aw, event, region);
}
static void
Resize(Widget wid)
{
Cardinal ac;
Arg av[5] ;
XmCommandWidget cw = (XmCommandWidget)wid;
XtWidgetProc resize;
_XmProcessLock();
resize = xmSelectionBoxClassRec.core_class.resize;
_XmProcessUnlock();
(*resize) ((Widget) cw) ;
/* keep list_visible_item_count in sync with List's visibleItemCount*/
ac = 0 ;
XtSetArg( av[ac], XmNvisibleItemCount, &(cw->selection_box.list_visible_item_count)) ; ++ac
;
XtGetValues( cw->selection_box.list, av, ac) ;
}
/* ARGSUSED */
static void
ArmTimeout(
XtPointer closure,
XtIntervalId *id )
{
XmArrowButtonWidget ab = (XmArrowButtonWidget) closure;
ab->arrowbutton.timer = 0;
if (XtIsRealized((Widget)ab) && XtIsManaged((Widget)ab))
{
XtExposeProc expose;
_XmProcessLock();
expose = ab->core.widget_class->core_class.expose;
_XmProcessUnlock();
(*(expose)) ((Widget) ab, NULL, FALSE);
XFlush (XtDisplay (ab));
}
}
