/* $XConsortium: geoIntrinsic.c /main/4 1995/07/15 21:13:22 drk $ */

/*

 * Motif

 *

 * Copyright (c) 1987-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 librararies and programs; if not, write

 * to the Free Software Foundation, Inc., 51 Franklin Street, Fifth

 * Floor, Boston, MA 02110-1301 USA

 */

/*

 * HISTORY

 */

#define INTRINSIC_C

#include "IntrinsicI.h"

#include "StringDefs.h"

#ifndef NO_IDENTIFY_WINDOWS

#include <X11/Xatom.h>

#endif

#ifndef VMS

#include <sys/stat.h>

#endif /* VMS */

#ifndef X_NOT_STDC_ENV

#include <stdlib.h>

#else

extern char *getenv();

#endif

#include "geoTattler.h"

String XtCXtToolkitError = "XtToolkitError";

Boolean XtIsSubclass(widget, widgetClass)

    Widget    widget;

    WidgetClass widgetClass;

{

    register WidgetClass w;

    for (w = widget->core.widget_class; w != NULL; w = w->core_class.superclass)

	if (w == widgetClass) return (TRUE);

    return (FALSE);

} /* XtIsSubclass */

#if NeedFunctionPrototypes

Boolean _XtCheckSubclassFlag(

    Widget object,

    _XtXtEnum flag

    )

#else

Boolean _XtCheckSubclassFlag(object, flag)

    Widget object;

    XtEnum flag;

#endif

{

    if (object->core.widget_class->core_class.class_inited & flag)

	return True;

    else

	return False;

} /*_XtVerifySubclass */

#if NeedFunctionPrototypes

Boolean _XtIsSubclassOf(

    Widget object,

    WidgetClass widgetClass,

    WidgetClass superClass,

    _XtXtEnum flag

    )

#else

Boolean _XtIsSubclassOf(object, widgetClass, superClass, flag)

    Widget object;

    WidgetClass widgetClass, superClass;

    XtEnum flag;

#endif

{

    if (!(object->core.widget_class->core_class.class_inited & flag))

	return False;

    else {

	register WidgetClass c = object->core.widget_class;

	while (c != superClass) {

	    if (c == widgetClass)

		return True;

	    c = c->core_class.superclass;

	}

	return False;

    }

} /*_XtIsSubclassOf */

static void ComputeWindowAttributes(widget,value_mask,values)

    Widget		 widget;

    XtValueMask		 *value_mask;

    XSetWindowAttributes *values;

{

    *value_mask = CWEventMask | CWColormap;

    (*values).event_mask = XtBuildEventMask(widget);

    (*values).colormap = widget->core.colormap;

    if (widget->core.background_pixmap != XtUnspecifiedPixmap) {

	*value_mask |= CWBackPixmap;

	(*values).background_pixmap = widget->core.background_pixmap;

    } else {

	*value_mask |= CWBackPixel;

	(*values).background_pixel = widget->core.background_pixel;

    }

    if (widget->core.border_pixmap != XtUnspecifiedPixmap) {

	*value_mask |= CWBorderPixmap;

	(*values).border_pixmap = widget->core.border_pixmap;

    } else {

	*value_mask |= CWBorderPixel;

	(*values).border_pixel = widget->core.border_pixel;

    }

    if (widget->core.widget_class->core_class.expose == (XtExposeProc) NULL) {

	/* Try to avoid redisplay upon resize by making bit_gravity the same

	   as the default win_gravity */

	*value_mask |= CWBitGravity;

	(*values).bit_gravity = NorthWestGravity;

    }

} /* ComputeWindowAttributes */

static void CallChangeManaged(widget)

    register Widget		widget;

