aboutsummaryrefslogtreecommitdiff
path: root/nx-X11/lib/Xt/Resources.c
diff options
context:
space:
mode:
authorReinhard Tartler <siretart@tauware.de>2011-10-10 17:43:39 +0200
committerReinhard Tartler <siretart@tauware.de>2011-10-10 17:43:39 +0200
commitf4092abdf94af6a99aff944d6264bc1284e8bdd4 (patch)
tree2ac1c9cc16ceb93edb2c4382c088dac5aeafdf0f /nx-X11/lib/Xt/Resources.c
parenta840692edc9c6d19cd7c057f68e39c7d95eb767d (diff)
downloadnx-libs-f4092abdf94af6a99aff944d6264bc1284e8bdd4.tar.gz
nx-libs-f4092abdf94af6a99aff944d6264bc1284e8bdd4.tar.bz2
nx-libs-f4092abdf94af6a99aff944d6264bc1284e8bdd4.zip
Imported nx-X11-3.1.0-1.tar.gznx-X11/3.1.0-1
Summary: Imported nx-X11-3.1.0-1.tar.gz Keywords: Imported nx-X11-3.1.0-1.tar.gz into Git repository
Diffstat (limited to 'nx-X11/lib/Xt/Resources.c')
-rw-r--r--nx-X11/lib/Xt/Resources.c1259
1 files changed, 1259 insertions, 0 deletions
diff --git a/nx-X11/lib/Xt/Resources.c b/nx-X11/lib/Xt/Resources.c
new file mode 100644
index 000000000..7da7d90a2
--- /dev/null
+++ b/nx-X11/lib/Xt/Resources.c
@@ -0,0 +1,1259 @@
+/* $Xorg: Resources.c,v 1.4 2001/02/09 02:03:56 xorgcvs Exp $ */
+
+/***********************************************************
+Copyright 1987, 1988 by Digital Equipment Corporation, Maynard, Massachusetts,
+Copyright 1993 by Sun Microsystems, Inc. Mountain View, CA.
+
+ All Rights Reserved
+
+Permission to use, copy, modify, and distribute this software and its
+documentation for any purpose and without fee is hereby granted,
+provided that the above copyright notice appear in all copies and that
+both that copyright notice and this permission notice appear in
+supporting documentation, and that the names of Digital or Sun not be
+used in advertising or publicity pertaining to distribution of the
+software without specific, written prior permission.
+
+DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
+ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
+DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
+ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
+WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
+ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
+SOFTWARE.
+
+SUN DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FIT-
+NESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL SUN BE LI-
+ABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
+ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
+PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH
+THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+******************************************************************/
+
+/*
+
+Copyright 1987, 1988, 1994, 1998 The Open Group
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the name of The Open Group shall not be
+used in advertising or otherwise to promote the sale, use or other dealings
+in this Software without prior written authorization from The Open Group.
+
+*/
+
+/* $XFree86: xc/lib/Xt/Resources.c,v 1.11tsi Exp $ */
+
+/*LINTLIBRARY*/
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include "IntrinsicI.h"
+#include "VarargsI.h"
+#include "Shell.h"
+#include "ShellP.h"
+#include "StringDefs.h"
+#include <stdio.h>
+
+static XrmClass QBoolean, QString, QCallProc, QImmediate;
+static XrmName QinitialResourcesPersistent, QInitialResourcesPersistent;
+static XrmClass QTranslations, QTranslationTable;
+static XrmName Qtranslations, QbaseTranslations;
+static XrmName Qscreen;
+static XrmClass QScreen;
+
+#ifdef CRAY
+void Cjump();
+char *Cjumpp = (char *) Cjump;
+void Cjump() {}
+#endif
+
+void _XtCopyFromParent(
+ Widget widget,
+ int offset,
+ XrmValue *value)
+{
+ if (widget->core.parent == NULL) {
+ XtAppWarningMsg(XtWidgetToApplicationContext(widget),
+ "invalidParent","xtCopyFromParent",XtCXtToolkitError,
+ "CopyFromParent must have non-NULL parent",
+ (String *)NULL, (Cardinal *)NULL);
+ value->addr = NULL;
+ return;
+ }
+ value->addr = (XPointer)(((char *)widget->core.parent) + offset);
+} /* _XtCopyFromParent */
+
+
+/* If the alignment characteristics of your machine are right, these may be
+ faster */
+
+#ifdef UNALIGNED
+
+void _XtCopyFromArg(
+ XtArgVal src,
+ char* dst,
+ register unsigned int size)
+{
+ if (size == sizeof(long)) *(long *)dst = (long)src;
+ else if (size == sizeof(short)) *(short *)dst = (short)src;
+ else if (size == sizeof(char)) *(char *)dst = (char)src;
+ else if (size == sizeof(XtPointer)) *(XtPointer *)dst = (XtPointer)src;
+ else if (size == sizeof(char*)) *(char **)dst = (char*)src;
+ else if (size == sizeof(XtArgVal)) *(XtArgVal *)dst = src;
+ else if (size > sizeof(XtArgVal))
+ (void) memmove((char *) dst, (char *) src, (int) size);
+ else
+ (void) memmove((char *) dst, (char *) &src, (int) size);
+} /* _XtCopyFromArg */
+
+void _XtCopyToArg(
+ char* src,
+ XtArgVal *dst,
+ register unsigned int size)
+{
+ if (! (*dst)) {
+#ifdef GETVALUES_BUG
+ /* old GetValues semantics (storing directly into arglists) are bad,
+ * but preserve for compatibility as long as arglist contains NULL.
+ */
+ if (size == sizeof(long)) *dst = (XtArgVal)*(long*)src;
+ else if (size == sizeof(short)) *dst = (XtArgVal)*(short*)src;
+ else if (size == sizeof(char)) *dst = (XtArgVal)*(char*)src;
+ else if (size == sizeof(XtPointer)) *dst = (XtArgVal)*(XtPointer*)src;
+ else if (size == sizeof(char*)) *dst = (XtArgVal)*(char**)src;
+ else if (size == sizeof(XtArgVal)) *dst = *(XtArgVal*)src;
+ else (void) memmove((char*)dst, (char*)src, (int)size);
+#else
+ XtErrorMsg("invalidGetValues", "xtGetValues", XtCXtToolkitError,
+ "NULL ArgVal in XtGetValues", (String*) NULL, (Cardinal*) NULL);
+#endif
+ }
+ else {
+ /* proper GetValues semantics: argval is pointer to destination */
+ if (size == sizeof(long)) *((long*)*dst) = *(long*)src;
+ else if (size == sizeof(short)) *((short*)*dst) = *(short*)src;
+ else if (size == sizeof(char)) *((char*)*dst) = *(char*)src;
+ else if (size == sizeof(XtPointer)) *((XtPointer*)*dst) = *(XtPointer*)src;
+ else if (size == sizeof(char*)) *((char**)*dst) = *(char**)src;
+ else if (size == sizeof(XtArgVal)) *((XtArgVal*)*dst)= *(XtArgVal*)src;
+ else (void) memmove((char*)*dst, (char*)src, (int)size);
+ }
+} /* _XtCopyToArg */
+
+static void CopyToArg(
+ char* src,
+ XtArgVal *dst,
+ register unsigned int size)
+{
+ if (! (*dst)) {
+ /* old GetValues semantics (storing directly into arglists) are bad,
+ * but preserve for compatibility as long as arglist contains NULL.
+ */
+ if (size == sizeof(long)) *dst = (XtArgVal)*(long*)src;
+ else if (size == sizeof(short)) *dst = (XtArgVal)*(short*)src;
+ else if (size == sizeof(char)) *dst = (XtArgVal)*(char*)src;
+ else if (size == sizeof(XtPointer)) *dst = (XtArgVal)*(XtPointer*)src;
+ else if (size == sizeof(char*)) *dst = (XtArgVal)*(char**)src;
+ else if (size == sizeof(XtArgVal)) *dst = *(XtArgVal*)src;
+ else (void) memmove((char*)dst, (char*)src, (int)size);
+ }
+ else {
+ /* proper GetValues semantics: argval is pointer to destination */
+ if (size == sizeof(long)) *((long*)*dst) = *(long*)src;
+ else if (size == sizeof(short)) *((short*)*dst) = *(short*)src;
+ else if (size == sizeof(char)) *((char*)*dst) = *(char*)src;
+ else if (size == sizeof(XtPointer)) *((XtPointer*)*dst) = *(XtPointer*)src;
+ else if (size == sizeof(char*)) *((char**)*dst) = *(char**)src;
+ else if (size == sizeof(XtArgVal)) *((XtArgVal*)*dst)= *(XtArgVal*)src;
+ else (void) memmove((char*)*dst, (char*)src, (int)size);
+ }
+} /* CopyToArg */
+
+#else
+void _XtCopyFromArg(
+ XtArgVal src,
+ char* dst,
+ register unsigned int size)
+{
+ if (size > sizeof(XtArgVal))
+ (void) memmove((char *) dst, (char *) src, (int) size);
+ else {
+ union {
+ long longval;
+#ifdef LONG64
+ int intval;
+#endif
+ short shortval;
+ char charval;
+ char* charptr;
+ XtPointer ptr;
+ } u;
+ char *p = (char*)&u;
+ if (size == sizeof(long)) u.longval = (long)src;
+#ifdef LONG64
+ else if (size == sizeof(int)) u.intval = (int)src;
+#endif
+ else if (size == sizeof(short)) u.shortval = (short)src;
+ else if (size == sizeof(char)) u.charval = (char)src;
+ else if (size == sizeof(XtPointer)) u.ptr = (XtPointer)src;
+ else if (size == sizeof(char*)) u.charptr = (char*)src;
+ else p = (char*)&src;
+
+ (void) memmove(dst, p, (int) size);
+ }
+} /* _XtCopyFromArg */
+
+void _XtCopyToArg(
+ char* src,
+ XtArgVal *dst,
+ register unsigned int size)
+{
+ if (!*dst) {
+#ifdef GETVALUES_BUG
+ /* old GetValues semantics (storing directly into arglists) are bad,
+ * but preserve for compatibility as long as arglist contains NULL.
+ */
+ union {
+ long longval;
+#ifdef LONG64
+ int intval;
+#endif
+ short shortval;
+ char charval;
+ char* charptr;
+ XtPointer ptr;
+ } u;
+ if (size <= sizeof(XtArgVal)) {
+ (void) memmove((char*)&u, (char*)src, (int)size );
+ if (size == sizeof(long)) *dst = (XtArgVal)u.longval;
+#ifdef LONG64
+ else if (size == sizeof(int)) *dst = (XtArgVal)u.intval;
+#endif
+ else if (size == sizeof(short)) *dst = (XtArgVal)u.shortval;
+ else if (size == sizeof(char)) *dst = (XtArgVal)u.charval;
+ else if (size == sizeof(char*)) *dst = (XtArgVal)u.charptr;
+ else if (size == sizeof(XtPointer)) *dst = (XtArgVal)u.ptr;
+ else (void) memmove((char*)dst, (char*)src, (int)size );
+ }
+ else
+ (void) memmove((char*)dst, (char*)src, (int)size );
+#else
+ XtErrorMsg("invalidGetValues", "xtGetValues", XtCXtToolkitError,
+ "NULL ArgVal in XtGetValues", (String*) NULL, (Cardinal*) NULL);
+#endif
+ }
+ else {
+ /* proper GetValues semantics: argval is pointer to destination */
+ (void) memmove((char*)*dst, (char*)src, (int)size );
+ }
+} /* _XtCopyToArg */
+
+static void CopyToArg(
+ char* src,
+ XtArgVal *dst,
+ register unsigned int size)
+{
+ if (!*dst) {
+ /* old GetValues semantics (storing directly into arglists) are bad,
+ * but preserve for compatibility as long as arglist contains NULL.
+ */
+ union {
+ long longval;
+#ifdef LONG64
+ int intval;
+#endif
+ short shortval;
+ char charval;
+ char* charptr;
+ XtPointer ptr;
+ } u;
+ if (size <= sizeof(XtArgVal)) {
+ (void) memmove((char*)&u, (char*)src, (int)size );
+ if (size == sizeof(long)) *dst = (XtArgVal)u.longval;
+#ifdef LONG64
+ else if (size == sizeof(int)) *dst = (XtArgVal)u.intval;
+#endif
+ else if (size == sizeof(short)) *dst = (XtArgVal)u.shortval;
+ else if (size == sizeof(char)) *dst = (XtArgVal)u.charval;
+ else if (size == sizeof(char*)) *dst = (XtArgVal)u.charptr;
+ else if (size == sizeof(XtPointer)) *dst = (XtArgVal)u.ptr;
+ else (void) memmove((char*)dst, (char*)src, (int)size );
+ }
+ else
+ (void) memmove((char*)dst, (char*)src, (int)size );
+ }
+ else {
+ /* proper GetValues semantics: argval is pointer to destination */
+ (void) memmove((char*)*dst, (char*)src, (int)size );
+ }
+} /* CopyToArg */
+
+#endif
+
+static Cardinal CountTreeDepth(
+ Widget w)
+{
+ Cardinal count;
+
+ for (count = 1; w != NULL; w = (Widget) w->core.parent)
+ count++;
+
+ return count;
+}
+
+static void GetNamesAndClasses(
+ register Widget w,
+ register XrmNameList names,
+ register XrmClassList classes)
+{
+ register Cardinal length, j;
+ register XrmQuark t;
+ WidgetClass class;
+
+ /* Return null-terminated quark arrays, with length the number of
+ quarks (not including NULL) */
+
+ LOCK_PROCESS;
+ for (length = 0; w != NULL; w = (Widget) w->core.parent) {
+ names[length] = w->core.xrm_name;
+ class = XtClass(w);
+ /* KLUDGE KLUDGE KLUDGE KLUDGE */
+ if (w->core.parent == NULL && XtIsApplicationShell(w)) {
+ classes[length] =
+ ((ApplicationShellWidget) w)->application.xrm_class;
+ } else classes[length] = class->core_class.xrm_class;
+ length++;
+ }
+ UNLOCK_PROCESS;
+ /* They're in backwards order, flop them around */
+ for (j = 0; j < length/2; j++) {
+ t = names[j];
+ names[j] = names[length-j-1];
+ names[length-j-1] = t;
+ t = classes[j];
+ classes[j] = classes[length-j-1];
+ classes[length-j-1] = t;
+ }
+ names[length] = NULLQUARK;
+ classes[length] = NULLQUARK;
+} /* GetNamesAndClasses */
+
+
+/* Spiffy fast compiled form of resource list. */
+/* XtResourceLists are compiled in-place into XrmResourceLists */
+/* All atoms are replaced by quarks, and offsets are -offset-1 to */
+/* indicate that this list has been compiled already */
+
+void _XtCompileResourceList(
+ register XtResourceList resources,
+ Cardinal num_resources)
+{
+ register Cardinal count;
+
+#define xrmres ((XrmResourceList) resources)
+#define PSToQ XrmPermStringToQuark
+
+ for (count = 0; count < num_resources; resources++, count++) {
+ xrmres->xrm_name = PSToQ(resources->resource_name);
+ xrmres->xrm_class = PSToQ(resources->resource_class);
+ xrmres->xrm_type = PSToQ(resources->resource_type);
+ xrmres->xrm_offset = (Cardinal)
+ (-(int)resources->resource_offset - 1);
+ xrmres->xrm_default_type = PSToQ(resources->default_type);
+ }
+#undef PSToQ
+#undef xrmres
+} /* _XtCompileResourceList */
+
+/* Like _XtCompileResourceList, but strings are not permanent */
+static void XrmCompileResourceListEphem(
+ register XtResourceList resources,
+ Cardinal num_resources)
+{
+ register Cardinal count;
+
+#define xrmres ((XrmResourceList) resources)
+
+ for (count = 0; count < num_resources; resources++, count++) {
+ xrmres->xrm_name = StringToName(resources->resource_name);
+ xrmres->xrm_class = StringToClass(resources->resource_class);
+ xrmres->xrm_type = StringToQuark(resources->resource_type);
+ xrmres->xrm_offset = (Cardinal)
+ (-(int)resources->resource_offset - 1);
+ xrmres->xrm_default_type = StringToQuark(resources->default_type);
+ }
+#undef xrmres
+} /* XrmCompileResourceListEphem */
+
+static void BadSize(
+ Cardinal size,
+ XrmQuark name)
+{
+ String params[2];
+ Cardinal num_params = 2;
+
+ params[0] = (String)(long) size;
+ params[1] = XrmQuarkToString(name);
+ XtWarningMsg("invalidSizeOverride", "xtDependencies", XtCXtToolkitError,
+ "Representation size %d must match superclass's to override %s",
+ params, &num_params);
+} /* BadType */
+
+/*
+ * Create a new resource list, with the class resources following the
+ * superclass's resources. If a resource in the class list overrides
+ * a superclass resource, then just replace the superclass entry in place.
+ *
+ * At the same time, add a level of indirection to the XtResourceList to
+ * create and XrmResourceList.
+ */
+void _XtDependencies(
+ XtResourceList *class_resp, /* VAR */
+ Cardinal *class_num_resp, /* VAR */
+ XrmResourceList *super_res,
+ Cardinal super_num_res,
+ Cardinal super_widget_size)
+{
+ register XrmResourceList *new_res;
+ Cardinal new_num_res;
+ XrmResourceList class_res = (XrmResourceList) *class_resp;
+ Cardinal class_num_res = *class_num_resp;
+ register Cardinal i, j;
+ Cardinal new_next;
+
+ if (class_num_res == 0) {
+ /* Just point to superclass resource list */
+ *class_resp = (XtResourceList) super_res;
+ *class_num_resp = super_num_res;
+ return;
+ }
+
+ /* Allocate and initialize new_res with superclass resource pointers */
+ new_num_res = super_num_res + class_num_res;
+ new_res = (XrmResourceList *) __XtMalloc(new_num_res*sizeof(XrmResourceList));
+ if (super_num_res > 0)
+ XtMemmove(new_res, super_res, super_num_res * sizeof(XrmResourceList));
+
+ /* Put pointers to class resource entries into new_res */
+ new_next = super_num_res;
+ for (i = 0; i < class_num_res; i++) {
+ if ((Cardinal)(-class_res[i].xrm_offset-1) < super_widget_size) {
+ /* Probably an override of superclass resources--look for overlap */
+ for (j = 0; j < super_num_res; j++) {
+ if (class_res[i].xrm_offset == new_res[j]->xrm_offset) {
+ /* Spec is silent on what fields subclass can override.
+ * The only two of real concern are type & size.
+ * Although allowing type to be over-ridden introduces
+ * the possibility of errors, it's at present the only
+ * reasonable way to allow a subclass to force a private
+ * converter to be invoked for a subset of fields.
+ */
+ /* We do insist that size be identical to superclass */
+ if (class_res[i].xrm_size != new_res[j]->xrm_size) {
+ BadSize(class_res[i].xrm_size,
+ (XrmQuark) class_res[i].xrm_name);
+ class_res[i].xrm_size = new_res[j]->xrm_size;
+ }
+ new_res[j] = &(class_res[i]);
+ new_num_res--;
+ goto NextResource;
+ }
+ } /* for j */
+ }
+ /* Not an overlap, add an entry to new_res */
+ new_res[new_next++] = &(class_res[i]);
+NextResource:;
+ } /* for i */
+
+ /* Okay, stuff new resources back into class record */
+ *class_resp = (XtResourceList) new_res;
+ *class_num_resp = new_num_res;
+} /* _XtDependencies */
+
+
+void _XtResourceDependencies(
+ WidgetClass wc)
+{
+ WidgetClass sc;
+
+ sc = wc->core_class.superclass;
+ if (sc == NULL) {
+ _XtDependencies(&(wc->core_class.resources),
+ &(wc->core_class.num_resources),
+ (XrmResourceList *) NULL, (unsigned)0, (unsigned)0);
+ } else {
+ _XtDependencies(&(wc->core_class.resources),
+ &(wc->core_class.num_resources),
+ (XrmResourceList *) sc->core_class.resources,
+ sc->core_class.num_resources,
+ sc->core_class.widget_size);
+ }
+} /* _XtResourceDependencies */
+
+void _XtConstraintResDependencies(
+ ConstraintWidgetClass wc)
+{
+ ConstraintWidgetClass sc;
+
+ if (wc == (ConstraintWidgetClass) constraintWidgetClass) {
+ _XtDependencies(&(wc->constraint_class.resources),
+ &(wc->constraint_class.num_resources),
+ (XrmResourceList *)NULL, (unsigned)0, (unsigned)0);
+ } else {
+ sc = (ConstraintWidgetClass) wc->core_class.superclass;
+ _XtDependencies(&(wc->constraint_class.resources),
+ &(wc->constraint_class.num_resources),
+ (XrmResourceList *) sc->constraint_class.resources,
+ sc->constraint_class.num_resources,
+ sc->constraint_class.constraint_size);
+ }
+} /* _XtConstraintResDependencies */
+
+
+
+
+XrmResourceList* _XtCreateIndirectionTable (
+ XtResourceList resources,
+ Cardinal num_resources)
+{
+ register Cardinal idx;
+ XrmResourceList* table;
+
+ table = (XrmResourceList*)__XtMalloc(num_resources * sizeof(XrmResourceList));
+ for (idx = 0; idx < num_resources; idx++)
+ table[idx] = (XrmResourceList)(&(resources[idx]));
+ return table;
+}
+
+static XtCacheRef *GetResources(
+ Widget widget, /* Widget resources are associated with */
+ char* base, /* Base address of memory to write to */
+ XrmNameList names, /* Full inheritance name of widget */
+ XrmClassList classes, /* Full inheritance class of widget */
+ XrmResourceList* table, /* The list of resources required. */
+ unsigned num_resources, /* number of items in resource list */
+ XrmQuarkList quark_args, /* Arg names quarkified */
+ ArgList args, /* ArgList to override resources */
+ unsigned num_args, /* number of items in arg list */
+ XtTypedArgList typed_args, /* Typed arg list to override resources */
+ Cardinal* pNumTypedArgs, /* number of items in typed arg list */
+ Boolean tm_hack) /* do baseTranslations */
+{
+/*
+ * assert: *pNumTypedArgs == 0 if num_args > 0
+ * assert: num_args == 0 if *pNumTypedArgs > 0
+ */
+#define SEARCHLISTLEN 100
+#define MAXRESOURCES 400
+
+ XrmValue value;
+ XrmQuark rawType;
+ XrmValue convValue;
+ XrmHashTable stackSearchList[SEARCHLISTLEN];
+ XrmHashTable *searchList = stackSearchList;
+ unsigned int searchListSize = SEARCHLISTLEN;
+ Boolean found[MAXRESOURCES];
+ int typed[MAXRESOURCES];
+ XtCacheRef cache_ref[MAXRESOURCES];
+ XtCacheRef *cache_ptr, *cache_base;
+ Boolean persistent_resources = True;
+ Boolean found_persistence = False;
+ int num_typed_args = *pNumTypedArgs;
+ XrmDatabase db;
+ Boolean do_tm_hack = False;
+
+ if ((args == NULL) && (num_args != 0)) {
+ XtAppWarningMsg(XtWidgetToApplicationContext(widget),
+ "invalidArgCount","getResources",XtCXtToolkitError,
+ "argument count > 0 on NULL argument list",
+ (String *)NULL, (Cardinal *)NULL);
+ num_args = 0;
+ }
+ if (num_resources == 0) {
+ return NULL;
+ } else if (num_resources >= MAXRESOURCES) {
+ XtAppWarningMsg(XtWidgetToApplicationContext(widget),
+ "invalidResourceCount","getResources",XtCXtToolkitError,
+ "too many resources",
+ (String *)NULL, (Cardinal *)NULL);
+ return NULL;
+ } else if (table == NULL) {
+ XtAppWarningMsg(XtWidgetToApplicationContext(widget),
+ "invalidResourceCount","getResources",XtCXtToolkitError,
+ "resource count > 0 on NULL resource list",
+ (String *)NULL, (Cardinal *)NULL);
+ return NULL;
+ }
+
+ /* Mark each resource as not found on arg list */
+ bzero((char *) found, (int) (num_resources * sizeof(Boolean)));
+ bzero((char *) typed, (int) (num_resources * sizeof(int)));
+
+ /* Copy the args into the resources, mark each as found */
+ {
+ register ArgList arg;
+ register XtTypedArgList typed_arg;
+ register XrmName argName;
+ register Cardinal j;
+ register int i;
+ register XrmResourceList rx;
+ register XrmResourceList *res;
+ for (arg = args, i = 0; (Cardinal)i < num_args; i++, arg++) {
+ argName = quark_args[i];
+ if (argName == QinitialResourcesPersistent) {
+ persistent_resources = (Boolean)arg->value;
+ found_persistence = True;
+ continue;
+ }
+ for (j = 0, res = table; j < num_resources; j++, res++) {
+ rx = *res;
+ if (argName == rx->xrm_name) {
+ _XtCopyFromArg(
+ arg->value,
+ base - rx->xrm_offset - 1,
+ rx->xrm_size);
+ found[j] = TRUE;
+ break;
+ }
+ }
+ }
+ for (typed_arg = typed_args, i = 0; i < num_typed_args;
+ i++, typed_arg++) {
+ register XrmRepresentation argType;
+ argName = quark_args[i];
+ argType = (typed_arg->type == NULL) ? NULLQUARK
+ : XrmStringToRepresentation(typed_arg->type);
+ if (argName == QinitialResourcesPersistent) {
+ persistent_resources = (Boolean)typed_arg->value;
+ found_persistence = True;
+ break;
+ }
+ for (j = 0, res = table; j < num_resources; j++, res++) {
+ rx = *res;
+ if (argName == rx->xrm_name) {
+ if (argType != NULLQUARK && argType != rx->xrm_type) {
+ typed[j] = i + 1;
+ } else {
+ _XtCopyFromArg(
+ typed_arg->value,
+ base - rx->xrm_offset - 1,
+ rx->xrm_size);
+ }
+ found[j] = TRUE;
+ break;
+ }
+ }
+ }
+ }
+
+ /* Ask resource manager for a list of database levels that we can
+ do a single-level search on each resource */
+
+ db = XtScreenDatabase(XtScreenOfObject(widget));
+ while (!XrmQGetSearchList(db, names, classes,
+ searchList, searchListSize)) {
+ if (searchList == stackSearchList)
+ searchList = NULL;
+ searchList = (XrmHashTable*)XtRealloc((char*)searchList,
+ sizeof(XrmHashTable) *
+ (searchListSize *= 2));
+ }
+
+ if (persistent_resources)
+ cache_base = NULL;
+ else
+ cache_base = cache_ref;
+ /* geez, this is an ugly mess */
+ if (XtIsShell(widget)) {
+ register XrmResourceList *res;
+ register Cardinal j;
+ Screen *oldscreen = widget->core.screen;
+
+ /* look up screen resource first, since real rdb depends on it */
+ for (res = table, j = 0; j < num_resources; j++, res++) {
+ if ((*res)->xrm_name != Qscreen)
+ continue;
+ if (typed[j]) {
+ register XtTypedArg* arg = typed_args + typed[j] - 1;
+ XrmQuark from_type;
+ XrmValue from_val, to_val;
+
+ from_type = StringToQuark(arg->type);
+ from_val.size = arg->size;
+ if ((from_type == QString) || ((unsigned) arg->size > sizeof(XtArgVal)))
+ from_val.addr = (XPointer)arg->value;
+ else
+ from_val.addr = (XPointer)&arg->value;
+ to_val.size = sizeof(Screen*);
+ to_val.addr = (XPointer)&widget->core.screen;
+ found[j] = _XtConvert(widget, from_type, &from_val,
+ QScreen, &to_val, cache_base);
+ if (cache_base && *cache_base)
+ cache_base++;
+ }
+ if (!found[j]) {
+ if (XrmQGetSearchResource(searchList, Qscreen, QScreen,
+ &rawType, &value)) {
+ if (rawType != QScreen) {
+ convValue.size = sizeof(Screen*);
+ convValue.addr = (XPointer)&widget->core.screen;
+ (void)_XtConvert(widget, rawType, &value,
+ QScreen, &convValue, cache_base);
+ if (cache_base && *cache_base)
+ cache_base++;
+ } else {
+ widget->core.screen = *((Screen **)value.addr);
+ }
+ }
+ }
+ break;
+ }
+ /* now get the database to use for the rest of the resources */
+ if (widget->core.screen != oldscreen) {
+ db = XtScreenDatabase(widget->core.screen);
+ while (!XrmQGetSearchList(db, names, classes,
+ searchList, searchListSize)) {
+ if (searchList == stackSearchList)
+ searchList = NULL;
+ searchList = (XrmHashTable*)XtRealloc((char*)searchList,
+ sizeof(XrmHashTable) *
+ (searchListSize *= 2));
+ }
+ }
+ }
+
+ /* go to the resource manager for those resources not found yet */
+ /* if it's not in the resource database use the default value */
+
+ {
+ register XrmResourceList rx;
+ register XrmResourceList *res;
+ register Cardinal j;
+ register XrmRepresentation xrm_type;
+ register XrmRepresentation xrm_default_type;
+ char char_val;
+ short short_val;
+ int int_val;
+ long long_val;
+ char* char_ptr;
+
+ if (!found_persistence) {
+ if (XrmQGetSearchResource(searchList, QinitialResourcesPersistent,
+ QInitialResourcesPersistent, &rawType, &value)) {
+ if (rawType != QBoolean) {
+ convValue.size = sizeof(Boolean);
+ convValue.addr = (XPointer)&persistent_resources;
+ (void)_XtConvert(widget, rawType, &value, QBoolean,
+ &convValue, NULL);
+ }
+ else
+ persistent_resources = *(Boolean*)value.addr;
+ }
+ }
+ if (persistent_resources)
+ cache_ptr = NULL;
+ else if (cache_base)
+ cache_ptr = cache_base;
+ else
+ cache_ptr = cache_ref;
+
+ for (res = table, j = 0; j < num_resources; j++, res++) {
+ rx = *res;
+ xrm_type = rx->xrm_type;
+ if (typed[j]) {
+ register XtTypedArg* arg = typed_args + typed[j] - 1;
+
+ /*
+ * This resource value has been specified as a typed arg and
+ * has to be converted. Typed arg conversions are done here
+ * to correctly interpose them with normal resource conversions.
+ */
+ XrmQuark from_type;
+ XrmValue from_val, to_val;
+ Boolean converted;
+
+ from_type = StringToQuark(arg->type);
+ from_val.size = arg->size;
+ if ((from_type == QString) || ((unsigned) arg->size > sizeof(XtArgVal)))
+ from_val.addr = (XPointer)arg->value;
+ else
+ from_val.addr = (XPointer)&arg->value;
+ to_val.size = rx->xrm_size;
+ to_val.addr = base - rx->xrm_offset - 1;
+ converted = _XtConvert(widget, from_type, &from_val,
+ xrm_type, &to_val, cache_ptr);
+ if (converted) {
+
+ /* Copy the converted value back into the typed argument.
+ * normally the data should be <= sizeof(XtArgVal) and
+ * is stored directly into the 'value' field .... BUT
+ * if the resource size is greater than sizeof(XtArgVal)
+ * then we dynamically alloc a block of store to hold the
+ * data and zap a copy in there !!! .... freeing it later
+ * the size field in the typed arg is negated to indicate
+ * that the store pointed to by the value field is
+ * dynamic .......
+ * "freeing" happens in the case of _XtCreate after the
+ * CallInitialize ..... other clients of GetResources
+ * using typed args should be aware of the need to free
+ * this store .....
+ */
+
+ if(rx->xrm_size > sizeof(XtArgVal)) {
+ arg->value = (XtArgVal) __XtMalloc(rx->xrm_size);
+ arg->size = -(arg->size);
+ } else { /* will fit - copy directly into value field */
+ arg->value = (XtArgVal) NULL;
+ }
+ CopyToArg((char *)(base - rx->xrm_offset - 1),
+ &arg->value, rx->xrm_size);
+
+ } else {
+ /* Conversion failed. Get default value. */
+ found[j] = False;
+ }
+
+ if (cache_ptr && *cache_ptr)
+ cache_ptr++;
+ }
+
+ if (!found[j]) {
+ Boolean already_copied = False;
+ Boolean have_value = False;
+
+ if (XrmQGetSearchResource(searchList,
+ rx->xrm_name, rx->xrm_class, &rawType, &value)) {
+ if (rawType != xrm_type) {
+ convValue.size = rx->xrm_size;
+ convValue.addr = (XPointer)(base - rx->xrm_offset - 1);
+ already_copied = have_value =
+ _XtConvert(widget, rawType, &value,
+ xrm_type, &convValue, cache_ptr);
+ if (cache_ptr && *cache_ptr)
+ cache_ptr++;
+ } else have_value = True;
+ if (have_value && rx->xrm_name == Qtranslations)
+ do_tm_hack = True;
+ }
+ LOCK_PROCESS;
+ if (!have_value
+ && ((rx->xrm_default_type == QImmediate)
+ || (rx->xrm_default_type == xrm_type)
+ || (rx->xrm_default_addr != NULL))) {
+ /* Convert default value to proper type */
+ xrm_default_type = rx->xrm_default_type;
+ if (xrm_default_type == QCallProc) {
+#ifdef CRAY
+ if ( (int) Cjumpp != (int) Cjump)
+ (*(XtResourceDefaultProc)
+ (((int)(rx->xrm_default_addr))<<2))(
+ widget,-(rx->xrm_offset+1), &value);
+ else
+#endif
+ (*(XtResourceDefaultProc)(rx->xrm_default_addr))(
+ widget,-(rx->xrm_offset+1), &value);
+
+ } else if (xrm_default_type == QImmediate) {
+ /* XtRImmediate == XtRString for type XtRString */
+ if (xrm_type == QString) {
+ value.addr = rx->xrm_default_addr;
+ } else if (rx->xrm_size == sizeof(int)) {
+ int_val = (int)(long)rx->xrm_default_addr;
+ value.addr = (XPointer) &int_val;
+ } else if (rx->xrm_size == sizeof(short)) {
+ short_val = (short)(long)rx->xrm_default_addr;
+ value.addr = (XPointer) &short_val;
+ } else if (rx->xrm_size == sizeof(char)) {
+ char_val = (char)(long)rx->xrm_default_addr;
+ value.addr = (XPointer) &char_val;
+ } else if (rx->xrm_size == sizeof(long)) {
+ long_val = (long)rx->xrm_default_addr;
+ value.addr = (XPointer) &long_val;
+ } else if (rx->xrm_size == sizeof(char*)) {
+ char_ptr = (char*)rx->xrm_default_addr;
+ value.addr = (XPointer) &char_ptr;
+ } else {
+ value.addr = (XPointer) &(rx->xrm_default_addr);
+ }
+ } else if (xrm_default_type == xrm_type) {
+ value.addr = rx->xrm_default_addr;
+ } else {
+ value.addr = rx->xrm_default_addr;
+ if (xrm_default_type == QString) {
+ value.size = strlen((char *)value.addr) + 1;
+ } else {
+ value.size = sizeof(XtPointer);
+ }
+ convValue.size = rx->xrm_size;
+ convValue.addr = (XPointer)(base - rx->xrm_offset - 1);
+ already_copied =
+ _XtConvert(widget, xrm_default_type, &value,
+ xrm_type, &convValue, cache_ptr);
+ if (!already_copied)
+ value.addr = NULL;
+ if (cache_ptr && *cache_ptr)
+ cache_ptr++;
+ }
+ }
+ if (!already_copied) {
+ if (xrm_type == QString) {
+ *((String*)(base - rx->xrm_offset - 1)) = value.addr;
+ } else {
+ if (value.addr != NULL) {
+ XtMemmove(base - rx->xrm_offset - 1,
+ value.addr, rx->xrm_size);
+ } else {
+ /* didn't get value, initialize to NULL... */
+ XtBZero(base - rx->xrm_offset - 1, rx->xrm_size);
+ }
+ }
+ }
+ UNLOCK_PROCESS;
+
+ if (typed[j]) {
+ /*
+ * This resource value was specified as a typed arg.
+ * However, the default value is being used here since
+ * type type conversion failed, so we compress the list.
+ */
+ register XtTypedArg* arg = typed_args + typed[j] - 1;
+ register int i;
+
+ for (i = num_typed_args - typed[j]; i; i--, arg++) {
+ *arg = *(arg+1);
+ }
+ num_typed_args--;
+ }
+ }
+ }
+ if (tm_hack)
+ widget->core.tm.current_state = NULL;
+ if (tm_hack &&
+ (!widget->core.tm.translations ||
+ (do_tm_hack &&
+ widget->core.tm.translations->operation != XtTableReplace)) &&
+ XrmQGetSearchResource(searchList, QbaseTranslations,
+ QTranslations, &rawType, &value)) {
+ if (rawType != QTranslationTable) {
+ convValue.size = sizeof(XtTranslations);
+ convValue.addr = (XPointer)&widget->core.tm.current_state;
+ (void)_XtConvert(widget, rawType, &value,
+ QTranslationTable, &convValue, cache_ptr);
+ if (cache_ptr && *cache_ptr)
+ cache_ptr++;
+ } else {
+ *((XtTranslations *)&widget->core.tm.current_state) =
+ *((XtTranslations *)value.addr);
+ }
+ }
+ }
+ if ((Cardinal)num_typed_args != *pNumTypedArgs) *pNumTypedArgs = num_typed_args;
+ if (searchList != stackSearchList) XtFree((char*)searchList);
+ if (!cache_ptr)
+ cache_ptr = cache_base;
+ if (cache_ptr && cache_ptr != cache_ref) {
+ int cache_ref_size = cache_ptr - cache_ref;
+ XtCacheRef *refs = (XtCacheRef*)
+ __XtMalloc((unsigned)sizeof(XtCacheRef)*(cache_ref_size + 1));
+ (void) memmove(refs, cache_ref, sizeof(XtCacheRef)*cache_ref_size );
+ refs[cache_ref_size] = NULL;
+ return refs;
+ }
+ return (XtCacheRef*)NULL;
+}
+
+
+
+static void CacheArgs(
+ ArgList args,
+ Cardinal num_args,
+ XtTypedArgList typed_args,
+ Cardinal num_typed_args,
+ XrmQuarkList quark_cache,
+ Cardinal num_quarks,
+ XrmQuarkList *pQuarks) /* RETURN */
+{
+ register XrmQuarkList quarks;
+ register Cardinal i;
+ register Cardinal count;
+
+ count = (args != NULL) ? num_args : num_typed_args;
+
+ if (num_quarks < count) {
+ quarks = (XrmQuarkList) __XtMalloc(count * sizeof(XrmQuark));
+ } else {
+ quarks = quark_cache;
+ }
+ *pQuarks = quarks;
+
+ if (args != NULL) {
+ for (i = count; i; i--)
+ *quarks++ = StringToQuark((args++)->name);
+ }
+ else {
+ for (i = count; i; i--)
+ *quarks++ = StringToQuark((typed_args++)->name);
+ }
+}
+
+#define FreeCache(cache, pointer) \
+ if (cache != pointer) XtFree((char *)pointer)
+
+
+XtCacheRef *_XtGetResources(
+ register Widget w,
+ ArgList args,
+ Cardinal num_args,
+ XtTypedArgList typed_args,
+ Cardinal* num_typed_args)
+{
+ XrmName *names, names_s[50];
+ XrmClass *classes, classes_s[50];
+ XrmQuark quark_cache[100];
+ XrmQuarkList quark_args;
+ WidgetClass wc;
+ ConstraintWidgetClass cwc;
+ XtCacheRef *cache_refs;
+ Cardinal count;
+
+ wc = XtClass(w);
+
+ count = CountTreeDepth(w);
+ names = (XrmName*) XtStackAlloc (count * sizeof(XrmName), names_s);
+ classes = (XrmClass*) XtStackAlloc (count * sizeof(XrmClass), classes_s);
+ if (names == NULL || classes == NULL) _XtAllocError(NULL);
+
+ /* Get names, classes for widget and ancestors */
+ GetNamesAndClasses(w, names, classes);
+
+ /* Compile arg list into quarks */
+ CacheArgs(args, num_args, typed_args, *num_typed_args, quark_cache,
+ XtNumber(quark_cache), &quark_args);
+
+ /* Get normal resources */
+ LOCK_PROCESS;
+ cache_refs = GetResources(w, (char*)w, names, classes,
+ (XrmResourceList *) wc->core_class.resources,
+ wc->core_class.num_resources, quark_args, args, num_args,
+ typed_args, num_typed_args, XtIsWidget(w));
+
+ if (w->core.constraints != NULL) {
+ cwc = (ConstraintWidgetClass) XtClass(w->core.parent);
+ (void) GetResources(w, (char*)w->core.constraints, names, classes,
+ (XrmResourceList *) cwc->constraint_class.resources,
+ cwc->constraint_class.num_resources,
+ quark_args, args, num_args, typed_args, num_typed_args, False);
+ }
+ FreeCache(quark_cache, quark_args);
+ UNLOCK_PROCESS;
+ XtStackFree((XtPointer)names, names_s);
+ XtStackFree((XtPointer)classes, classes_s);
+ return cache_refs;
+} /* _XtGetResources */
+
+
+void _XtGetSubresources (
+ Widget w, /* Widget "parent" of subobject */
+ XtPointer base, /* Base address to write to */
+ const char* name, /* name of subobject */
+ const char* class, /* class of subobject */
+ XtResourceList resources, /* resource list for subobject */
+ Cardinal num_resources,
+ ArgList args, /* arg list to override resources */
+ Cardinal num_args,
+ XtTypedArgList typed_args,
+ Cardinal num_typed_args)
+{
+ XrmName *names, names_s[50];
+ XrmClass *classes, classes_s[50];
+ XrmQuark quark_cache[100];
+ XrmQuarkList quark_args;
+ XrmResourceList* table;
+ Cardinal count, ntyped_args = num_typed_args;
+ WIDGET_TO_APPCON(w);
+
+ if (num_resources == 0) return;
+
+ LOCK_APP(app);
+ count = CountTreeDepth(w);
+ count++; /* make sure there's enough room for name and class */
+ names = (XrmName*) XtStackAlloc(count * sizeof(XrmName), names_s);
+ classes = (XrmClass*) XtStackAlloc(count * sizeof(XrmClass), classes_s);
+ if (names == NULL || classes == NULL) _XtAllocError(NULL);
+
+ /* Get full name, class of subobject */
+ GetNamesAndClasses(w, names, classes);
+ count -= 2;
+ names[count] = StringToName(name);
+ classes[count] = StringToClass(class);
+ count++;
+ names[count] = NULLQUARK;
+ classes[count] = NULLQUARK;
+
+ /* Compile arg list into quarks */
+ CacheArgs(args, num_args, typed_args, num_typed_args,
+ quark_cache, XtNumber(quark_cache), &quark_args);
+
+ /* Compile resource list if needed */
+ if (((int) resources->resource_offset) >= 0) {
+ XrmCompileResourceListEphem(resources, num_resources);
+ }
+ table = _XtCreateIndirectionTable(resources, num_resources);
+ (void) GetResources(w, (char*)base, names, classes, table, num_resources,
+ quark_args, args, num_args,
+ typed_args, &ntyped_args, False);
+ FreeCache(quark_cache, quark_args);
+ XtFree((char *)table);
+ XtStackFree((XtPointer)names, names_s);
+ XtStackFree((XtPointer)classes, classes_s);
+ UNLOCK_APP(app);
+}
+
+void XtGetSubresources (
+ Widget w, /* Widget "parent" of subobject */
+ XtPointer base, /* Base address to write to */
+ _Xconst char* name, /* name of subobject */
+ _Xconst char* class, /* class of subobject */
+ XtResourceList resources, /* resource list for subobject */
+ Cardinal num_resources,
+ ArgList args, /* arg list to override resources */
+ Cardinal num_args)
+{
+ _XtGetSubresources (w, base, name, class, resources, num_resources, args, num_args, NULL, 0);
+}
+
+
+void _XtGetApplicationResources (
+ Widget w, /* Application shell widget */
+ XtPointer base, /* Base address to write to */
+ XtResourceList resources, /* resource list for subobject */
+ Cardinal num_resources,
+ ArgList args, /* arg list to override resources */
+ Cardinal num_args,
+ XtTypedArgList typed_args,
+ Cardinal num_typed_args)
+{
+ XrmName *names, names_s[50];
+ XrmClass *classes, classes_s[50];
+ XrmQuark quark_cache[100];
+ XrmQuarkList quark_args;
+ XrmResourceList* table;
+ Cardinal count, ntyped_args = num_typed_args;
+#ifdef XTHREADS
+ XtAppContext app;
+#endif
+
+ if (num_resources == 0) return;
+
+#ifdef XTHREADS
+ if (w == NULL) app = _XtDefaultAppContext();
+ else app = XtWidgetToApplicationContext(w);
+#endif
+
+ LOCK_APP(app);
+ /* Get full name, class of application */
+ if (w == NULL) {
+ /* hack for R2 compatibility */
+ XtPerDisplay pd = _XtGetPerDisplay(_XtDefaultAppContext()->list[0]);
+ names = (XrmName*) XtStackAlloc (2 * sizeof(XrmName), names_s);
+ classes = (XrmClass*) XtStackAlloc (2 * sizeof(XrmClass), classes_s);
+ names[0] = pd->name;
+ names[1] = NULLQUARK;
+ classes[0] = pd->class;
+ classes[1] = NULLQUARK;
+ }
+ else {
+ count = CountTreeDepth(w);
+ names = (XrmName*) XtStackAlloc(count * sizeof(XrmName), names_s);
+ classes = (XrmClass*) XtStackAlloc(count * sizeof(XrmClass), classes_s);
+ if (names == NULL || classes == NULL) _XtAllocError(NULL);
+ GetNamesAndClasses(w, names, classes);
+ }
+
+ /* Compile arg list into quarks */
+ CacheArgs(args, num_args, typed_args, num_typed_args, quark_cache,
+ XtNumber(quark_cache), &quark_args);
+ /* Compile resource list if needed */
+ if (((int) resources->resource_offset) >= 0) {
+#ifdef CRAY2
+ if (base == 0) { /* this client is non-portable, but... */
+ int count;
+ XtResourceList res = resources;
+ for (count = 0; count < num_resources; res++, count++) {
+ res->resource_offset *= sizeof(long);
+ }
+ }
+#endif /* CRAY2 */
+ XrmCompileResourceListEphem(resources, num_resources);
+ }
+ table = _XtCreateIndirectionTable(resources,num_resources);
+
+ (void) GetResources(w, (char*)base, names, classes, table, num_resources,
+ quark_args, args, num_args,
+ typed_args, &ntyped_args, False);
+ FreeCache(quark_cache, quark_args);
+ XtFree((char *)table);
+ if (w != NULL) {
+ XtStackFree((XtPointer)names, names_s);
+ XtStackFree((XtPointer)classes, classes_s);
+ }
+ UNLOCK_APP(app);
+}
+
+void XtGetApplicationResources (
+ Widget w, /* Application shell widget */
+ XtPointer base, /* Base address to write to */
+ XtResourceList resources, /* resource list for subobject */
+ Cardinal num_resources,
+ ArgList args, /* arg list to override resources */
+ Cardinal num_args)
+{
+ _XtGetApplicationResources(w, base, resources, num_resources, args, num_args, NULL, 0);
+}
+
+static Boolean initialized = FALSE;
+
+void _XtResourceListInitialize(void)
+{
+ LOCK_PROCESS;
+ if (initialized) {
+ XtWarningMsg("initializationError","xtInitialize",XtCXtToolkitError,
+ "Initializing Resource Lists twice",
+ (String *)NULL, (Cardinal *)NULL);
+ UNLOCK_PROCESS;
+ return;
+ }
+ initialized = TRUE;
+ UNLOCK_PROCESS;
+
+ QBoolean = XrmPermStringToQuark(XtCBoolean);
+ QString = XrmPermStringToQuark(XtCString);
+ QCallProc = XrmPermStringToQuark(XtRCallProc);
+ QImmediate = XrmPermStringToQuark(XtRImmediate);
+ QinitialResourcesPersistent = XrmPermStringToQuark(XtNinitialResourcesPersistent);
+ QInitialResourcesPersistent = XrmPermStringToQuark(XtCInitialResourcesPersistent);
+ Qtranslations = XrmPermStringToQuark(XtNtranslations);
+ QbaseTranslations = XrmPermStringToQuark("baseTranslations");
+ QTranslations = XrmPermStringToQuark(XtCTranslations);
+ QTranslationTable = XrmPermStringToQuark(XtRTranslationTable);
+ Qscreen = XrmPermStringToQuark(XtNscreen);
+ QScreen = XrmPermStringToQuark(XtCScreen);
+}