/* $XConsortium: EditresCom.c /main/34 1995/12/11 00:19:42 gildea $ */

/*

Copyright (c) 1989  X Consortium

Permission is hereby granted, free of charge, to any person obtaining a copy

of this software and associated documentation files (the "Software"), to deal

in the Software without restriction, including without limitation the rights

to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

copies of the Software, and to permit persons to whom the Software is

furnished to do so, subject to the following conditions:

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

X CONSORTIUM 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 X Consortium 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 X Consortium.

*/

/* $XFree86: xc/lib/Xmu/EditresCom.c,v 1.3.2.4 1999/07/23 13:22:15 hohndel Exp $ */

/*

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

 */

/*

    Replacement EditresCom.c for the one in Xmu to add the GetValues

    feature, and to modify the PositionInChild function for Motif. This

    modification is needed because Motif's VendorShell lies about the

    real position of it's child.

 */

#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. */

#define  XK_LATIN1

#include <X11/keysymdef.h>

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

#include <X11/Xatom.h>

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

#include <X11/Xmu/EditresP.h>

#include <X11/Xmu/CharSet.h>

#include <X11/Xmd.h>

#include <stdio.h>

#define _XEditResPutBool _XEditResPut8	

#define _XEditResPutResourceType _XEditResPut8

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

 *

 * Local structure definitions.

 *

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

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;

/*

 * Things that are 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)

static Atom res_editor_command, res_editor_protocol, client_value;

static Globals globals;

static void SendFailure(), SendCommand(), InsertWidget(), ExecuteCommand();

static void FreeEvent(), ExecuteSetValues(), ExecuteGetGeometry();

static void ExecuteGetResources();

static void GetCommand();

static void LoadResources();

static Boolean IsChild();

static void DumpChildren();

static char *DumpWidgets(), *DoSetValues(), *DoFindChild();

static char *DoGetGeometry(), *DoGetResources(), *DumpValues();

#ifndef HAVE_XMU_N_COPY_ISO

void _XmNCopyISOLatin1Lowered(char *dst, char *src, int size)

{

    register unsigned char *dest, *source;

    int bytes;

    if (size <= 0)

	return;

    for (dest = (unsigned char *)dst, source = (unsigned char *)src, bytes = 0;

	 *source && bytes < size - 1;

	 source++, dest++, bytes++)

    {

	if ((*source >= XK_A) && (*source <= XK_Z))

	    *dest = *source + (XK_a - XK_A);

	else if ((*source >= XK_Agrave) && (*source <= XK_Odiaeresis))

	    *dest = *source + (XK_agrave - XK_Agrave);

	else if ((*source >= XK_Ooblique) && (*source <= XK_Thorn))

	    *dest = *source + (XK_oslash - XK_Ooblique);

	else

	    *dest = *source;

    }

    *dest = '\0';

}

#endif

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

 *

 * Resource Editor Communication Code

 *

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

/*	Function Name: _XEditResCheckMessages

 *	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.

 *	Arguments: w - the shell widget.

 *                 data - *** UNUSED ***

 *                 event - The X Event that triggered this handler.

 *                 cont - *** UNUSED ***.

 *	Returns: none.

 */

/* ARGSUSED */

void

_XmEditResCheckMessages(w, data, event, cont)

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 char* names[] = {

		EDITRES_NAME, EDITRES_COMMAND_ATOM,

		EDITRES_PROTOCOL_ATOM, EDITRES_CLIENT_VALUE };

	    first_time = TRUE;

	    XInternAtoms(dpy, 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 Name: BuildEvent

 *	Description: Takes the info out the protocol stream an constructs

 *                   the proper event structure.

 *	Arguments: 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.

 *	Returns: the event, or NULL.

 */

#if defined(Lynx) && defined(ERROR_MESSAGE)

#undef ERROR_MESSAGE

#endif

#define ERROR_MESSAGE ("Client: Improperly formatted protocol request")

static EditresEvent *

BuildEvent(w, sel, data, ident, length)

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;	/* easier to think of it this way... */

    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'; /* NULL terminate that sucker. */

	    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];

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

	    SendFailure(w, sel, ident, buf);

	    return(NULL);

	}

    }

    return(event);

 done:

    SendFailure(w, sel, ident, ERROR_MESSAGE);

    FreeEvent(event);

    return(NULL);

}    