{

    register Cardinal		i;

    XtWidgetProc		change_managed;

    register WidgetList		children;

    int    			managed_children = 0;

    register CompositePtr cpPtr;

    register CompositePartPtr clPtr;

    if (XtIsComposite (widget)) {

	cpPtr = (CompositePtr)&((CompositeWidget) widget)->composite;

        clPtr = (CompositePartPtr)&((CompositeWidgetClass)

                   widget->core.widget_class)->composite_class;

    } else return;

    children = cpPtr->children;

    change_managed = clPtr->change_managed;

    /* CallChangeManaged for all children */

    for (i = cpPtr->num_children; i != 0; --i) {

	CallChangeManaged (children[i-1]);

	if (XtIsManaged(children[i-1])) managed_children++;

    }

    if (change_managed != NULL && managed_children != 0) {

	_GeoPrintTrace(widget,"Call \"%s\"[%d,%d]'s changemanaged\n", XtName(widget), widget->core.width, widget->core.height);

	(*change_managed) (widget);

    }

} /* CallChangeManaged */

static void MapChildren(cwp)

    CompositePart *cwp;

{

    Cardinal i;

    WidgetList children;

    register Widget child;

    children = cwp->children;

    for (i = 0; i <  cwp->num_children; i++) {

	child = children[i];

	if (XtIsWidget (child)){

	    if (child->core.managed && child->core.mapped_when_managed) {

		XtMapWidget (children[i]);

	    }

	}

    }

} /* MapChildren */

static Boolean ShouldMapAllChildren(cwp)

    CompositePart *cwp;

{

    Cardinal i;

    WidgetList children;

    register Widget child;

    children = cwp->children;

    for (i = 0; i < cwp->num_children; i++) {

	child = children[i];

	if (XtIsWidget(child)) {

	    if (XtIsRealized(child) && (! (child->core.managed 

					  && child->core.mapped_when_managed))){

		    return False;

	    }

	}

    }

    return True;

} /* ShouldMapAllChildren */

static void RealizeWidget(widget)

    register Widget		widget;

{

    XtValueMask			value_mask;

    XSetWindowAttributes	values;

    XtRealizeProc		realize;

    Window			window;

    if (!XtIsWidget(widget) || XtIsRealized(widget)) return;

    _XtInstallTranslations(widget);

    ComputeWindowAttributes (widget, &value_mask, &values);

    realize = widget->core.widget_class->core_class.realize;

    if (realize == NULL)

	XtAppErrorMsg(XtWidgetToApplicationContext(widget),

		      "invalidProcedure","realizeProc",XtCXtToolkitError,

		      "No realize class procedure defined",

		      (String *)NULL, (Cardinal *)NULL);

    else {

	_GeoPrintTrace(widget,"Call \"%s\"[%d,%d]'s realize proc\n", XtName(widget), widget->core.width, widget->core.height);

	(*realize) (widget, &value_mask, &values);

    }

    window = XtWindow(widget);

#ifndef NO_IDENTIFY_WINDOWS

    if (_XtGetPerDisplay(XtDisplay(widget))->appContext->identify_windows) {

	int len_nm, len_cl;

 	char *s;

	len_nm = widget->core.name ? strlen(widget->core.name) : 0;

 	len_cl = strlen(widget->core.widget_class->core_class.class_name);

 	s = XtMalloc((unsigned) (len_nm + len_cl + 2));

 	s[0] = '\0';

 	if (len_nm)

 	    strcpy(s, widget->core.name);

 	strcpy(s + len_nm + 1,

 	       widget->core.widget_class->core_class.class_name);

 	XChangeProperty(XtDisplay(widget), window,

 			XInternAtom(XtDisplay(widget), "_MIT_OBJ_CLASS",

 				    False),

 			XA_STRING, 8, PropModeReplace, (unsigned char *) s, 

 			len_nm + len_cl + 2);

 	XtFree(s);

    }

#endif

#ifdef notdef

    _XtRegisterAsyncHandlers(widget);

#endif

    _XtRegisterGrabs(widget);

    _XtRegisterWindow (window, widget);

    if (XtIsComposite (widget)) {

	register Cardinal		i;

	register CompositePart *cwp = &(((CompositeWidget)widget)->composite);

	register WidgetList children = cwp->children;

	/* Realize all children */

	for (i = cwp->num_children; i != 0; --i) {

	    RealizeWidget (children[i-1]);

	}

	/* Map children that are managed and mapped_when_managed */

	if (cwp->num_children != 0) {

	    if (ShouldMapAllChildren(cwp)) {

		XMapSubwindows (XtDisplay(widget), window);

	    } else {

		MapChildren(cwp);

	    }

	}

    }

    /* If this is the application's popup shell, map it */

    if (widget->core.parent == NULL && widget->core.mapped_when_managed) {

	XtMapWidget (widget);

    }

} /* RealizeWidget */

