/*

Copyright 1989, 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.

*/

/*

 * Author:  Chris D. Peterson, Dave Sternlicht, MIT X Consortium

 */

#ifdef HAVE_CONFIG_H

#include <config.h>

#endif

#include <X11/IntrinsicP.h>	/* To get into the composite and core widget

				   structures. */

#include <X11/ObjectP.h>	/* For XtIs<Classname> macros. */

#include <X11/StringDefs.h>	/* for XtRString. */

#include <X11/ShellP.h>		/* for Application Shell Widget class. */

#include <X11/Xatom.h>

#include <X11/Xos.h>		/* for strcpy declaration */

#include <X11/Xfuncs.h>

#include <X11/Xmu/EditresP.h>

#include <X11/Xmd.h>

#include <X11/Xmu/CharSet.h>

#include <X11/Xmu/SysUtil.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#define _XEditResPutBool _XEditResPut8

#define _XEditResPutResourceType _XEditResPut8

/*

 * Types

 */

typedef enum {

    BlockNone,

    BlockSetValues,

    BlockAll

} EditresBlock;

typedef struct _SetValuesEvent {

    EditresCommand type;		/* first field must be type */

    WidgetInfo *widgets;

    unsigned short num_entries;		/* number of set values requests */

    char *name;

    char *res_type;

    XtPointer value;

    unsigned short value_len;

} SetValuesEvent;

typedef struct _SVErrorInfo {

    SetValuesEvent *event;

    ProtocolStream *stream;

    unsigned short *count;

    WidgetInfo *entry;

} SVErrorInfo;

typedef struct _GetValuesEvent {

    EditresCommand type;		/* first field must be type */

    WidgetInfo *widgets;

    unsigned short num_entries;		/* number of get values requests */

    char *name;

} GetValuesEvent;

typedef struct _FindChildEvent {

    EditresCommand type;		/* first field must be type */

    WidgetInfo *widgets;

    short x, y;

} FindChildEvent;

typedef struct _GenericGetEvent {

    EditresCommand type;		/* first field must be type */

    WidgetInfo *widgets;

    unsigned short num_entries;		/* number of set values requests */

} GenericGetEvent, GetResEvent, GetGeomEvent;

/*

 * Common to all events

 */

typedef struct _AnyEvent {

    EditresCommand type;		/* first field must be type */

    WidgetInfo *widgets;

} AnyEvent;

/*

 * The event union

 */

typedef union _EditresEvent {

    AnyEvent any_event;

    SetValuesEvent set_values_event;

    GetResEvent get_resources_event;

    GetGeomEvent get_geometry_event;

    FindChildEvent find_child_event;

} EditresEvent;

typedef struct _Globals {

    EditresBlock block;

    SVErrorInfo error_info;

    ProtocolStream stream;

    ProtocolStream *command_stream;	/* command stream */

#if defined(LONG64) || defined(WORD64)

    unsigned long base_address;

#endif

} Globals;

#define CURRENT_PROTOCOL_VERSION 5L

#define streq(a,b) (strcmp((a), (b)) == 0)

/*

 * Prototypes

 */

static Widget _FindChild(Widget, int, int);

static void _XEditresGetStringValues(Widget, Arg*, int);

static XtPointer BuildReturnPacket(ResIdent, EditResError, ProtocolStream*);

static void CommandDone(Widget, Atom*, Atom*);

static Boolean ConvertReturnCommand(Widget, Atom*, Atom*, Atom*, XtPointer*,

				    unsigned long*, int*);

static Boolean CvtStringToBlock(Display*, XrmValue*, Cardinal*,

				XrmValue*, XrmValue*, XtPointer*);

static EditresEvent *BuildEvent(Widget, Atom, XtPointer, ResIdent,

				unsigned long);

static _Xconst char *DoFindChild(Widget, EditresEvent*, ProtocolStream*);

static _Xconst char *DoGetGeometry(Widget, EditresEvent*, ProtocolStream*);

static _Xconst char *DoGetResources(Widget, EditresEvent*, ProtocolStream*);

static _Xconst char *DoSetValues(Widget, EditresEvent*, ProtocolStream*);

static void DumpChildren(Widget, ProtocolStream*, unsigned short*);

static _Xconst char *DumpValues(Widget, EditresEvent*, ProtocolStream*);