/*	Function Name: FreeEvent

 *	Description: Frees the event structure and any other pieces

 *                   in it that need freeing.

 *	Arguments: event - the event to free.

 *	Returns: none.

 */

static void

FreeEvent(event)

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 does not free if */

	XtFree(event->set_values_event.res_type); /* value is NULL. */

    }

    XtFree((char *)event);

}

/*	Function Name: GetCommand

 *	Description: Gets the Command out of the selection asserted by the

 *                   resource manager.

 *	Arguments: (See Xt XtConvertSelectionProc)

 *                 data - contains the ident number for the command.

 *	Returns: none.

 */

/* ARGSUSED */

static void

GetCommand(w, data, selection, type, value, length, format)

Widget w;

XtPointer data, value;

Atom *selection, *type;

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 Name: ExecuteCommand

 *	Description: Executes a command string received from the 

 *                   resource editor.

 *	Arguments: w       - a widget.

 *                 command - the command to execute.

 *                 value - the associated with the command.

 *	Returns: none.

 *

 * NOTES:  munges str

 */

/* ARGSUSED */    

static void

ExecuteCommand(w, sel, ident, event)

Widget w;

Atom sel;

ResIdent ident;

EditresEvent * event;

{

    char * (*func)();

    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];

	    sprintf(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);

	XtFree(str);

    }

}

/*	Function Name: ConvertReturnCommand

 *	Description: Converts a selection.

 *	Arguments: 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.

 *	Returns: True if conversion was sucessful.

 */

/* ARGSUSED */

static Boolean

ConvertReturnCommand(w, selection, target,

		     type_ret, value_ret, length_ret, format_ret)

Widget w;

Atom * selection, * target, * 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 Name: CommandDone

 *	Description: done with the selection.

 *	Arguments: *** UNUSED ***

 *	Returns: none.

 */

/* ARGSUSED */

static void

CommandDone(widget, selection, target)

Widget widget;

Atom *selection;

Atom *target;    

{

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

}

/*	Function Name: SendFailure

 *	Description: Sends a failure message.

 *	Arguments: w - the widget to own the selection.

 *                 sel - the selection to assert.

 *	 	   ident - the identifier.

 *                 str - the error message.

 *	Returns: none.

 */

static void

SendFailure(w, sel, ident, str) 

Widget w;

Atom sel;

ResIdent ident;

char * str;

{

    _XEditResResetStream(&globals.stream);

    _XEditResPutString8(&globals.stream, str);

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

}

/*	Function Name: BuildReturnPacket

 *	Description: Builds a return packet, given the data to send.

 *	Arguments: ident - the identifier.

 *                 command - the command code.

 *                 stream - the protocol stream.

 *	Returns: packet - the packet to send.

 */

static XtPointer

BuildReturnPacket(ident, command, stream)

ResIdent ident;

EditresCommand command;

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) command);

    _XEditResPut32(stream, old_size);

    stream->alloc = old_alloc;

    stream->current = old_current;

    stream->size = old_size;

    return((XtPointer) stream->real_top);

}    

/*	Function Name: SendCommand

 *	Description: Builds a return command line.

 *	Arguments: w - the widget to own the selection.

 *                 sel - the selection to assert.

 *	 	   ident - the identifier.

 *                 command - the command code.

 *                 stream - the protocol stream.

 *	Returns: none.

 */

static void

SendCommand(w, sel, ident, command, stream)

Widget w;

Atom sel;

ResIdent ident;

EditresCommand command;

ProtocolStream * stream;