void XtRealizeWidget (widget)

    register Widget		widget;

{

    if (XtIsRealized (widget)) return;

    CallChangeManaged(widget);

    RealizeWidget(widget);

} /* XtRealizeWidget */

static void UnrealizeWidget(widget)

    register Widget		widget;

{

    register CompositeWidget	cw;

    register Cardinal		i;

    register WidgetList		children;

    if (!XtIsWidget(widget) || !XtIsRealized(widget)) return;

    /* If this is the application's popup shell, unmap it? */

    /* no, the window is being destroyed */

    /* Recurse on children */

    if (XtIsComposite (widget)) {

	cw = (CompositeWidget) widget;

	children = cw->composite.children;

	/* Unrealize all children */

	for (i = cw->composite.num_children; i != 0; --i) {

	    UnrealizeWidget (children[i-1]);

	}

	/* Unmap children that are managed and mapped_when_managed? */

	/* No, it's ok to be managed and unrealized as long as your parent */

	/* is unrealized. XtUnrealize widget makes sure the "top" widget */

	/* is unmanaged, we can ignore all descendents */

    }

    if (XtHasCallbacks(widget, XtNunrealizeCallback) == XtCallbackHasSome)

	XtCallCallbacks(widget, XtNunrealizeCallback, NULL);

    /* Unregister window */

    _XtUnregisterWindow(XtWindow(widget), widget);

    /* Remove Event Handlers */

    /* remove grabs. Happens automatically when window is destroyed. */

    /* Destroy X Window, done at outer level with one request */

    widget->core.window = None;

    /* Removing the event handler here saves having to keep track if

     * the translation table is changed while the widget is unrealized.

     */

    _XtRemoveTranslations(widget);

} /* UnrealizeWidget */

void XtUnrealizeWidget (widget)

    register Widget		widget;

{

    Window window = XtWindow(widget);

    if (! XtIsRealized (widget)) return;

    if (widget->core.parent != NULL) XtUnmanageChild(widget);

    UnrealizeWidget(widget);

    if (window != None) XDestroyWindow(XtDisplay(widget), window);

} /* XtUnrealizeWidget */

void XtCreateWindow(widget, window_class, visual, value_mask, attributes)

    Widget		 widget;

    unsigned int	 window_class;

    Visual		 *visual;

    XtValueMask		 value_mask;

    XSetWindowAttributes *attributes;

{

    if (widget->core.window == None) {

	if (widget->core.width == 0 || widget->core.height == 0) {

	    Cardinal count = 1;

	    XtAppErrorMsg(XtWidgetToApplicationContext(widget),

		       "invalidDimension", "xtCreateWindow", XtCXtToolkitError,

		       "Widget %s has zero width and/or height",

		       &widget->core.name, &count);

	}

	widget->core.window =

	    XCreateWindow (

		XtDisplay (widget),

		(widget->core.parent ?

		    widget->core.parent->core.window :

		    widget->core.screen->root),

		(int)widget->core.x, (int)widget->core.y,

		(unsigned)widget->core.width, (unsigned)widget->core.height,

		(unsigned)widget->core.border_width, (int) widget->core.depth,

		window_class, visual, value_mask, attributes);

    }

} /* XtCreateWindow */

/* ---------------- XtNameToWidget ----------------- */

static Widget NameListToWidget();

typedef Widget (*NameMatchProc)();

static Widget MatchExactChildren(names, bindings, children, num,

	in_depth, out_depth, found_depth)

    XrmNameList     names;

    XrmBindingList  bindings;

    register WidgetList children;

    register int num;

    int in_depth, *out_depth, *found_depth;

{

    register Cardinal   i;

    register XrmName    name = *names;

    Widget w, result = NULL;

    int d, min = 10000;

    for (i = 0; i < num; i++) {

	if (name == children[i]->core.xrm_name) {

	    w = NameListToWidget(children[i], &names[1], &bindings[1],

		    in_depth+1, &d, found_depth);

	    if (w != NULL && d < min) {result = w; min = d;}

	}

    }

    *out_depth = min;

    return result;

}