static _Xconst char *DumpWidgets(Widget, EditresEvent*, ProtocolStream*);

static void ExecuteCommand(Widget, Atom, ResIdent, EditresEvent*);

static void ExecuteGetGeometry(Widget, ProtocolStream*);

static void ExecuteGetResources(Widget w, ProtocolStream *stream);

static void ExecuteSetValues(Widget, SetValuesEvent*, WidgetInfo*,

			     ProtocolStream*, unsigned short*);

static void FreeEvent(EditresEvent*);

static void GetCommand(Widget w, XtPointer, Atom*, Atom*, XtPointer,

		       unsigned long*, int*);

static void HandleToolkitErrors(String, String, String, String,

				String*, Cardinal*);

static void InsertWidget(ProtocolStream*, Widget);

static Bool IsChild(Widget, Widget, Widget);

static Bool isApplicationShell(Widget);

static void LoadResources(Widget);

static Bool PositionInChild(Widget, int, int);

static int qcmp_widget_list(register _Xconst void*, register _Xconst void*);

static void SendCommand(Widget, Atom, ResIdent, EditResError,

			ProtocolStream*);

static void SendFailure(Widget, Atom, ResIdent, _Xconst char*);

static _Xconst char *VerifyWidget(Widget, WidgetInfo*);

/*

 * External

 */

void _XEditResCheckMessages(Widget, XtPointer, XEvent*, Boolean*);

/*

 * Initialization

 */

static Atom res_editor_command, res_editor_protocol, client_value;

static Globals globals;

/************************************************************

 * Resource Editor Communication Code

 ************************************************************/

/*

 * Function:

 *	_XEditResCheckMessages

 *

 * Parameters:

 *	data  - unused

 *	event - The X Event that triggered this handler

 *	cont  - unused

 *

 * Description:

 *	  This callback routine is set on all shell widgets, and checks to

 *	see if a client message event has come from the resource editor.

 */

/*ARGSUSED*/

void

_XEditResCheckMessages(Widget w, XtPointer data, XEvent *event, Boolean *cont)

{

    Time time;

    ResIdent ident;

    static Boolean first_time = False;

    static Atom res_editor, res_comm;

    Display *dpy;

    if (event->type == ClientMessage)

    {

	XClientMessageEvent * c_event = (XClientMessageEvent *)event;

	dpy = XtDisplay(w);

	if (!first_time)

	{

	    Atom atoms[4];

	    static _Xconst char *names[] = {

		EDITRES_NAME, EDITRES_COMMAND_ATOM,

		EDITRES_PROTOCOL_ATOM, EDITRES_CLIENT_VALUE

	    };

	    first_time = True;

	    XInternAtoms(dpy, (char **) names, 4, False, atoms);

	    res_editor = atoms[0];

	    res_editor_command = atoms[1];

	    res_editor_protocol = atoms[2];

	  /* Used in later procedures */

	    client_value = atoms[3];

	    LoadResources(w);

	}

	if ((c_event->message_type != res_editor)

	    || (c_event->format != EDITRES_SEND_EVENT_FORMAT))

	    return;

	time = c_event->data.l[0];

	res_comm = c_event->data.l[1];

	ident = (ResIdent) c_event->data.l[2];

	if (c_event->data.l[3] != CURRENT_PROTOCOL_VERSION)

	{

	    _XEditResResetStream(&globals.stream);

	    _XEditResPut8(&globals.stream,

			  (unsigned int) CURRENT_PROTOCOL_VERSION);

	    SendCommand(w, res_comm, ident, ProtocolMismatch, &globals.stream);

	    return;

	}

	XtGetSelectionValue(w, res_comm, res_editor_command,

			    GetCommand, (XtPointer)(long)ident, time);

    }

}

/*

 * Function:

 *	BuildEvent

 *

 * Parameters:

 *	w      - widget to own selection, in case of error

 *	sel    - selection to send error message beck in

 *	data   - the data for the request

 *	ident  - the id number we are looking for

 *	length - length of request

 *

 * Description:

 *	  Takes the info out the protocol stream an constructs

 *                   the proper event structure.

 *

 * Returns:

 *	the event, or NULL

 */

#if defined(ERROR_MESSAGE)