{

    BuildReturnPacket(ident, command, 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.

 *

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

/*	Function Name: FindChildren

 *	Description: Retuns all children (popup, normal and otherwise)

 *                   of this widget

 *	Arguments: parent - the parent widget.

 *                 children - the list of children.

 *                 normal - return normal children.

 *                 popup - return popup children.

 *	Returns: the number of children.

 */

static int

FindChildren(parent, children, normal, popup)

Widget parent, **children;

Boolean normal, popup;

{

    CompositeWidget cw = (CompositeWidget) parent;

    int i, num_children, current = 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 (num_children == 0) {	

	*children = NULL; 

	return(0);

    }

    *children =(Widget*) XtMalloc((Cardinal) sizeof(Widget) * num_children);

    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];

    return(num_children);

}

/*	Function Name: IsChild

 *	Description: check to see of child is a child of parent.

 *	Arguments: top - the top of the tree.

 *                 parent - the parent widget.

 *                 child - the child.

 *	Returns: none.

 */

static Boolean

IsChild(top, parent, child)

Widget top, parent, child;

{

    int i, num_children;

    Widget * children;

    if (parent == NULL)

	return(top == child);

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

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

	if (children[i] == child) {

	    XtFree((char *)children);

	    return(TRUE);

	}

    }

    XtFree((char *)children);

    return(FALSE);

}

/*	Function Name: VerifyWidget

 *	Description: Makes sure all the widgets still exist.

 *	Arguments: w - any widget in the tree.

 *                 info - the info about the widget to verify.

 *	Returns: an error message or NULL.

 */

static char * 

VerifyWidget(w, info)

Widget w;

WidgetInfo *info;

{

    Widget top;

    register int count;

    register Widget parent;

    register unsigned long * child;

    for (top = w; XtParent(top) != NULL; top = XtParent(top)) {}

    parent = NULL;

    child = info->ids;

    count = 0;

    while (TRUE) {

	if (!IsChild(top, parent, (Widget) *child)) 

	    return(XtNewString("This widget no longer exists in the client."));

	if (++count == info->num_widgets)

	    break;

	parent = (Widget) *child++;

    }

    info->real_widget = (Widget) *child;

    return(NULL);

}

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

 *

 * Code to Perform SetValues operations.

 *

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

/*	Function Name: 	DoSetValues

 *	Description: performs the setvalues requested.

 *	Arguments: w - a widget in the tree.

 *                 event - the event that caused this action.

 *                 stream - the protocol stream to add.

 *	Returns: NULL.

 */

static char *

DoSetValues(w, event, stream)

Widget w;

EditresEvent * event;

ProtocolStream * stream;

{

    char * str;

    register unsigned i;

    unsigned short count = 0;

    SetValuesEvent * sv_event = (SetValuesEvent *) event;

    _XEditResPut16(stream, count); /* insert 0, will be overwritten later. */

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

	if ((str = VerifyWidget(w, &(sv_event->widgets[i]))) != NULL) {

	    _XEditResPutWidgetInfo(stream, &(sv_event->widgets[i]));

	    _XEditResPutString8(stream, str);

	    XtFree(str);

	    count++;

	}

	else 

	    ExecuteSetValues(sv_event->widgets[i].real_widget, 

			     sv_event, sv_event->widgets + i, stream, &count);

    }

    /*

     * Overwrite the first 2 bytes with the real count.

     */

    *(stream->top) = count >> XER_NBBY;

    *(stream->top + 1) = count;

    return(NULL);

}

/*	Function Name: HandleToolkitErrors

 *	Description: Handles X Toolkit Errors.

 *	Arguments: name - name of the error.

 *                 type - type of the error.

 *                 class - class of the error.

 *                 msg - the default message.

 *                 params, num_params - the extra parameters for this message.

 *	Returns: none.

 */

/* ARGSUSED */

static void

HandleToolkitErrors(name, type, class, msg, params, num_params)