static Widget MatchWildChildren(names, bindings, children, num,

	in_depth, out_depth, found_depth)

    XrmNameList     names;

    XrmBindingList  bindings;

    register WidgetList children;

    register int num;

    int in_depth, *out_depth, *found_depth;

{

    register Cardinal   i;

    Widget w, result = NULL;

    int d, min = 10000;

    for (i = 0; i < num; i++) {

	w = NameListToWidget(children[i], names, bindings,

		in_depth+1, &d, found_depth);

	if (w != NULL && d < min) {result = w; min = d;}

    }

    *out_depth = min;

    return result;

}

static Widget SearchChildren(root, names, bindings, matchproc,

	in_depth, out_depth, found_depth)

    Widget root;

    XrmNameList     names;

    XrmBindingList  bindings;

    NameMatchProc matchproc;

    int in_depth, *out_depth, *found_depth;

{

    Widget w1, w2;

    int d1, d2;

    if (XtIsComposite(root)) {

	w1 = (*matchproc)(names, bindings,

		((CompositeWidget) root)->composite.children,

		((CompositeWidget) root)->composite.num_children,

		in_depth, &d1, found_depth);

    } else d1 = 10000;

    w2 = (*matchproc)(names, bindings, root->core.popup_list,

	    root->core.num_popups, in_depth, &d2, found_depth);

    *out_depth = (d1 < d2 ? d1 : d2);

    return (d1 < d2 ? w1 : w2);

}

static Widget NameListToWidget(root, names, bindings,

	in_depth, out_depth, found_depth)

    register Widget root;

    XrmNameList     names;

    XrmBindingList  bindings;

    int in_depth, *out_depth, *found_depth;

{

    Widget w1, w2;

    int d1, d2;

    if (in_depth >= *found_depth) {

	*out_depth = 10000;

	return NULL;

    }

    if (names[0] == NULLQUARK) {

	*out_depth = *found_depth = in_depth;

	return root;

    }

    if (! XtIsWidget(root)) {

	*out_depth = 10000;

	return NULL;

    }

    if (*bindings == XrmBindTightly) {

	return SearchChildren(root, names, bindings, MatchExactChildren,

		in_depth, out_depth, found_depth);

    } else {	/* XrmBindLoosely */

	w1 = SearchChildren(root, names, bindings, MatchExactChildren,

		in_depth, &d1, found_depth);

	w2 = SearchChildren(root, names, bindings, MatchWildChildren,

		in_depth, &d2, found_depth);

	*out_depth = (d1 < d2 ? d1 : d2);

	return (d1 < d2 ? w1 : w2);

    }

} /* NameListToWidget */

#if NeedFunctionPrototypes

Widget XtNameToWidget(

    Widget root,

    _Xconst char* name

    )

#else

Widget XtNameToWidget(root, name)

    Widget root;

    String name;

#endif

{

    XrmName *names;

    XrmBinding *bindings;

    int len, depth, found = 10000;

    Widget result;

    len = strlen(name);

    if (len == 0) return NULL;

    names = (XrmName *) ALLOCATE_LOCAL((unsigned) (len+1) * sizeof(XrmName));

    bindings = (XrmBinding *)

	ALLOCATE_LOCAL((unsigned) (len+1) * sizeof(XrmBinding));

    if (names == NULL || bindings == NULL) _XtAllocError(NULL);

    XrmStringToBindingQuarkList(name, bindings, names);

    if (names[0] == NULLQUARK) {

	DEALLOCATE_LOCAL((char *) bindings);

	DEALLOCATE_LOCAL((char *) names);

	return NULL;

    }

    result = NameListToWidget(root, names, bindings, 0, &depth, &found);

    DEALLOCATE_LOCAL((char *) bindings);

    DEALLOCATE_LOCAL((char *) names);

    return result;

} /* XtNameToWidget */

/* Define user versions of intrinsics macros */

#undef XtDisplayOfObject

Display *XtDisplayOfObject(object)

     Widget object;

{

    return XtDisplay(XtIsWidget(object) ? object : _XtWindowedAncestor(object));

}