#undef ERROR_MESSAGE

#endif

#define ERROR_MESSAGE "Client: Improperly formatted protocol request"

static EditresEvent *

BuildEvent(Widget w, Atom sel, XtPointer data, ResIdent ident,

	   unsigned long length)

{

    EditresEvent *event;

    ProtocolStream alloc_stream, *stream;

    unsigned char temp;

    register unsigned int i;

    stream = &alloc_stream;

    stream->current = stream->top = (unsigned char *)data;

    stream->size = HEADER_SIZE;		/* size of header */

    /*

     * Retrieve the Header

     */

    if (length < HEADER_SIZE)

    {

	SendFailure(w, sel, ident, ERROR_MESSAGE);

	return (NULL);

    }

    (void)_XEditResGet8(stream, &temp);

    if (temp != ident)			/* Id's don't match, ignore request */

	return (NULL);

    event = (EditresEvent *)XtCalloc(sizeof(EditresEvent), 1);

    (void)_XEditResGet8(stream, &temp);

    event->any_event.type = (EditresCommand)temp;

    (void)_XEditResGet32(stream, &stream->size);

    stream->top = stream->current;	/* reset stream to top of value */

    /*

     * Now retrieve the data segment

     */

    switch(event->any_event.type)

    {

    case SendWidgetTree:

	break;			/* no additional info */

    case SetValues:

        {

	    SetValuesEvent *sv_event = (SetValuesEvent *)event;

	    if (!(_XEditResGetString8(stream, &sv_event->name)

		  && _XEditResGetString8(stream, &sv_event->res_type)))

		goto done;

	    /*

	     * Since we need the value length, we have to pull the

	     * value out by hand

	     */

	    if (!_XEditResGet16(stream, &sv_event->value_len))

		goto done;

	    sv_event->value = XtMalloc(sizeof(char) * (sv_event->value_len + 1));

	    for (i = 0; i < sv_event->value_len; i++)

		if (!_XEditResGet8(stream, (unsigned char *)sv_event->value + i))

		    goto done;

	    ((char*)sv_event->value)[i] = '\0';

	    if (!_XEditResGet16(stream, &sv_event->num_entries))

		goto done;

	    sv_event->widgets = (WidgetInfo *)

		XtCalloc(sizeof(WidgetInfo), sv_event->num_entries);

	    for (i = 0; i < sv_event->num_entries; i++)

		if (!_XEditResGetWidgetInfo(stream, sv_event->widgets + i))

		    goto done;

	}

	break;

    case FindChild:

	{

	    FindChildEvent *find_event = (FindChildEvent *)event;

	    find_event->widgets = (WidgetInfo *)XtCalloc(sizeof(WidgetInfo), 1);

	    if (!(_XEditResGetWidgetInfo(stream, find_event->widgets)

		  && _XEditResGetSigned16(stream, &find_event->x)

		  && _XEditResGetSigned16(stream, &find_event->y)))

		goto done;

	}

	break;

    case GetGeometry:

    case GetResources:

	{

	    GenericGetEvent *get_event = (GenericGetEvent *)event;

	    if (!_XEditResGet16(stream, &get_event->num_entries))

		goto done;

	    get_event->widgets = (WidgetInfo *)

		XtCalloc(sizeof(WidgetInfo), get_event->num_entries);

	    for (i = 0; i < get_event->num_entries; i++)

		if (!_XEditResGetWidgetInfo(stream, get_event->widgets + i))

		    goto done;

	}

	break;

    case GetValues:

	{

	    GetValuesEvent *gv_event = (GetValuesEvent *)event;

	    _XEditResGetString8(stream, &gv_event->name);

	    _XEditResGet16(stream, &gv_event->num_entries);

	    gv_event->widgets = (WidgetInfo *)

		XtCalloc(sizeof(WidgetInfo), gv_event->num_entries);

	    _XEditResGetWidgetInfo(stream, gv_event->widgets);

	}

        break;

    default:

	{

	    char buf[BUFSIZ];

	    XmuSnprintf(buf, sizeof(buf),

			"Unknown Protocol request %d.", event->any_event.type);

	    SendFailure(w, sel, ident, buf);

	    FreeEvent(event);

	    return (NULL);

	}

    }

    return (event);

  done:

    SendFailure(w, sel, ident, ERROR_MESSAGE);

    FreeEvent(event);

    return (NULL);

}