#undef XtDisplay

Display *XtDisplay(widget)

	Widget widget;

{

    return DisplayOfScreen(widget->core.screen);

}

#undef XtScreenOfObject

Screen *XtScreenOfObject(object)

     Widget object;

{

    return XtScreen(XtIsWidget(object) ? object : _XtWindowedAncestor(object));

}

#undef XtScreen

Screen *XtScreen(widget)

	Widget widget;

{

    return widget->core.screen;

}

#undef XtWindowOfObject

Window XtWindowOfObject(object)

     Widget object;

{

    return XtWindow(XtIsWidget(object) ? object : _XtWindowedAncestor(object));

}

#undef XtWindow

Window XtWindow(widget)

	Widget widget;

{

    return widget->core.window;

}

#undef XtSuperclass

WidgetClass XtSuperclass(widget)

	Widget widget;

{

	return XtClass(widget)->core_class.superclass;

}

#undef XtClass

WidgetClass XtClass(widget)

	Widget widget;

{

	return widget->core.widget_class;

}

#undef XtIsManaged

Boolean XtIsManaged(object)

	Widget object;

{

    if (XtIsRectObj(object))

	return object->core.managed;

    else

	return False;

}

#undef XtIsRealized

Boolean XtIsRealized (object)

	Widget   object;

{

    return XtWindowOfObject(object) != None;

} /* XtIsRealized */

#undef XtIsSensitive

Boolean XtIsSensitive(object)

	Widget	object;

{

    if (XtIsRectObj(object))

	return object->core.sensitive && object->core.ancestor_sensitive;

    else

	return False;

}

/*

 * Internal routine; must be called only after XtIsWidget returns false

 */

Widget _XtWindowedAncestor(object)

    register Widget object;

{

    Widget obj = object;

    for (object = XtParent(object); object && !XtIsWidget(object);)

	object = XtParent(object);

    if (object == NULL) {

	String params = XtName(obj);

	Cardinal num_params = 1;

	XtErrorMsg("noWidgetAncestor", "windowedAncestor", XtCXtToolkitError,

		   "Object \"%s\" does not have windowed ancestor",

		   &params, &num_params);

    }

    return object;

}

#undef XtParent

Widget XtParent(widget)

	Widget widget;

{

	return widget->core.parent;

}

#undef XtName

String XtName(object)

     Widget object;

{

    return XrmQuarkToString(object->core.xrm_name);

}

Boolean XtIsObject(object)

    Widget object;

{

    WidgetClass wc;

    String class_name;

    /* perform basic sanity checks */

    if (object->core.self != object || object->core.xrm_name == NULLQUARK)

	return False;

    wc = object->core.widget_class;

    if (wc->core_class.class_name == NULL ||

	wc->core_class.xrm_class == NULLQUARK ||

	(class_name = XrmClassToString(wc->core_class.xrm_class)) == NULL ||

	strcmp(wc->core_class.class_name, class_name) != 0)

	    return False;

    if (XtIsWidget(object)) {

	if (object->core.name == NULL ||

	    (class_name = XrmNameToString(object->core.xrm_name)) == NULL ||

	    strcmp(object->core.name, class_name) != 0)

	    return False;

    }

    return True;

}

static Boolean TestFile(path)

    String path;

{

#ifdef VMS

    return TRUE;	/* Who knows what to do here? */

#else

    struct stat status;

    return (access(path, R_OK) == 0 &&		/* exists and is readable */

	    stat(path, &status) == 0 &&		/* get the status */

#ifndef X_NOT_POSIX

	    S_ISDIR(status.st_mode) == 0);	/* not a directory */

#else

	    (status.st_mode & S_IFDIR) == 0);	/* not a directory */

#endif /* X_NOT_POSIX else */

#endif /* VMS */

}

/* return of TRUE = resolved string fit, FALSE = didn't fit.  Not

   null-terminated and not collapsed if it didn't fit */

static Boolean Resolve(source, len, sub, num, buf, collapse)

    register char *source;	/* The source string */

    register int len;		/* The length in bytes of *source */

    Substitution sub;	/* Array of string values to substitute */

    Cardinal num;	/* Number of substitution entries */

    char *buf;		/* Where to put the resolved string; */

    char collapse;	/* Character to collapse */