/*

 * Function:

 *	FreeEvent

 *

 * Parameters:

 *	event - event to free

 *

 * Description:

 *	Frees the event structure and any other pieces in it that need freeing.

 */

static void

FreeEvent(EditresEvent *event)

{

    if (event->any_event.widgets != NULL)

    {

	XtFree((char *)event->any_event.widgets->ids);

	XtFree((char *)event->any_event.widgets);

    }

    if (event->any_event.type == SetValues)

    {

	XtFree(event->set_values_event.name);

	XtFree(event->set_values_event.res_type);

    }

    XtFree((char *)event);

}

/*

 * Function:

 *	GetCommand

 *

 * Parameters:

 *	(See Xt XtConvertSelectionProc)

 *	data - contains the ident number for the command

 *

 * Description:

 *	Gets the Command out of the selection asserted by the resource manager.

 */

/*ARGSUSED*/

static void

GetCommand(Widget w, XtPointer data, Atom *selection, Atom *type,

	   XtPointer value, unsigned long *length, int *format)

{

    ResIdent ident = (ResIdent)(long)data;

    EditresEvent *event;

    if (*type != res_editor_protocol || *format != EDITRES_FORMAT)

	return;

    if ((event = BuildEvent(w, *selection, value, ident, *length)) != NULL)

    {

	ExecuteCommand(w, *selection, ident, event);

	FreeEvent(event);

    }

}

/*

 * Function:

 *	ExecuteCommand

 *

 * Parameters:

 *	w	- widget

 *	command	- the command to execute

 *	value	- the associated with the command

 *

 * Description:

 *	Executes a command string received from the resource editor.

 */

/*ARGSUSED*/

static void

ExecuteCommand(Widget w, Atom sel, ResIdent ident, EditresEvent *event)

{

    _Xconst char *(*func)(Widget, EditresEvent*, ProtocolStream*);

    _Xconst char *str;

    if (globals.block == BlockAll)

    {

	SendFailure(w, sel, ident,

		    "This client has blocked all Editres commands.");

	return;

    }

    else if (globals.block == BlockSetValues

	     && event->any_event.type == SetValues)

    {

	SendFailure(w, sel, ident,

		    "This client has blocked all SetValues requests.");

	return;

    }

    switch(event->any_event.type)

    {

    case SendWidgetTree:

#if defined(LONG64) || defined(WORD64)

	globals.base_address = (unsigned long)w & 0xFFFFFFFF00000000;

#endif

	func = DumpWidgets;

	break;

    case SetValues:

	func = DoSetValues;

	break;

    case FindChild:

	func = DoFindChild;

	break;

    case GetGeometry:

	func = DoGetGeometry;

	break;

    case GetResources:

	func = DoGetResources;

	break;

    case GetValues:

        func = DumpValues;

    break;

    default:

        {

	    char buf[BUFSIZ];

	    XmuSnprintf(buf, sizeof(buf),

			"Unknown Protocol request %d.",event->any_event.type);

	    SendFailure(w, sel, ident, buf);

	    return;

	}

    }

    _XEditResResetStream(&globals.stream);

    if ((str = (*func)(w, event, &globals.stream)) == NULL)

	SendCommand(w, sel, ident, PartialSuccess, &globals.stream);

    else

	SendFailure(w, sel, ident, str);

}

/*

 * Function:

 *	ConvertReturnCommand

 *

 * Parameters:

 *	w	   - the widget that owns the selection

 *	selection  - selection to convert

 *	target	   - target type for this selection

 *	type_ret   - type of the selection

 *	value_ret  - selection value

 *	length_ret - lenght of this selection

 *	format_ret - the format the selection is in

 *

 * Description:

 *	Converts a selection

 *

 * Returns:

 *	True if conversion was sucessful

 */

/*ARGSUSED*/

static Boolean

ConvertReturnCommand(Widget w, Atom *selection, Atom *target, Atom *type_ret,

		     XtPointer *value_ret, unsigned long *length_ret,

		     int *format_ret)