{

    register int bytesLeft = PATH_MAX;

    register char* bp = buf;

#ifndef DONT_COLLAPSE

    Boolean atBeginning = TRUE;

    Boolean prevIsCollapse = FALSE;

#define PUT(ch) \

    { \

	if (--bytesLeft == 0) return FALSE; \

        if (prevIsCollapse) \

	    if ((*bp = ch) != collapse) { \

		prevIsCollapse = FALSE; \

		bp++; \

	    } \

	    else bytesLeft++; \

        else if ((*bp++ = ch) == collapse && !atBeginning) \

	    prevIsCollapse = TRUE; \

    }

#else /* DONT_COLLAPSE */

#define PUT(ch) \

    { \

	if (--bytesLeft == 0) return FALSE; \

	*bp++ = ch; \

    }

#endif /* DONT_COLLAPSE */

#define escape '%'

    while (len--) {

#ifndef DONT_COLLAPSE

	if (*source == collapse) {

	    PUT(*source);

	    source++;

	    continue;

	}

	else

#endif /* DONT_COLLAPSE */

	    if (*source != escape) {

		PUT(*source);

	}

	else {

	    source++;

	    if (len-- == 0) {

		PUT(escape);

		break;

	    }

	    if (*source == ':' || *source == escape)

		PUT(*source)

	    else {

		/* Match the character against the match array */

		register int j;

		for (j = 0; j < num && sub[j].match != *source; j++) {}

		/* Substitute the substitution string */

		if (j >= num) PUT(*source)

		else if (sub[j].substitution != NULL) {

		    char *sp = sub[j].substitution;

		    while (*sp) {

			PUT(*sp);

			sp++;

		    }

		}

	    }

	}

	source++;

#ifndef DONT_COLLAPSE

	atBeginning = FALSE;

#endif /* DONT_COLLAPSE */

    }

    PUT('\0');

    return TRUE;

#undef PUT

#undef escape

}

#if NeedFunctionPrototypes

String XtFindFile(

    _Xconst char* path,

    Substitution substitutions,

    Cardinal num_substitutions,

    XtFilePredicate predicate

    )

#else

String XtFindFile(path, substitutions, num_substitutions, predicate)

    String path;

    Substitution substitutions;

    Cardinal num_substitutions;

    XtFilePredicate predicate;

#endif

{

    char *buf, *buf1, *buf2, *colon, *start;

    int len;

    Boolean firstTime = TRUE;

    buf = buf1 = XtMalloc((unsigned)PATH_MAX);

    buf2 = XtMalloc((unsigned)PATH_MAX);

    if (predicate == NULL) predicate = TestFile;

    while (1) {

	start = (String)path;

	while (1) {

	    colon = index(start, ':');

	    if (colon == NULL) break;

	    if (colon == path) {start++; path++; continue; }

	    if (*(colon-1) != '%') break;

	    start = colon+1;

	}

	if (colon != NULL)

	    len = colon - path;

	else

	    len = strlen(path);

	if (Resolve(path, len, substitutions, num_substitutions,

		    buf, '/')) {

	    if (firstTime || strcmp(buf1,buf2) != 0) {

#ifdef XNL_DEBUG

		printf("Testing file %s\n", buf);

#endif /* XNL_DEBUG */

		/* Check out the file */

		if ((*predicate) (buf)) {

		    /* We've found it, return it */

#ifdef XNL_DEBUG

		    printf("File found.\n");

#endif /* XNL_DEBUG */

		    if (buf == buf1) XtFree(buf2);

		    else XtFree(buf1);

		    return buf;

		}

		if (buf == buf1)

		    buf = buf2;

		else

		    buf = buf1;

		firstTime = FALSE;

	    }

	}

	/* Nope...any more paths? */

	if (colon == NULL) break;

	path = colon+1;

    }

    /* No file found */

    XtFree(buf1);

    XtFree(buf2);

    return NULL;

}

/* The implementation of this routine is operating system dependent */

static char *ExtractLocaleName(lang)

    String	lang;

{

#ifdef hpux	 /* hpux-specific parsing of the locale string */