{

    /*

     * I assume the intrinsics give me the correct selection back

     */

    if ((*target != client_value))

	return (False);

    *type_ret = res_editor_protocol;

    *value_ret = (XtPointer)globals.command_stream->real_top;

    *length_ret = globals.command_stream->size + HEADER_SIZE;

    *format_ret = EDITRES_FORMAT;

  return (True);

}

/*

 * Function:

 *	CommandDone

 *

 * Parameters:

 *	widget	  - unused

 *	selection - unused

 *	target	  - unused

 *

 * Description:

 *	done with the selection

 */

/*ARGSUSED*/

static void

CommandDone(Widget widget, Atom *selection, Atom *target)

{

    /* Keep the toolkit from automaticaly freeing the selection value */

}

/*

 * Function:

 *	SendFailure

 *

 * Paramters:

 *	w     - widget to own the selection

 *	sel   - selection to assert

 *	ident - identifier

 *	str   - error message

 *

 * Description:

 *	Sends a failure message

 */

static void

SendFailure(Widget w, Atom sel, ResIdent ident, _Xconst char *str)

{

    _XEditResResetStream(&globals.stream);

    _XEditResPutString8(&globals.stream, str);

    SendCommand(w, sel, ident, Failure, &globals.stream);

}

/*

 * Function:

 *	BuildReturnPacket

 *

 * Parameters:

 *	ident   - identifier

 *	command - command code

 *	stream  - protocol stream

 * Description:

 *	Builds a return packet, given the data to send

 *

 * Returns:

 *	packet to send

 */

static XtPointer

BuildReturnPacket(ResIdent ident, EditResError error, ProtocolStream *stream)

{

    long old_alloc, old_size;

    unsigned char *old_current;

    /*

     * We have cleverly keep enough space at the top of the header

     * for the return protocol stream, so all we have to do is

     * fill in the space

     */

    /*

     * Fool the insert routines into putting the header in the right

     * place while being damn sure not to realloc (that would be very bad.)

     */

    old_current = stream->current;

    old_alloc = stream->alloc;

    old_size = stream->size;

    stream->current = stream->real_top;

    stream->alloc = stream->size + (2 * HEADER_SIZE);

    _XEditResPut8(stream, ident);

    _XEditResPut8(stream, (unsigned char)error);

    _XEditResPut32(stream, old_size);

    stream->alloc = old_alloc;

    stream->current = old_current;

    stream->size = old_size;

    return ((XtPointer)stream->real_top);

}

/*

 * Function:

 *	SendCommand

 * Parameters:

 *	w	- widget to own the selection

 *	sel	- selection to assert

 *	ident   - identifier

 *	command - command code

 *	stream  - protocol stream

 *

 * Description:

 *	Builds a return command line

 */

static void

SendCommand(Widget w, Atom sel, ResIdent ident, EditResError error,

	    ProtocolStream *stream)

{

    BuildReturnPacket(ident, error, stream);

    globals.command_stream = stream;

    /*

     * I REALLY want to own the selection.  Since this was not triggered

     * by a user action, and I am the only one using this atom it is safe to

     * use CurrentTime

     */

    XtOwnSelection(w, sel, CurrentTime, ConvertReturnCommand, NULL, CommandDone);

}

/************************************************************

 * Generic Utility Functions

 ************************************************************/

static int

qcmp_widget_list(register _Xconst void *left, register _Xconst void *right)

{

    return (char *)*(Widget **)left - (char *)*(Widget **)right;

}

/*

 * Function:

 *	FindChildren

 *

 * Parameters:

 *	parent   - parent widget

 *	children - list of children

 *	normal   - return normal children

 *	popup    - return popup children

 *	extra	 - return extra children

 *

 * Description:

 *	Retuns all children (popup, normal and otherwise) of this widget

 *

 * Returns:

 *	number of children

 */

static int

FindChildren(Widget parent, Widget **children, Bool normal, Bool popup,

	     Bool extra)

{

    CompositeWidget cw = (CompositeWidget)parent;

    Cardinal i, num_children, current = 0;

    Widget *extra_widgets = NULL;

    Cardinal num_extra = 0;

    num_children = 0;

    if (XtIsWidget(parent) && popup)

	num_children += parent->core.num_popups;

    if (XtIsComposite(parent) && normal)

	num_children += cw->composite.num_children;

    if (XtIsWidget(parent) && extra)

    {

	XtResourceList norm_list, cons_list;

	Cardinal num_norm, num_cons;

	Arg args[1];

	Widget widget;

	XtGetResourceList(XtClass(parent), &norm_list, &num_norm);

	if (XtParent(parent) != NULL)

	    XtGetConstraintResourceList(XtClass(XtParent(parent)),

					&cons_list, &num_cons);

	else

	    num_cons = 0;

	extra_widgets = (Widget *)XtMalloc(sizeof(Widget));

	for (i = 0; i < num_norm; i++)

	    if (strcmp(norm_list[i].resource_type, XtRWidget) == 0)

	    {

		widget = NULL;

		XtSetArg(args[0], norm_list[i].resource_name, &widget);

		XtGetValues(parent, args, 1);

		if (widget && XtParent(widget) == parent)

		{

		    ++num_extra;

		    extra_widgets = (Widget *) XtRealloc(

			(char *)extra_widgets, num_extra * sizeof(Widget));

		    extra_widgets[num_extra - 1] = widget;

		}

	    }

	for (i = 0; i < num_cons; i++)

	    if (strcmp(cons_list[i].resource_type, XtRWidget) == 0)

	    {

		widget = NULL;

		XtSetArg(args[0], cons_list[i].resource_name, &widget);

		XtGetValues(parent, args, 1);

		if (widget && XtParent(widget) == parent)

		{

		    ++num_extra;

		    extra_widgets = (Widget *) XtRealloc(

			(char *)extra_widgets, num_extra * sizeof(Widget));

		    extra_widgets[num_extra - 1] = widget;

		}

	    }

	if (num_norm)

	    XtFree((char *)norm_list);

	if (num_cons)

	    XtFree((char *)cons_list);

    }

    if ((num_children + num_extra) == 0)

    {

	*children = NULL;

	return (0);

    }

    *children = (Widget *)XtMalloc(sizeof(Widget) * (num_children + num_extra));

    if (XtIsComposite(parent) && normal)

	for (i = 0; i < cw->composite.num_children; i++, current++)

	    (*children)[current] = cw->composite.children[i];

    if (XtIsWidget(parent) && popup)

	for (i = 0; i < parent->core.num_popups; i++, current++)

	    (*children)[current] = parent->core.popup_list[i];

    if (num_extra)

    /* Check for dups */

    {

	Cardinal j, old_num_extra = num_extra;

	qsort(extra_widgets, num_extra, sizeof(Widget), qcmp_widget_list);

	for (i = 0; i < num_extra - 1; i++)

	    while (i < num_extra - 1 &&

		   extra_widgets[i] == extra_widgets[i + 1])

	    {

		memmove(&extra_widgets[i], &extra_widgets[i + 1],

			(num_extra - i) * sizeof(Widget));

		--num_extra;

	    }

	for (i = 0; i < num_children; i++)

	    for (j = 0; j < num_extra; j++)

		if ((*children)[i] == extra_widgets[j])

		{

		    if ((j + 1) < num_extra)

			memmove(&extra_widgets[j], &extra_widgets[j + 1],

				(num_extra - j) * sizeof(Widget));

		    --num_extra;

		}

	if (old_num_extra != num_extra)

	    *children = (Widget *)XtRealloc((char *)*children, sizeof(Widget)

					    * (num_children + num_extra));

	if (num_extra)

	    memcpy(&(*children)[num_children], extra_widgets,

		   sizeof(Widget) * num_extra);

    }

    if (extra_widgets)

	XtFree((char *)extra_widgets);

    if (num_children + num_extra == 0)

    {

	XtFree((char *)*children);

	*children = NULL;

    }

    return (num_children + num_extra);

}

/*

 * Function:

 *	IsChild

 *

 * parameters:

 *	top    - top of the tree

 *	parent - parent widget

 *	child  - child widget

 *

 * Description:

 *	Check to see of child is a child of parent

 */

static Bool

IsChild(Widget top, Widget parent, Widget child)

{

    int i, num_children;

    Widget *children;

    if (parent == NULL)

	return (top == child);

    num_children = FindChildren(parent, &children, True, True, True);

    for (i = 0; i < num_children; i++)

	if (children[i] == child)

	{

	    XtFree((char *)children);

	    return (True);

	}

    XtFree((char *)children);

    return (False);

}