daven@maxine.WPI.EDU (Dave Nedde) (06/28/91)
Submitted-by: daven@maxine.WPI.EDU (Dave Nedde)
Posting-number: Volume 13, Issue 65
Archive-name: xrainbow/part03
#! /bin/sh
# This is a shell archive. Remove anything before this line, then unpack
# it by saving it into a file and typing "sh file". To overwrite existing
# files, type "sh file -c". You can also feed this as standard input via
# unshar, or by typing "sh <file", e.g.. If this archive is complete, you
# will see the following message at the end:
# "End of archive 3 (of 5)."
# Contents: xrainbow/Wc1_05/Wc/WcConvert.c
# xrainbow/Wc1_05/Wc/WcCreate.c xrainbow/Wc1_05/Wc/WcCreate.h
# xrainbow/Wc1_05/Wc/WcCreateP.h
# xrainbow/include/X11/Xaw_d/DrawingA.h
# Wrapped by daven@ash on Mon Jun 3 12:33:23 1991
PATH=/bin:/usr/bin:/usr/ucb ; export PATH
if test -f 'xrainbow/Wc1_05/Wc/WcConvert.c' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'xrainbow/Wc1_05/Wc/WcConvert.c'\"
else
echo shar: Extracting \"'xrainbow/Wc1_05/Wc/WcConvert.c'\" \(21715 characters\)
sed "s/^X//" >'xrainbow/Wc1_05/Wc/WcConvert.c' <<'END_OF_FILE'
X/*
X** Copyright (c) 1990 David E. Smyth
X**
X** This file was derived from work performed by Martin Brunecky at
X** Auto-trol Technology Corporation, Denver, Colorado, under the
X** following copyright:
X**
X*******************************************************************************
X* Copyright 1990 by Auto-trol Technology Corporation, Denver, Colorado.
X*
X* All Rights Reserved
X*
X* Permission to use, copy, modify, and distribute this software and its
X* documentation for any purpose and without fee is hereby granted, provided
X* that the above copyright notice appears on all copies and that both the
X* copyright and this permission notice appear in supporting documentation
X* and that the name of Auto-trol not be used in advertising or publicity
X* pertaining to distribution of the software without specific, prior written
X* permission.
X*
X* Auto-trol disclaims all warranties with regard to this software, including
X* all implied warranties of merchantability and fitness, in no event shall
X* Auto-trol be liable for any special, indirect or consequential damages or
X* any damages whatsoever resulting from loss of use, data or profits, whether
X* in an action of contract, negligence or other tortious action, arising out
X* of or in connection with the use or performance of this software.
X*******************************************************************************
X**
X** Redistribution and use in source and binary forms are permitted
X** provided that the above copyright notice and this paragraph are
X** duplicated in all such forms and that any documentation, advertising
X** materials, and other materials related to such distribution and use
X** acknowledge that the software was developed by David E. Smyth. The
X** name of David E. Smyth may not be used to endorse or promote products
X** derived from this software without specific prior written permission.
X** THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
X** WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
X** MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
X**
X*/
X
X/*
X* SCCS_data: @(#)WcConvert.c 1.1 ( 19 Nov 90 )
X*
X* Subsystem_group:
X*
X* Widget Creation Library
X*
X* Module_description:
X*
X* This module contains Xt converter functions which convert strings,
X* as found in the Xrm database, into useful types.
X*
X* It also contains the routine which registers all Wc converters.
X*
X* The CvtStringToWidget converter takes a pathname which starts
X* from the application shell an proceeds to a specific widget. The
X* widget must already have been created. Note that this converter
X* needs to be used INSTEAD of the XmuCvtStringToWidget which gets
X* registered by the Athena widgets. The Xmu converter is not so
X* user friendly. This means this file also declares an external
X* function XmuCvtStringToWidget() which is really CvtStringToWidget,
X* and this needs to be linked before Xmu.
X*
X* The CvtStringToCallback converter parses the resource string in
X* the format:
X*
X* ...path: name[(args)][,name[(args)]]...
X*
X* where: name: specifies the registered callback function name
X* args: specifies the string passed to a callback as
X* "client data".
X*
X* Multiple callbacks can be specified for a single callback list
X* resource. Any callbacks must be "registered" by the application
X* prior converter invocation (.i.e.prior widget creation).
X* If no "args" string is provided, the default "client data"
X* specified at callback registration are used.
X*
X* The CvtStringToConstructor converter searches the Constructor
X* cache for a registered constructor.
X*
X* The CvtStringToClass converter searches the Class cache for a
X* registered object (widget) class pointer name.
X*
X* The CvtStringToClassName converter searches the ClassName cache
X* for a registered object (widget) class name.
X
X*
X* Module_interface_summary:
X*
X* Resource converter is invoked indirectly by the toolkit. The
X* converter is added to the toolkit by widgets calling
X* WcAddConverters() in the Wc intialization code.
X*
X* Module_history:
X*
X* mm/dd/yy initials function action
X* -------- -------- -------- ---------------------------------------------
X* 06/08/90 D.Smyth Class, ClassName, and Constructor converters.
X* 05/24/90 D.Smyth WcAddConverters created from something similar
X* 04/03/90 MarBru CvtStr.. Fixed argument termination with a NUL char
X* 02/26/90 MarBru All Created
X*
X* Design_notes:
X*
X* For VMS, we could have used LIB$FIND_IMAGE_SYMBOL and use dynamic
X* (runtime) binding. But since most UNIX systems lack such capability,
X* we stick to the concept of "registration" routines.
X*
X* One time, I considered applying conversion to callback argument, which
X* would take the burden of conversion from the callback code (runtime)
X* to the callback conversion (one time initialization). The problem is
X* that some conversions are widget context specific (color to pixel needs
X* display connection), and at the time of callback conversion I do not
X* have a widget. I could require the widget argument, but this would kill
X* caching of the conversion result.
X*
X* The sequential search of the callback cache is far from optimal. I should
X* use binary search, or the R4 conversion cache. I can't use the R4 cache
X* until Motif 1.1 is released which will (supposedly) run on R4 Intrinsics.
X*
X*******************************************************************************
X*/
X/*
X*******************************************************************************
X* Include_files.
X*******************************************************************************
X*/
X
X#include <ctype.h> /* isupper() and tolower macros */
X#include <stdio.h>
X
X/* -- X Window System includes */
X#include <X11/Intrinsic.h>
X#include <X11/StringDefs.h>
X
X/* -- Widget Creation Library includes */
X#include "WcCreate.h"
X#include "WcCreateP.h"
X
X/*
X*******************************************************************************
X* Private_constant_declarations.
X*******************************************************************************
X*/
X
X/*
X*******************************************************************************
X* Private_type_declarations.
X*******************************************************************************
X*/
X
X/*
X*******************************************************************************
X* Private_macro_definitions.
X*******************************************************************************
X*/
X
X#define done( type, value ) \
X{ \
X if ( toVal->addr != NULL ) \
X { \
X if ( toVal->size < sizeof( type ) ) \
X { \
X toVal->size = sizeof( type ); \
X return; \
X } \
X *(type*)(toVal->addr) = (value); \
X } \
X else \
X { \
X static type static_val; \
X static_val = (value); \
X toVal->addr = (caddr_t)&static_val; \
X } \
X toVal->size = sizeof(type); \
X return; \
X}
X
X/*
X*******************************************************************************
X* Private_data_definitions.
X*******************************************************************************
X*/
X
X/*
X*******************************************************************************
X* Private_function_declarations.
X*******************************************************************************
X*/
X
X/*
X -- Convert String To ClassPtr
X*******************************************************************************
X This conversion searches the Object Class cache for the appropriate
X Cache record. The resource database string is simply the name
X of the class pointer, case insensitive. The value provided is the
X widget class pointer, as passed to XtCreateWidget().
X*/
X
Xvoid CvtStringToClassPtr (args, num_args, fromVal, toVal )
X XrmValue *args;
X Cardinal *num_args;
X XrmValue *fromVal;
X XrmValue *toVal;
X{
X char* string = (char *) fromVal->addr;
X char cleanName[MAX_XRMSTRING];
X char* lowerCase;
X XrmQuark quark;
X int i;
X
X (void)WcCleanName ( string, cleanName );
X lowerCase = WcLowerCaseCopy ( cleanName );
X quark = XrmStringToQuark ( lowerCase );
X XtFree ( lowerCase );
X
X for (i=0; i<classes_num; i++)
X {
X if ( classes_ptr[i].quark == quark )
X {
X done( WidgetClass, classes_ptr[i].class );
X }
X }
X XtStringConversionWarning (cleanName, "Object Class, not registered.");
X}
X
X/*
X -- Convert String To ClassName
X*******************************************************************************
X This conversion searches the Class Name cache for the appropriate
X Cache record. The resource database string is simply the name
X of the class, case insensitive. The value provided is the widget
X class pointer, as passed to XtCreateWidget().
X*/
X
Xvoid CvtStringToClassName (args, num_args, fromVal, toVal )
X XrmValue *args;
X Cardinal *num_args;
X XrmValue *fromVal;
X XrmValue *toVal;
X{
X char* string = (char *) fromVal->addr;
X char cleanName[MAX_XRMSTRING];
X char* lowerCase;
X XrmQuark quark;
X int i;
X
X (void)WcCleanName ( string, cleanName );
X lowerCase = WcLowerCaseCopy ( cleanName );
X quark = XrmStringToQuark ( lowerCase );
X XtFree ( lowerCase );
X
X for (i=0; i<cl_nm_num; i++)
X {
X if ( cl_nm_ptr[i].quark == quark )
X {
X done( WidgetClass, cl_nm_ptr[i].class );
X }
X }
X XtStringConversionWarning (cleanName, "Class Name, not registered.");
X}
X
X/*
X -- Convert String To Constructor
X*******************************************************************************
X This conversion searches the Constructor Cache for the appropriate
X Cache record. The resource database string is simply the name
X of the constructor, case insensitive. The value provided is a
X Contrstructor Cache Record. The constructor (func ptr) itself is
X not provided, as the user of this value (generally WcCreateDatabaseChild)
X also likes to have the constructor name as registered for error messages.
X*/
X
Xvoid CvtStringToConstructor (args, num_args, fromVal, toVal)
X XrmValue *args;
X Cardinal *num_args;
X XrmValue *fromVal;
X XrmValue *toVal;
X{
X char* string = (char *) fromVal->addr;
X char cleanName[MAX_XRMSTRING];
X char* lowerCase;
X XrmQuark quark;
X int i;
X
X (void)WcCleanName ( string, cleanName );
X lowerCase = WcLowerCaseCopy ( cleanName );
X quark = XrmStringToQuark ( lowerCase );
X XtFree ( lowerCase );
X
X for (i=0; i<constrs_num; i++)
X {
X if ( constrs_ptr[i].quark == quark )
X {
X done( ConCacheRec*, &(constrs_ptr[i]) );
X }
X }
X XtStringConversionWarning (cleanName, "Constructor, not registered.");
X}
X
X/*
X -- Convert String To Callback
X*******************************************************************************
X This conversion creates a callback list structure from the X resource
X database string in format:
X
X name(arg),name(arg).....
X
X Note "name" is not case sensitive, while "arg" may be - it is passed to
X a callback as client data as a null terminated string (first level
X parenthesis stripped off). Even if nothing is specified e.g.,
X SomeCallback() there is a null terminated string passed as client
X data to the callback. If it is empty, then it is the null string.
X
X Note also that the argument CANNOT be converted at this point: frequently,
X the argument refers to a widget which has not yet been created, or
X uses the context of the callback (i.e., WcUnmanageCB( this ) uses the
X widget which invoked the callback).
X*/
X
Xtypedef struct
X{
X char *name_start, *name_end; /* callback name start, end */
X char *arg_start, *arg_end; /* argument string start, end */
X} Segment;
X
X#ifdef FUNCTION_PROTOTYPES
Xstatic int ParseCallbackString( char*, Segment*, int );
Xstatic XtCallbackRec* BuildCallbackList( Segment* );
Xstatic int GetCallbackAddrFromCache(char*, char*, XtCallbackRec* );
Xstatic void CopyArgsToCallbackClosure( char*, char*, XtCallbackRec* );
X#else
Xstatic int ParseCallbackString();
Xstatic XtCallbackRec* BuildCallbackList();
Xstatic int GetCallbackAddrFromCache();
Xstatic void CopyArgsToCallbackClosure();
X#endif
X
X/*
X -- Convert String To Callback
X*******************************************************************************
X*/
X
Xvoid CvtStringToCallback (args, num_args, fromVal, toVal)
X XrmValue *args;
X Cardinal *num_args;
X XrmValue *fromVal;
X XrmValue *toVal;
X{
X static XtCallbackRec* retval; /* return value MUST be static */
X
X Segment name_arg_segments[MAX_CALLBACKS];
X char* string = (char *) fromVal->addr;
X
X/* -- assume error or undefined input argument */
X toVal->size = 0;
X toVal->addr = (caddr_t) NULL;
X
X if (ParseCallbackString( string, name_arg_segments, MAX_CALLBACKS ))
X return;
X
X /* name_arg_segments[MAX_CALLBACKS-1].name_start MUST be NULL
X */
X retval = BuildCallbackList( name_arg_segments );
X
X toVal->size = sizeof(XtCallbackRec*);
X toVal->addr = (caddr_t)&retval;
X}
X
X/*
X -- Parse string into name+argument segments: returns 1 if failed
X*******************************************************************************
X*/
X
Xstatic int ParseCallbackString( string, seg, num_segs )
X char* string;
X Segment* seg;
X int num_segs;
X{
X register char* cp = string;
X register char* ws;
X register int in_parens = 0;
X
X/* -- Don't need to do anything if there is nothing interesting in string */
X if ( cp == NULL) return 1;
X if (*cp == NULL) return 1;
X
X /* skip leading whitespace */
X while( *cp <= ' ' )
X if (*++cp == NULL) return 1;
X
X/* -- Always end the parse on a null to make life easier */
X#define NEXT_CHAR if (*++cp == NULL) goto end_of_parse;
X#define BARF(str) { XtStringConversionWarning( string, str ); return 1; }
X
X while (1) /* parsing loop */
X {
X /* start new segment: we've got the start of the callback name,
X ** and nothing else.
X */
X seg->name_start = cp;
X seg->name_end = seg->arg_start = seg->arg_end = (char*)NULL;
X
X
X /* take care of possible error - barf if *cp is left paren or comma */
X if ( *cp == '(' || *cp == ',' )
X BARF( "Callback, name cannot start with `(' or `,'" )
X
X /* name is everything up to whitespace, a left paren, or comma */
X while( ' ' < *cp && *cp != '(' && *cp != ',' )
X NEXT_CHAR
X
X seg->name_end = cp-1; /* found end of the callback name */
X
X /* There may be whitespace between name and left paren or comma */
X while( *cp <= ' ' )
X NEXT_CHAR
X
X /* if we've found a left paren, collect the argument */
X if ( *cp == '(' )
X {
X ws = cp; /* actually points at initial left paren */
X in_parens = 1;
X while (in_parens)
X {
X NEXT_CHAR /* 1st time skips the initial left paren */
X if ( '(' == *cp ) in_parens++;
X if ( ')' == *cp ) in_parens--;
X }
X /* Now cp actually points at final right paren. Lets get rid of
X ** leading and trailing argument whitespace. If only whitespace
X ** then leave seg->arg_start == seg->arg_end == NULL
X */
X do {
X ws++; /* skip initial '(', will hit ')' at cp if no arg */
X } while ( *ws <= ' ' );
X if (ws != cp)
X {
X seg->arg_start = ws; /* first non-whitespace of argument */
X ws = cp; /* now look at the final right paren */
X do {
X ws--;
X } while ( *ws <= ' ' );
X seg->arg_end = ws;
X }
X NEXT_CHAR /* skip final right paren */
X }
X /* Skip optional comma separator, then do next segment */
X while( *cp <= ' ' || *cp == ',' )
X NEXT_CHAR
X
X seg++;
X /* NB: we must have space for following `NULL' segment */
X if ( --num_segs < 2 )
X BARF( "Callback, Too many callbacks" );
X }
X
Xend_of_parse:
X /* Got here because we've detected the NULL terminator. We
X ** could have hit the NULL at any of the "NEXT_CHAR" invocations.
X */
X
X if (seg->name_start && !seg->name_end)
X seg->name_end = cp-1; /* callback name */
X else if ( in_parens )
X BARF( "Callback, Unbalanced parens in callback argument" )
X
X seg++; seg->name_start = (char*)NULL; /* following seg is NULL */
X
X return 0; /* sucessful parse */
X}
X
X/*
X -- Build XtCallbackList based on name+arg segments
X*******************************************************************************
X*/
X
Xstatic XtCallbackRec* BuildCallbackList( seg )
X Segment* seg;
X{
X XtCallbackRec callback_list[MAX_CALLBACKS]; /* temporary */
X XtCallbackRec* rec = callback_list;
X int callback_list_len = 0;
X int bytes;
X
X/* -- process individual callback string segments "name(arg)" */
X for( ; seg->name_start ; seg++ )
X {
X if ( GetCallbackAddrFromCache( seg->name_start, seg->name_end, rec ) )
X {
X CopyArgsToCallbackClosure( seg->arg_start, seg->arg_end, rec );
X rec++;
X callback_list_len++;
X }
X }
X
X/* -- terminate the callback list */
X {
X rec->callback = NULL;
X rec->closure = NULL;
X callback_list_len++;
X }
X
X/* -- make a permanent copy of the new callback list, and return a pointer */
X bytes = callback_list_len * sizeof(XtCallbackRec);
X rec = (XtCallbackRec*)XtMalloc( bytes );
X memcpy ( (char*)rec, (char*)callback_list, bytes );
X return rec;
X}
X
X/*
X -- Find named callback in callback cache: TRUE if found
X*******************************************************************************
X Searches the Callback cache, gets the address of the callback
X function, and the default closure data as registered.
X*/
X
Xstatic int GetCallbackAddrFromCache( name_start, name_end, rec )
X char* name_start;
X char* name_end;
X XtCallbackRec* rec;
X{
X static char lowerCaseName[MAX_XRMSTRING];
X register char* cp = name_start;
X register char* dest = lowerCaseName;
X register int i;
X XrmQuark quark;
X
X /* our callback cache names are case insensitive */
X while( cp <= name_end )
X *dest++ = (isupper(*cp) ) ? tolower (*cp++) : *cp++;
X *dest = NUL;
X
X /* try to locate callback in our cache of callbacks */
X quark = XrmStringToQuark (lowerCaseName);
X
X for ( i=0 ; i < callbacks_num ; i++ )
X {
X if ( callbacks_ptr[i].quark == quark )
X {
X rec->callback = callbacks_ptr[i].callback;
X rec->closure = callbacks_ptr[i].closure; /* default closure */
X return 1;
X }
X }
X XtStringConversionWarning ( lowerCaseName,
X "Callback, unknown callback name");
X return 0;
X}
X
X/*
X -- Copy arguments from segment into XtCallbackList
X*******************************************************************************
X*/
X
Xstatic void CopyArgsToCallbackClosure( arg_start, arg_end, rec )
X char* arg_start;
X char* arg_end;
X XtCallbackRec* rec;
X{
X register char *arg;
X register int alen;
X
X if ( arg_start )
X {
X /* arg in parens - pass as string replacing default closure */
X alen = 1 + (int)arg_end - (int)arg_start;
X arg = XtMalloc(alen+1);
X strncpy ( arg, arg_start, alen );
X arg[alen] = NUL;
X rec->closure = (caddr_t)arg;
X }
X else
X {
X /* no arg in parens. Make sure closure is something -
X ** do NOT return NULL in any event. Causes SEGV too
X ** easily.
X */
X if (rec->closure == NULL)
X rec->closure = (caddr_t)"";
X }
X}
X
X/*
X -- Convert String To Widget
X*******************************************************************************
X This conversion creates a Widget id from the X resource database string.
X The conversion will fail, and WcFullNameToWidget() will issue a warning,
X if the widget so named has not been created when this converter is called.
X For example, if a widget refers to itself for some reason, during
X its creation when this converter is called, it is not yet created:
X therefore, the converter will fail.
X*/
X
Xvoid XmuCvtStringToWidget (args, num_args, fromVal, toVal)
X XrmValue *args;
X Cardinal *num_args;
X XrmValue *fromVal;
X XrmValue *toVal;
X{
X toVal->addr =
X (caddr_t) WcFullNameToWidget( WcRootWidget(NULL), fromVal->addr);
X toVal->size = sizeof(Widget);
X}
X
X/*
X*******************************************************************************
X* Public_function_declarations.
X*******************************************************************************
X*/
X
X/*
X -- Add String To ... Convertors
X*******************************************************************************
X*/
X
Xvoid WcAddConverters ( app )
X XtAppContext app;
X{
X ONCE_PER_XtAppContext( app );
X
X XtAddConverter (XtRString,
X WcRClassPtr,
X CvtStringToClassPtr,
X (XtConvertArgList)NULL,
X (Cardinal)0);
X
X XtAddConverter (XtRString,
X WcRClassName,
X CvtStringToClassName,
X (XtConvertArgList)NULL,
X (Cardinal)0);
X
X XtAddConverter (XtRString,
X WcRConstructor,
X CvtStringToConstructor,
X (XtConvertArgList)NULL,
X (Cardinal)0);
X
X XtAddConverter (XtRString,
X XtRCallback,
X CvtStringToCallback,
X (XtConvertArgList)NULL,
X (Cardinal)0);
X
X XtAddConverter (XtRString,
X XtRWidget,
X XmuCvtStringToWidget,
X (XtConvertArgList)NULL,
X (Cardinal)0);
X}
END_OF_FILE
if test 21715 -ne `wc -c <'xrainbow/Wc1_05/Wc/WcConvert.c'`; then
echo shar: \"'xrainbow/Wc1_05/Wc/WcConvert.c'\" unpacked with wrong size!
fi
# end of 'xrainbow/Wc1_05/Wc/WcConvert.c'
fi
if test -f 'xrainbow/Wc1_05/Wc/WcCreate.c' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'xrainbow/Wc1_05/Wc/WcCreate.c'\"
else
echo shar: Extracting \"'xrainbow/Wc1_05/Wc/WcCreate.c'\" \(27716 characters\)
sed "s/^X//" >'xrainbow/Wc1_05/Wc/WcCreate.c' <<'END_OF_FILE'
X/*
X** Copyright (c) 1990 David E. Smyth
X**
X** This file was derived from work performed by Martin Brunecky at
X** Auto-trol Technology Corporation, Denver, Colorado, under the
X** following copyright:
X**
X*******************************************************************************
X* Copyright 1990 by Auto-trol Technology Corporation, Denver, Colorado.
X*
X* All Rights Reserved
X*
X* Permission to use, copy, modify, and distribute this software and its
X* documentation for any purpose and without fee is hereby granted, provided
X* that the above copyright notice appears on all copies and that both the
X* copyright and this permission notice appear in supporting documentation
X* and that the name of Auto-trol not be used in advertising or publicity
X* pertaining to distribution of the software without specific, prior written
X* permission.
X*
X* Auto-trol disclaims all warranties with regard to this software, including
X* all implied warranties of merchantability and fitness, in no event shall
X* Auto-trol be liable for any special, indirect or consequential damages or
X* any damages whatsoever resulting from loss of use, data or profits, whether
X* in an action of contract, negligence or other tortious action, arising out
X* of or in connection with the use or performance of this software.
X*******************************************************************************
X**
X** Redistribution and use in source and binary forms are permitted
X** provided that the above copyright notice and this paragraph are
X** duplicated in all such forms and that any documentation, advertising
X** materials, and other materials related to such distribution and use
X** acknowledge that the software was developed by David E. Smyth. The
X** name of David E. Smyth may not be used to endorse or promote products
X** derived from this software without specific prior written permission.
X** THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
X** WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
X** MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
X**
X*/
X
X/*
X* SCCS_data: @(#)WcCreate.c 1.1 ( 19 Nov 90 )
X*
X* Subsystem_group:
X*
X* Widget Creation Library
X*
X* Module_description:
X*
X* This module contains the functions used to create and manage
X* a widget tree using the Xrm database.
X
X* The Xrm database format used to prescribe widget's children
X* is as follows:
X*
X* ...parent.wcChildren: childName1, childName2, ...
X*
X* The type of each child must be specified. There are three
X* ways of doing this: (1) by widget class (class pointer name),
X* (2) by widget class name, and (3) by widget constructor
X* function name. The resource value given is case insensitive,
X* although one is encouraged to use the capitalization given
X* in the reference manuals simply on stylistic grounds. The
X* three examples below are effectively equivalent:
X*
X* ...drawing.wcClass: xmDrawingAreaWidgetClass
X* ...drawing.wcClassName: XmDrawingArea
X* ...drawing.wcConstructor: XmCreateDrawingArea
X*
X* Since there are multiple ways of specifying the widget type,
X* a precedence is defined: wcClass is the highest precedence,
X* and wcClass > wcClassName > wcConstructor.
X*
X* Currently, the Motif widget set defines many constructors, such
X* as XmCreateForm or XmCreateFileSelectionBox. Constructors are
X* somtimes called Convenience Functions or even Confusion Functions.
X* It is highly recommended that you use the WcTrace resource when
X* first using Constructors in order to see the resulting widget
X* heirarchy more clearly. The WcTrace resource is specified as:
X*
X* ...drawing.wcTrace: True
X
X* By default, all widgets created from the Xrm resource database
X* are managed. In some cases, this is not what is desired: for
X* example, pop-up menus are generally not managed when they are
X* created, rather they are managed due to some mouse event. In
X* such cases, the WcManaged resource should be set False, as below:
X*
X* *fileMenu.wcManaged: False
X
X* It is possible to bind one or more callback functions to the
X* creation of a widget by using the WcCallback resource. For
X* example, using the Motif widget set, when a menu bar is created
X* as a child of an XmMainWindow, the menuBar resource of the
X* XmMainWindow needs to be set to refer to the menu bar. For
X* example:
X*
X* App.main.wcClassName: XmMainWindow
X* App.main.wcChildren: mbar
X* *mbar.wcConstructor: XmCreateMenuBar
X* *mbar.wcCallback: WcSetResourceCB( *main.menuBar: this)
X
X* Sometimes widget heirarchies are dynamic: many of the widgets
X* are created at initialization time, but others need to be created
X* at run time. Simply do not include the names of the dynamic
X* created widgets in any wcChildren resource. They will then still
X* be defined in the Xrm database, but they will not be created
X* during the initial widget tree creation.
X
X* The WcDeferred resource is an obsolete mechanism which should no
X* longer be used.
X
X* For example, let's say your interface includes a box world, where
X* the user can create an arbitrary number of various types of boxes:
X
X* *box_world.wcClass: MyBoxWorldWidgetClass
X*
X* *box_type1.wcClass: MyBoxType1WidgetClass
X* *box_type2.wcClass: MyBoxType2WidgetClass
X* *box_type3.wcClass: MyBoxType3WidgetClass
X* *box_type3.wcChildren: child1, child2, child3, child4
X*
X* *button1.callback: WcCreateChildrenCB( *box_world, box_type1 )
X* *button2.callback: WcCreateChildrenCB( *box_world, box_type2 )
X* *button3.callback: WcCreateChildrenCB( *box_world, box_type3 )
X*
X* Initially, when box_world is created, it will have no children.
X* Each time button1 is pressed, another instance of box_type1 will
X* be created as a child of box_world, and managed (since wcManaged
X* is by default True). Similarly, everytime button2 is pressed
X* another box_type2 will be created, and everytime button3 is
X* pressed another box_type3 will be created, along with children
X* named child1, child2, child3, and child4, and their children as
X* applicable.
X
X* User interfaces are often rather complex. Since the Widget
X* Creation Library allows much more of the interface to be
X* specified in resource files than in prehistoric days of
X* Widget application programming, it becomes necessary to allow
X* interfaces to be specified in a collection of resource files.
X*
X* It is very desirable that anything in the interface can be
X* tailored by the user. Therefore, each resource filename
X* loaded to describe an interface must be searched for in
X* all the locations defined by the Xt Intrinsics. This is
X* exactly the same as the initial resource file.
X*
X* Since a resource file may override any of the resources on
X* a given widget, including other creation resources, the
X* resource file name is first fetched before any of the other
X* wc* resources.
X*
X* A resource file name is specified as follows:
X*
X* *menuBar.wcResFile: MenuBar
X*
X* Each of the standard directories will be searched in order
X* for a file named MenuBar, and each merged into the resource database.
X
X* The following is the complete set of resources which are
X* interpreted by the Widget Creation Library:
X*
X* ...widget.wcChildren: childName1, childName2, ...
X* ...widget.wcClass: classPointerName
X* ...widget.wcClassName: className
X* ...widget.wcConstructor: constructorFunctionName
X* ...widget.wcTrace: true/false (default = false)
X* ...widget.wcManaged: true/false (default = true)
X* ...widget.wcCallback: callback1(args), callback2(args), ...
X* ...widget.wcResFile: filename
X*
X* In all cases, the Widget Creation resource names can be
X* specified as Wc<name> or wc<name>, with the capitalized
X* form having looser binding (representing the resource class).
X
X* Example:
X*
X* HelloWorld.wcChildren: push
X*
X* *push.wcClass: xmPushButtonWidgetClass
X* *push.labelString: Hello World
X* *push.activateCallback: WcExitCB(1)
X
X* Since (for portability reasons) we can not assume runtime binding,
X* all widget classes or creation routines (constructors) must be
X* "registered" by the application BEFORE widget tree creation.
X*
X* The widget tree creation is performed by the WcCreateDatabaseChild()
X* function, which descends the widget tree recursively until no more
X* children are found, or a non-composite widget/object is found.
X*
X* Several convenience callbacks are provided with the package, allowing
X* deferred widget creation, control (manage/unmanage) and other utility
X* functions. These are found in WcCallb.c
X*
X* Module_history:
X
X* mm/dd/yy initials function action
X* -------- -------- -------- ---------------------------------------------
X* 13Aug90 D.Smyth Got rid of WcDefered stuff
X* 11Jul90 D.Smyth Added wcResFile resource
X* 30Jun90 R.Whitby WcWidgetCreation added call to WcRegisterWcActions
X* 19Jun90 D.Smyth Version 1.0
X* 04/18/90 MarBru many.. Changed w->core.name to XrmQuarkToString...
X* 03/27/90 MarBru Creation Converted to a completely new syntax
X* 02/16/90 MarBru Create.. Limited creation to composite widgets/objects
X*
X* Design_notes:
X*
X*******************************************************************************
X*/
X/*
X*******************************************************************************
X* Include_files.
X*******************************************************************************
X*/
X
X/* -- Operating system includes */
X#include <stdio.h>
X
X/* -- X Window System includes */
X#include <X11/IntrinsicP.h>
X#include <X11/StringDefs.h>
X
X/* -- Widget Creation Includes */
X#include "WcCreate.h"
X#include "WcCreateP.h"
X
X/*
X*******************************************************************************
X* Private_data_definitions.
X*******************************************************************************
X*/
X
Xstatic char msg[MAX_ERRMSG];
X
X/* -- Creation resources
X NOTE: All resource values are fetched at once, but if WcResFile
X is specified, then the resource files must be loaded and then
X the resources re-fetched. This is an optimization: usually
X WcResFile is not specified, so two fetches from the Xrm database
X do not need to be done in the normal case. If resource files are
X loaded and the resources are re-fetched, WcResFile is ignored.
X NOTE: The WcClass and WcClassName resources are both converted to
X a class pointer, as we can construct useful error messages using:
X class->core_class.class_name
X However, the Constructor must be the entire constructor cache
X record so we have the name of the constructor for the error
X messages.
X NOTE: WcClass and WcClassName write to different ResourceRec
X members, so we can provide better error messages.
X*/
X
XXtResource wc_resources[] =
X {
X { WcNwcResFile, WcCWcResFile, XtRString, sizeof(String),
X XtOffset(ResourceRecPtr, resFile ), XtRImmediate, (caddr_t) NULL
X },
X { WcNwcChildren, WcCWcChildren, XtRString, sizeof(String),
X XtOffset(ResourceRecPtr, children ), XtRImmediate, (caddr_t) NULL
X },
X { WcNwcPopups, WcCWcPopups, XtRString, sizeof(String),
X XtOffset(ResourceRecPtr, popups ), XtRImmediate, (caddr_t) NULL
X },
X { WcNwcClass, WcCWcClass, WcRClassPtr, sizeof(caddr_t),
X XtOffset(ResourceRecPtr, class ), XtRImmediate, (caddr_t) NULL
X },
X { WcNwcClassName, WcCWcClassName, WcRClassName, sizeof(caddr_t),
X XtOffset(ResourceRecPtr, classFromName ), XtRImmediate, (caddr_t) NULL
X },
X { WcNwcConstructor, WcCWcConstructor, WcRConstructor, sizeof(caddr_t),
X XtOffset(ResourceRecPtr, constructor ), XtRImmediate, (caddr_t) NULL
X },
X { WcNwcManaged, WcCWcManaged, XtRBoolean, sizeof(Boolean),
X XtOffset(ResourceRecPtr, managed), XtRImmediate, (caddr_t) TRUE
X },
X { WcNwcTrace, WcCWcTrace, XtRBoolean, sizeof(Boolean),
X XtOffset(ResourceRecPtr, trace), XtRImmediate, (caddr_t) FALSE
X },
X { WcNwcCallback, WcCWcCallback, XtRCallback, sizeof(XtCallbackList),
X XtOffset(ResourceRecPtr, callback ), XtRImmediate, (caddr_t) NULL
X }
X };
X
X/*
X*******************************************************************************
X* Private_function_declarations.
X*******************************************************************************
X*/
X
X#define TRACE_CREATION 1
X#define TRACE_POPUP 2
X
X#ifdef FUNCTION_PROTOTYPES
Xstatic void GetWcResources( ResourceRec*, Widget, char* nm, char* class );
Xstatic int DuplicateType ( ResourceRec*, Widget, char* nm, char* callr );
Xstatic Widget CreateWidget ( ResourceRec*, Widget, char* nm, char* callr );
Xstatic Widget CreatePopup ( ResourceRec*, Widget, char* nm, char* callr );
Xstatic void CreationWarningMessage ( ResourceRec* rp, Widget pw,
X char* name, char* caller, char* func );
Xstatic void PrintCreationTrace ( ResourceRec*, Widget child, int traceTyp );
Xstatic void CallCreationCallbacks( ResourceRec*, Widget child );
X#else
Xstatic void GetWcResources();
Xstatic int DuplicateType();
Xstatic Widget CreateWidget();
Xstatic Widget CreatePopup();
Xstatic void CreationWarningMessage();
Xstatic void PrintCreationTrace();
Xstatic void CallCreationCallbacks();
X#endif
X
X/*
X*******************************************************************************
X* Public_function_declarations.
X*******************************************************************************
X*/
X
X/*
X -- Create Widget Tree from Xrm Database
X*******************************************************************************
X This routine creates widget children as defined in Xrm database.
X It checks the widget resource "WcChildren", which is a list of
X names of children to create. Each child must then be further defined
X in the databse.
X
X This function is frequently called from an application's main()
X procedure after the application shell is created via XtInitialize().
X
X Note that this function registers the converters for StringToWidget,
X StringToCallback, and so forth.
X*/
X
Xvoid WcWidgetCreation ( root )
X Widget root;
X{
X XtAppContext app = XtWidgetToApplicationContext( root );
X char* fullName = WcWidgetToFullName( root ); /* must be XtFree'd */
X ResourceRec res;
X
X /* register the root of this widget */
X (void)WcRootWidget(root);
X
X /* register the Xt standard widgets */
X WcRegisterIntrinsic ( app );
X
X /* register the Wc converters */
X WcAddConverters( app );
X
X /* register the Wc callbacks */
X WcRegisterWcCallbacks ( app );
X
X /* register the Wc actions */
X WcRegisterWcActions ( app );
X
X if ( XtIsSubclass( root, compositeWidgetClass ) )
X {
X XtGetApplicationResources ( root, &res,
X wc_resources, XtNumber(wc_resources), NULL, 0 );
X
X if ( res.popups || res.children )
X {
X if ( res.popups )
X WcCreateNamedPopups ( root, res.popups );
X if ( res.children )
X WcCreateNamedChildren ( root, res.children );
X }
X else
X {
X sprintf( msg,
X "WcWidgetCreation (%s) - Failed \n\
X Problem: No children defined in Xrm database.\n\
X Possible: resource file not found (XENVIRONEMENT not set?), \n\
X Possible: top level widget in resource file not named %s",
X fullName, root->core.name );
X XtWarning( msg );
X }
X }
X
X else
X {
X sprintf( msg,
X "WcWidgetCreation (%s) - Failed \n\
X Problem: %s is not a composite widget, cannot have children.",
X fullName, fullName );
X XtWarning( msg );
X }
X
X XtFree ( fullName );
X}
X
X/*
X -- Create And Manage Named Children from Xrm Database
X*******************************************************************************
X This function creates widget's children specified by names list,
X by calling WcCreateDatabaseChild() for each of the names provided.
X
X All the children are then managed, unless WcManaged resource is FALSE.
X
X Note that widgets created by WcCreateDatabaseChild may or may not
X be children of `pw' due to the use of constructors. Only children
X of `pw' may be managed via a call to XtManageChildren(). Other
X widgets must be managed individually. Usually, these widgets
X are created by the XmCreateScrolled*() or XmCreate*Dialog confusion
X functions.
X*/
X
Xvoid WcCreateNamedChildren ( pw, names )
X Widget pw; /* children's parent */
X char* names; /* (list of) widget names to create */
X{
X Widget child;
X int children = 0;
X Widget widget_children[MAX_CHILDREN];
X int other = 0;
X Widget widget_other[MAX_CHILDREN];
X char cleanName[MAX_XRMSTRING];
X char* next;
X int managed;
X int i;
X
X if ( !names ) return;
X
X next = WcCleanName( names, cleanName );
X
X while ( cleanName[0] )
X {
X child = WcCreateDatabaseChild ( pw, cleanName, &managed );
X if ( child )
X {
X if ( managed && (XtParent( child ) == pw ) )
X widget_children[children++] = child;
X else if ( managed )
X widget_other[other++] = child;
X }
X next = WcSkipWhitespace_Comma( next );
X next = WcCleanName( next, cleanName );
X }
X
X if ( children )
X XtManageChildren( widget_children, children );
X
X for (i = 0 ; i < other ; i++)
X XtManageChild( widget_other[i] );
X}
X
X/*
X -- Create Named Popup Children from Xrm Database
X*******************************************************************************
X This function creates widget's popup children specified by names list,
X by calling WcCreateDatabasePopup() for each of the names provided.
X*/
X
Xvoid WcCreateNamedPopups ( pw, names )
X Widget pw; /* children's parent */
X char* names; /* (list of) names of popup widgets to create */
X{
X Widget child;
X char cleanName[MAX_XRMSTRING];
X char* next;
X
X if ( !names ) return;
X
X next = WcCleanName( names, cleanName );
X
X while ( cleanName[0] )
X {
X child = WcCreateDatabasePopup ( pw, cleanName );
X next = WcSkipWhitespace_Comma( next );
X next = WcCleanName( next, cleanName );
X }
X}
X
X/*
X -- Create Widget from the Resource Database
X*******************************************************************************
X WcCreateDatabaseChild() causes a normal child to be created. This
X implies that the parent widget is a composite widget.
X*/
X
XWidget WcCreateDatabaseChild ( pw, name, managed )
X Widget pw; /* child's parent */
X char* name; /* child name to create */
X int *managed; /* returned T/F: this child to be managed ? */
X{
X ResourceRec res; /* child's creation resources */
X Widget child; /* what we create */
X char* className; /* get after child is created */
X
X *managed = FALSE; /* Assume error */
X
X if ( !XtIsSubclass( pw, compositeWidgetClass ) )
X {
X /* child is not a manager widget, so cannot create children */
X char* parentName = WcWidgetToFullName( pw );
X sprintf( msg,
X "WcCreateDatabaseChild (%s) - children ignored \n\
X Problem: %s is not a composite, cannot have children.",
X parentName, parentName );
X XtWarning( msg );
X XtFree( parentName );
X return (Widget)NULL;
X }
X
X GetWcResources ( &res, pw, name, name );
X if (DuplicateType ( &res, pw, name, "WcCreateDatabaseChild" ))
X return (Widget)NULL;
X
X child = CreateWidget ( &res, pw, name, "WcCreateDatabaseChild" );
X
X /* Now that widget is created, we can get the "class" resources */
X className = child->core.widget_class->core_class.class_name;
X GetWcResources ( &res, pw, name, className );
X
X if (res.trace)
X PrintCreationTrace ( &res, child, TRACE_CREATION );
X if (res.callback)
X CallCreationCallbacks ( &res, child );
X
X if (res.popups)
X WcCreateNamedPopups ( child, res.popups );
X if (res.children)
X WcCreateNamedChildren ( child, res.children );
X
X *managed = res.managed;
X return child;
X}
X
X/*
X -- Create Popup Widget from the Resource Database
X*******************************************************************************
X WcCreateDatabasePopup() causes a popup widget to be created. Any
X widget can have popup chidren.
X*/
X
XWidget WcCreateDatabasePopup ( pw, name )
X Widget pw; /* child's parent */
X char* name; /* child name to create */
X{
X ResourceRec res; /* child's creation resources */
X Widget child; /* what we create */
X char* className; /* get after child is created */
X
X GetWcResources ( &res, pw, name, name );
X if (DuplicateType ( &res, pw, name, "WcCreateDatabasePopup" ))
X return (Widget)NULL;
X
X child = CreatePopup ( &res, pw, name, "WcCreateDatabasePopup" );
X
X /* Now that widget is created, we can get the "class" resources */
X className = child->core.widget_class->core_class.class_name;
X GetWcResources ( &res, pw, name, className );
X
X if (res.trace)
X PrintCreationTrace ( &res, child, TRACE_POPUP );
X if (res.callback)
X CallCreationCallbacks ( &res, child );
X
X if (res.popups)
X WcCreateNamedPopups ( child, res.popups );
X if (res.children)
X WcCreateNamedChildren ( child, res.children );
X
X return child;
X}
X
X/*
X*******************************************************************************
X** Private functions used by WcCreateDatabaseChild and WcCreateDatabasePopup
X*******************************************************************************
X*/
X
X/*
X -- Get Wc* Resources for named child of pw from Xrm resource database
X*******************************************************************************
X*/
X
Xstatic void GetWcResources( rp, pw, name, className )
X ResourceRec* rp;
X Widget pw;
X char* name;
X char* className;
X{
X /* Get creation resources for the child to be created.
X ** After this XtGetSubresources() call, the resource structure `res'
X ** contains resources specified in the Xrm database or the defaults.
X */
X XtGetSubresources ( pw, rp, name, className,
X wc_resources, XtNumber(wc_resources), NULL, 0 );
X
X /* if a resource file is specified for this widget, first
X ** load the resource file, then re-fetch the resources.
X ** Notice that we don't check for resFile again.
X */
X if ( rp->resFile )
X {
X WcLoadResourceFileCB ( pw, rp->resFile, NULL );
X XtGetSubresources ( pw, rp, name, className,
X wc_resources, XtNumber(wc_resources), NULL, 0 );
X }
X}
X
X/*
X -- See if duplicate type resources are specified for this widget
X*******************************************************************************
X Exactly one of WcClass, WcClassName, or WcConstructor must be
X specified in order to create a widget. If none are specified,
X or if more than one is specified, then this is an error, and
X this function returns TRUE, and the widget should not then be
X created.
X*/
X
Xstatic int DuplicateType( rp, pw, name, caller )
X ResourceRec* rp;
X Widget pw;
X char* name;
X char* caller;
X{
X /* Booleans */
X int class = (NULL != rp->class);
X int className = (NULL != rp->classFromName);
X int constructor = (NULL != rp->constructor);
X char* reason;
X char* parentName;
X
X if ( class + className + constructor == 0 )
X reason = "No WcClass, WcClassName, nor WcConstructor";
X
X else if ( class + className + constructor == 3 )
X reason = "WcClass, WcClassName, and WcConstructor";
X
X else if ( class + className == 2 )
X reason = "WcClass and WcClassName";
X
X else if ( class + constructor == 2 )
X reason = "WcClass and WcConstructor";
X
X else if ( className + constructor == 2 )
X reason = "WcClassName and WcConstructor";
X
X else
X return 0; /* OK */
X
X parentName = WcWidgetToFullName( pw );
X sprintf( msg,
X "%s (%s.%s) - Failed (Ambiguous) \n\
X Problem: %s specified, \n\
X child %s.%s not created.",
X caller, parentName, name,
X reason,
X parentName, name );
X XtWarning( msg );
X XtFree( parentName );
X return 1;
X}
X
X/*
X -- Create child widget using XtCreateWidget or constructor
X*******************************************************************************
X*/
X
Xstatic Widget CreateWidget ( rp, pw, name, caller )
X ResourceRec* rp;
X Widget pw;
X char* name;
X char* caller;
X{
X Widget child;
X
X if ( rp->class )
X child = XtCreateWidget ( name, rp->class, pw, NULL, 0 );
X else if ( rp->classFromName )
X child = XtCreateWidget ( name, rp->classFromName , pw, NULL, 0 );
X else /* rp->constructor */
X child = rp->constructor->constructor( pw, name, NULL, 0 );
X
X if (child)
X return child;
X CreationWarningMessage( rp, pw, name, caller, "XtCreateWidget" );
X return (Widget)NULL;
X}
X
X/*
X -- Create child widget using XtCreateWidget or constructor
X*******************************************************************************
X*/
X
Xstatic Widget CreatePopup ( rp, pw, name, caller )
X ResourceRec* rp;
X Widget pw;
X char* name;
X char* caller;
X{
X Widget child;
X
X if ( rp->class )
X child = XtCreatePopupShell ( name, rp->class, pw, NULL, 0 );
X else if ( rp->classFromName )
X child = XtCreatePopupShell ( name, rp->classFromName , pw, NULL, 0 );
X else /* rp->constructor */
X child = rp->constructor->constructor( pw, name, NULL, 0 );
X
X if (child)
X return child;
X CreationWarningMessage( rp, pw, name, caller, "XtCreatePopupShell" );
X return (Widget)NULL;
X}
X
X/*
X -- Print warning message when CreateWidget or CreatePopup fail
X*******************************************************************************
X*/
X
Xstatic void CreationWarningMessage ( rp, pw, name, caller, func )
X ResourceRec* rp;
X Widget pw;
X char* name;
X char* caller;
X char* func;
X{
X char* parentName = WcWidgetToFullName( pw );
X static char funcWithArgs[1024];
X
X if ( rp->class || rp->classFromName )
X {
X sprintf( funcWithArgs, "%s( %s, %s )",
X func, name, rp->class->core_class.class_name );
X }
X else /* rp->constructor */
X {
X sprintf( funcWithArgs, "%s( %s )", rp->constructor->name, name );
X }
X
X sprintf( msg,
X "%s (%s.%s) - Failed \n\
X Problem: %s failed.",
X caller, parentName, name,
X funcWithArgs );
X
X XtWarning( msg );
X XtFree( parentName );
X}
X
X/*
X -- Print creation trace message
X*******************************************************************************
X*/
X
Xstatic void PrintCreationTrace( rp, child, traceType )
X ResourceRec* rp;
X Widget child;
X int traceType;
X{
X char* childName = WcWidgetToFullName( child );
X char* trace;
X
X if (traceType == TRACE_CREATION)
X trace = (rp->managed) ? " managed" : "unmanaged";
X else
X trace = " pop-up";
X
X fprintf(stderr,"Wc %s: %s of class %s\n",
X trace,
X childName,
X child->core.widget_class->core_class.class_name);
X
X XtFree( childName );
X}
X
X/*
X -- Call creation time callbacks specified by WcCallbacks resource.
X*******************************************************************************
X*/
X
Xstatic void CallCreationCallbacks( rp, child )
X ResourceRec* rp;
X Widget child;
X{
X XtCallbackRec *cb = rp->callback;
X for ( ; cb->callback; cb++ )
X (*cb->callback)( child, cb->closure, NULL );
X}
END_OF_FILE
if test 27716 -ne `wc -c <'xrainbow/Wc1_05/Wc/WcCreate.c'`; then
echo shar: \"'xrainbow/Wc1_05/Wc/WcCreate.c'\" unpacked with wrong size!
fi
# end of 'xrainbow/Wc1_05/Wc/WcCreate.c'
fi
if test -f 'xrainbow/Wc1_05/Wc/WcCreate.h' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'xrainbow/Wc1_05/Wc/WcCreate.h'\"
else
echo shar: Extracting \"'xrainbow/Wc1_05/Wc/WcCreate.h'\" \(7512 characters\)
sed "s/^X//" >'xrainbow/Wc1_05/Wc/WcCreate.h' <<'END_OF_FILE'
X/*
X** Copyright (c) 1990 David E. Smyth
X**
X** This file was derived from work performed by Martin Brunecky at
X** Auto-trol Technology Corporation, Denver, Colorado, under the
X** following copyright:
X**
X*******************************************************************************
X* Copyright 1990 by Auto-trol Technology Corporation, Denver, Colorado.
X*
X* All Rights Reserved
X*
X* Permission to use, copy, modify, and distribute this software and its
X* documentation for any purpose and without fee is hereby granted, provided
X* that the above copyright notice appears on all copies and that both the
X* copyright and this permission notice appear in supporting documentation
X* and that the name of Auto-trol not be used in advertising or publicity
X* pertaining to distribution of the software without specific, prior written
X* permission.
X*
X* Auto-trol disclaims all warranties with regard to this software, including
X* all implied warranties of merchantability and fitness, in no event shall
X* Auto-trol be liable for any special, indirect or consequential damages or
X* any damages whatsoever resulting from loss of use, data or profits, whether
X* in an action of contract, negligence or other tortious action, arising out
X* of or in connection with the use or performance of this software.
X*******************************************************************************
X**
X** Redistribution and use in source and binary forms are permitted
X** provided that the above copyright notice and this paragraph are
X** duplicated in all such forms and that any documentation, advertising
X** materials, and other materials related to such distribution and use
X** acknowledge that the software was developed by David E. Smyth. The
X** name of David E. Smyth may not be used to endorse or promote products
X** derived from this software without specific prior written permission.
X** THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
X** WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
X** MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
X**
X*/
X
X/*
X* SCCS_data: @(#)WcCreate.h 1.1 ( 19 Nov 90 )
X*
X* Include_name:
X*
X* WcCreate.h
X*
X* Subsystem_group:
X*
X* Widget Creation Library
X*
X* Include_description:
X*
X* Public defines for the Widget Creation Library supporting widget
X* tree creation from the Xrm database.
X*
X* Include_history:
X*
X* mm/dd/yy initials action
X* -------- -------- -------------------------------------------------------
X* 07/16/90 D.Smyth added WcAllowDuplicate*Reg... decls
X* 06/30/90 R.Whitby added WcRegisterWcActions declaration
X* 06/19/90 D.Smyth Widget Creation Library version 1.0 Release
X* 04/04/90 marbru updated, added new callbacks
X* 03/27/90 marbru updated for new names
X* 03/02/90 marbru created
X*
X*******************************************************************************
X*/
X#ifndef _WcCreate_h
X#define _WcCreate_h
X
X/*
X#include <X11/IntrinsicP.h>
X#include <X11/CoreP.h>
X#include <X11/ObjectP.h>
X*/
X
X#ifdef FUNCTION_PROTOTYPES
X/****************************** ANSI FUNC DECLS ******************************/
X
X#define APP XtAppContext
X#define EV extern void
X#define EW extern Widget
X#define EC extern char*
X
X/* -- Widget class, constructor, and callback proc registration routines */
X
XEV WcRegisterClassPtr (APP, char* name, WidgetClass class);
XEV WcRegisterClassName (APP, char* name, WidgetClass class);
XEV WcRegisterConstructor(APP, char* name, Widget(*constructor) () );
XEV WcRegisterCallback (APP, char* CBname, XtCallbackProc, caddr_t defCliData);
XEV WcRegisterAction (APP, char* name, XtActionProc proc );
XEV WcRegisterWcCallbacks(APP );
X
X/* -- Allow duplicate registration of classes, constructors, and callbacks */
X
XEV WcAllowDuplicateRegistration ( int allowed );
XEV WcAllowDuplicateClassPtrReg ( int allowed );
XEV WcAllowDuplicateClassNameReg ( int allowed );
XEV WcAllowDuplicateConstructorReg ( int allowed );
XEV WcAllowDuplicateCallbackReg ( int allowed );
X
X/* -- Widget action registration routine */
X
XEV WcRegisterWcActions ( APP );
X
X/* -- Widget creation routines */
X
XEV WcWidgetCreation ( Widget root );
XEV WcCreateNamedChildren ( Widget parent, char* names );
XEV WcCreateNamedPopups ( Widget parent, char* names );
XEW WcCreateDatabaseChild ( Widget parent, char* name, int* managed );
XEW WcCreateDatabasePopup ( Widget parent, char* name );
X
X/* -- Widget name routines
X** The character buffer returned by WcNamesToWidgetList contains the
X** names which could not be converted to widgets. This buffer is static,
X** so its contents are changed everytime WcNamesToWidgetList is called.
X** The character buffer returned by WcWidgetToFullName must be XtFree'd
X** by the caller.
X*/
X
XEW WcChildNameToWidget ( Widget w, char* childName );
XEW WcFullNameToWidget ( Widget w, char* name );
XEC WcNamesToWidgetList ( Widget, char* names, Widget widgetList[], int* count);
XEC WcWidgetToFullName ( Widget w );
X
X/* -- Useful for argument parsing */
X
XEC WcLowerCaseCopy ( char* in ); /* caller frees buf */
XEC WcSkipWhitespace ( char* cp );
XEC WcSkipWhitespace_Comma ( char* cp );
XEC WcCleanName ( char* in, char* out ); /* out[] must exist */
XEC WcStripWhitespaceFromBothEnds (char* name ); /* caller frees buf */
X
XEC WcGetResourceType ( Widget, char* rName ); /* caller frees buf */
XEV WcSetValueFromString ( Widget, char* rName, char* rVal );
XEV WcSetValueFromStringAndType( Widget, char* rName, char* rVal, char* rType );
X
XEC WcStrStr( char* searchThis, char* forThisPattern ); /* like ANSI strstr */
X
X#undef APP
X#undef EV
X#undef EW
X#undef EC
X
X#else
X/**************************** NON-ANSI FUNC DECLS ****************************/
X
X/* -- Widget constructor registration routine */
X
Xextern void WcRegisterClassPtr ();
Xextern void WcRegisterClassName ();
Xextern void WcRegisterConstructor ();
Xextern void WcRegisterCallback ();
Xextern void WcRegisterAction ();
Xextern void WcRegisterWcCallbacks ();
X
X/* -- Allow duplicate registration of classes, constructors, and callbacks */
X
Xextern void WcAllowDuplicateRegistration ();
Xextern void WcAllowDuplicateClassPtrReg ();
Xextern void WcAllowDuplicateClassNameReg ();
Xextern void WcAllowDuplicateConstructorReg ();
Xextern void WcAllowDuplicateCallbackReg ();
X
X/* -- Widget action registration routine */
X
Xextern void WcRegisterWcActions ();
X
X/* -- Widget creation routines */
X
Xextern void WcWidgetCreation ();
Xextern void WcCreateNamedChildren ();
Xextern void WcCreateNamedPopups ();
Xextern Widget WcCreateDatabaseChild ();
Xextern Widget WcCreateDatabasePopup ();
X
X/* -- Widget name routine */
X
Xextern Widget WcChildNameToWidget ();
Xextern Widget WcFullNameToWidget ();
Xextern char* WcNamesToWidgetList (); /* rets: names not converted */
Xextern char* WcWidgetToFullName (); /* ret'd buff must be free'd */
X
Xextern char* WcLowerCaseCopy (); /* ret'd buff must be free'd */
Xextern char* WcSkipWhitespace ();
Xextern char* WcSkipWhitespace_Comma ();
Xextern char* WcCleanName ();
Xextern char* WcStripWhitespaceFromBothEnds (); /* ret'd buff must be free'd */
X
Xextern char* WcGetResourceType (); /* ret'd buff must be free'd */
Xextern void WcSetValueFromString ();
Xextern void WcSetValueFromStringAndType ();
X
Xextern char* WcStrStr (); /* same as ANSI strstr() */
X
X#endif /* FUNCTION_PROTOTYPES */
X
X#endif /* _WcCreate_h */
END_OF_FILE
if test 7512 -ne `wc -c <'xrainbow/Wc1_05/Wc/WcCreate.h'`; then
echo shar: \"'xrainbow/Wc1_05/Wc/WcCreate.h'\" unpacked with wrong size!
fi
# end of 'xrainbow/Wc1_05/Wc/WcCreate.h'
fi
if test -f 'xrainbow/Wc1_05/Wc/WcCreateP.h' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'xrainbow/Wc1_05/Wc/WcCreateP.h'\"
else
echo shar: Extracting \"'xrainbow/Wc1_05/Wc/WcCreateP.h'\" \(15619 characters\)
sed "s/^X//" >'xrainbow/Wc1_05/Wc/WcCreateP.h' <<'END_OF_FILE'
X/*
X** Copyright (c) 1990 David E. Smyth
X**
X** This file was derived from work performed by Martin Brunecky at
X** Auto-trol Technology Corporation, Denver, Colorado, under the
X** following copyright:
X**
X*******************************************************************************
X* Copyright 1990 by Auto-trol Technology Corporation, Denver, Colorado.
X*
X* All Rights Reserved
X*
X* Permission to use, copy, modify, and distribute this software and its
X* documentation for any purpose and without fee is hereby granted, provided
X* that the above copyright notice appears on all copies and that both the
X* copyright and this permission notice appear in supporting documentation
X* and that the name of Auto-trol not be used in advertising or publicity
X* pertaining to distribution of the software without specific, prior written
X* permission.
X*
X* Auto-trol disclaims all warranties with regard to this software, including
X* all implied warranties of merchantability and fitness, in no event shall
X* Auto-trol be liable for any special, indirect or consequential damages or
X* any damages whatsoever resulting from loss of use, data or profits, whether
X* in an action of contract, negligence or other tortious action, arising out
X* of or in connection with the use or performance of this software.
X*******************************************************************************
X**
X** Redistribution and use in source and binary forms are permitted
X** provided that the above copyright notice and this paragraph are
X** duplicated in all such forms and that any documentation, advertising
X** materials, and other materials related to such distribution and use
X** acknowledge that the software was developed by David E. Smyth. The
X** name of David E. Smyth may not be used to endorse or promote products
X** derived from this software without specific prior written permission.
X** THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
X** WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
X** MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
X**
X*/
X
X/*
X* SCCS_data: @(#)WcCreateP.h 1.1 ( 19 Nov 90 )
X*
X* Include_name:
X*
X* WcCreateP.h
X*
X* Subsystem_group:
X*
X* Widget Creation Library
X*
X* Include_description:
X*
X* Private defines for the Widget Creation Library supporting widget
X* tree creation from the Xrm database.
X*
X* Include_history:
X*
X* mm/dd/yy initials action
X* -------- -------- -------------------------------------------------------
X* 11/14/90 D.Smyth Added popup resources
X* 06/30/90 R.Whitby added Action declarations
X* 05/24/90 D.Smyth created from provate section of WsCreate.h
X* 03/02/90 marbru created
X*
X*******************************************************************************
X*/
X#ifndef _WcCreateP_h
X#define _WcCreateP_h
X
X/*
X*******************************************************************************
X* Private_constant_declarations.
X*******************************************************************************
X*/
X#undef NUL
X#define NUL '\0'
X#define MAX_XRMSTRING 4096 /* max length of the Xrm DB string */
X#define MAX_ERRMSG 1024 /* max length of error message */
X#define MAX_CHILDREN 1024 /* max number of widget's children */
X#define MAX_PATHNAME 1024 /* max length of the pathname */
X#define INCR_REGISTRY 32 /* incr of cl, con, cb registries */
X#define MAX_CALLBACKS 64 /* max callbacks per Xrm resource */
X#define MAX_WIDGETS 512 /* max depth of a widget tree */
X#define MAX_ROOT_WIDGETS 32 /* max # separate widget trees */
X#define MAX_RES_FILES 512 /* max # res file names per interf */
X
X#define WcNwcResFile "wcResFile"
X#define WcNwcChildren "wcChildren"
X#define WcNwcPopups "wcPopups"
X#define WcNwcClass "wcClass"
X#define WcNwcClassName "wcClassName"
X#define WcNwcConstructor "wcConstructor"
X#define WcNwcManaged "wcManaged"
X#define WcNwcTrace "wcTrace"
X#define WcNwcCallback "wcCallback"
X
X#define WcCWcResFile "WcResFile"
X#define WcCWcChildren "WcChildren"
X#define WcCWcPopups "WcPopups"
X#define WcCWcClass "WcClass"
X#define WcCWcClassName "WcClassName"
X#define WcCWcConstructor "WcConstructor"
X#define WcCWcManaged "WcManaged"
X#define WcCWcTrace "WcTrace"
X#define WcCWcCallback "WcCallback"
X
X/* Motif 1.0 has a bug: widgets ask for Windows
X** instead of Widgets for their resources...
X*/
X#define WcRWidget "Window"
X#define WcRClassPtr "ClassPtr"
X#define WcRClassName "ClassName"
X#define WcRConstructor "Constructor"
X/*
X*******************************************************************************
X* Private_type_declarations.
X*******************************************************************************
X*/
X
Xtypedef void (*PtrFuncVoid)(); /* ptr to func returning void */
Xtypedef Widget (*PtrFuncWidget)(); /* ptr to func returning Widget */
X
X/* Registration structs: It is a good idea if the classes, class names,
X** constructors, and callbacks are registered with the same upper & lower
X** case names as the names in the ref manuals and source files, as this
X** makes the user error messages clearer.
X*/
X
Xtypedef struct /* Class cache record */
X{
X String name; /* class ptr name as registered */
X XrmQuark quark; /* quarkified class ptr name */
X WidgetClass class; /* widget class pointer */
X} ClCacheRec;
X
Xtypedef struct /* Class Name cache record */
X{
X String name; /* class name as registered */
X XrmQuark quark; /* quarkified class name */
X WidgetClass class; /* widget class pointer */
X} ClNameCacheRec;
X
Xtypedef struct /* Constructor cache record */
X{
X String name; /* constructor as registered */
X XrmQuark quark; /* quarkified constructor name */
X Widget (*constructor)(); /* constructor function ptr */
X} ConCacheRec;
X
Xtypedef struct /* Callback cache record */
X{
X String name; /* name as registered */
X XrmQuark quark; /* quarkified callback name */
X XtCallbackProc callback; /* callback procedure pointer */
X caddr_t closure; /* default client data */
X} CBCacheRec;
X
Xtypedef struct _ResourceRec
X{
X String resFile; /* additional resource file name */
X String children; /* list of children names to create */
X String popups; /* list of popup children to create */
X WidgetClass class; /* widget class pointer */
X WidgetClass classFromName; /* widget class pointer */
X ConCacheRec* constructor; /* ptr to Constructo cache record */
X Boolean managed; /* created managed (default TRUE) */
X Boolean deferred; /* deferred creation, (def FALSE) */
X Boolean trace; /* creation trace required */
X XtCallbackList callback; /* creation callback list */
X} ResourceRec, *ResourceRecPtr;
X
X/*
X*******************************************************************************
X* Private_macro_definitions.
X*******************************************************************************
X ONCE_PER_XtAppContext(app) should be invoked at the beginning of each
X function which performs registration, like MriRegisterMotif and
X AriRegisterAthena. Note that this IS a macro: therefore, the return
X statement actually causes the return from the registration function.
X*/
X
X#define ONCE_PER_XtAppContext( app ) \
X{ \
X static XtAppContext already[1024]; \
X static int numApps = 0; \
X int i; \
X \
X for (i = 0; i < numApps ; i++) \
X if (app == already[i]) \
X return; \
X \
X already[numApps++] = app; \
X}
X
X/*
X*******************************************************************************
X* Private_data_definitions.
X*******************************************************************************
X The following cache/registry of known widget classes and contructors,
X initially empty, are loaded by the application using "registration"
X routines.
X Assuming small numbers of constructors, the sequential search
X of such cache is (initially) considered acceptable.
X*/
X
X/* -- Named class pointer cache, intially empty */
X
Xextern int classes_num;
Xextern int classes_max;
Xextern ClCacheRec* classes_ptr;
X
X/* -- Class name cache, intially empty */
X
Xextern int cl_nm_num;
Xextern int cl_nm_max;
Xextern ClNameCacheRec* cl_nm_ptr;
X
X/* -- Named object constructor cache, intially empty */
X
Xextern int constrs_num;
Xextern int constrs_max;
Xextern ConCacheRec* constrs_ptr;
X
X/* -- Callback function cache, initially empty */
X
Xextern int callbacks_num;
Xextern int callbacks_max;
Xextern CBCacheRec* callbacks_ptr;
X/* -- Widget Creation resources */
X
Xextern XtResource wc_resources[];
X
X/*
X*******************************************************************************
X* Private_function_declarations.
X*******************************************************************************
X The following functions are generally private functions to the
X WcCreate routines, but they may be defined in different files from
X where they are used. Client programs probably should not invoke
X these functions directly.
X*/
X
X#ifdef FUNCTION_PROTOTYPES
X/****************************** ANSI FUNC DECLS ******************************/
X
X#define EV extern void
X
X/* -- Resource converters */
X
XEV WcAddConverters ( XtAppContext );
XEV CvtStringToClassPtr ( XrmValue*, Cardinal*, XrmValue*, XrmValue* );
XEV CvtStringToClassName ( XrmValue*, Cardinal*, XrmValue*, XrmValue* );
XEV CvtStringToConstructor ( XrmValue*, Cardinal*, XrmValue*, XrmValue* );
XEV CvtStringToCallback ( XrmValue*, Cardinal*, XrmValue*, XrmValue* );
XEV XmuCvtStringToWidget ( XrmValue*, Cardinal*, XrmValue*, XrmValue* );
X
X/* -- Find root widget of argument, remember if never seen before */
X
Xextern Widget WcRootWidget ( Widget );
X
X/* -- Convenience Callbacks - Clients generally invoke these only
X by binding them to widgets via the resource file. They can
X be programmatically bound, but generally should not be.
X*/
X
XEV WcCreateChildrenCB (Widget w, char* parent_children, caddr_t unused );
XEV WcCreatePopupsCB (Widget w, char* parent_children, caddr_t unused );
XEV WcManageCB (Widget w, char* widgetNames, caddr_t unused );
XEV WcUnmanageCB (Widget w, char* widgetNames, caddr_t unused );
XEV WcManageChildrenCB (Widget w, char* parent_children, caddr_t unused );
XEV WcUnmanageChildrenCB (Widget w, char* parent_children, caddr_t unused );
XEV WcDestroyCB (Widget w, char* widgetNames, caddr_t unused );
XEV WcSetValueCB (Widget w, char* name_res_resVal, caddr_t unused );
XEV WcSetTypeValueCB (Widget w, char* nm_res_type_val, caddr_t unused );
XEV WcSetSensitiveCB (Widget w, char* widgetNames, caddr_t unused );
XEV WcSetInsensitiveCB (Widget w, char* widgetNames, caddr_t unused );
XEV WcLoadResourceFileCB (Widget w, char* resFileName, caddr_t unused );
XEV WcTraceCB (Widget w, char* annotation, caddr_t unused );
XEV WcPopupCB (Widget w, char* widgetName, caddr_t unused );
XEV WcPopupGrabCB (Widget w, char* widgetName, caddr_t unused );
XEV WcPopdownCB (Widget w, char* widgetName, caddr_t unused );
XEV WcMapCB (Widget w, char* widgetName, caddr_t unused );
XEV WcUnmapCB (Widget w, char* widgetName, caddr_t unused );
XEV WcSystemCB (Widget w, char* shellCmdString, caddr_t unused );
XEV WcExitCB (Widget w, char* exitValue, caddr_t unused );
X
X/* -- Convenience Actions - Clients generally invoke these only
X by binding them to widgets via the resource file. They can
X be programmatically bound, but generally should not be.
X*/
X
X#define ACT_ARGS Widget w, XEvent *event, String *params, Cardinal *num_params
X
XEV WcCreateChildrenACT ( ACT_ARGS );
XEV WcCreatePopupsACT ( ACT_ARGS );
XEV WcManageACT ( ACT_ARGS );
XEV WcUnmanageACT ( ACT_ARGS );
XEV WcManageChildrenACT ( ACT_ARGS );
XEV WcUnmanageChildrenACT ( ACT_ARGS );
XEV WcDestroyACT ( ACT_ARGS );
XEV WcSetValueACT ( ACT_ARGS );
XEV WcSetTypeValueACT ( ACT_ARGS );
XEV WcSetSensitiveACT ( ACT_ARGS );
XEV WcSetInsensitiveACT ( ACT_ARGS );
XEV WcLoadResourceFileACT ( ACT_ARGS );
XEV WcTraceACT ( ACT_ARGS );
XEV WcPopupACT ( ACT_ARGS );
XEV WcPopupGrabACT ( ACT_ARGS );
XEV WcPopdownACT ( ACT_ARGS );
XEV WcMapACT ( ACT_ARGS );
XEV WcUnmapACT ( ACT_ARGS );
XEV WcSystemACT ( ACT_ARGS );
XEV WcExitACT ( ACT_ARGS );
X
X#undef ACT_ARGS
X#undef EV
X
X#else
X/**************************** NON-ANSI FUNC DECLS ****************************/
X
X/* -- Resource converters */
X
Xextern void WcAddConverters ();
Xextern void CvtStringToClassPtr ();
Xextern void CvtStringToClassName ();
Xextern void CvtStringToConstructor ();
Xextern void CvtStringToCallback ();
Xextern void XmuCvtStringToWidget (); /* note naming! replace Xmu... */
X
X/* -- Find root widget of argument, remember if never seen before */
X
Xextern Widget WcRootWidget ();
X
X/* -- Convenience Callbacks - Clients generally invoke these only
X by binding them to widgets via the resource file. They can
X be programmatically bound, but generally should not be.
X*/
X
Xextern void WcCreateChildrenCB ();
Xextern void WcCreatePopupsCB ();
Xextern void WcManageCB ();
Xextern void WcUnmanageCB ();
Xextern void WcManageChildrenCB ();
Xextern void WcUnmanageChildrenCB ();
Xextern void WcDestroyCB ();
Xextern void WcSetValueCB ();
Xextern void WcSetTypeValueCB ();
Xextern void WcSetSensitiveCB ();
Xextern void WcSetInsensitiveCB ();
Xextern void WcLoadResourceFileCB ();
Xextern void WcTraceCB ();
Xextern void WcPopupCB ();
Xextern void WcPopupGrabCB ();
Xextern void WcPopdownCB ();
Xextern void WcMapCB ();
Xextern void WcUnmapCB ();
Xextern void WcSystemCB ();
Xextern void WcExitCB ();
X
X/* -- Convenience Actions - Clients generally invoke these only
X by binding them to widgets via the resource file. They can
X be programmatically bound, but generally should not be.
X*/
X
Xextern void WcCreateChildrenACT ();
Xextern void WcCreatePopupsACT ();
Xextern void WcManageACT ();
Xextern void WcUnmanageACT ();
Xextern void WcManageChildrenACT ();
Xextern void WcUnmanageChildrenACT ();
Xextern void WcDestroyACT ();
Xextern void WcSetValueACT ();
Xextern void WcSetTypeValueACT ();
Xextern void WcSetSensitiveACT ();
Xextern void WcSetInsensitiveACT ();
Xextern void WcLoadResourceFileACT ();
Xextern void WcTraceACT ();
Xextern void WcPopupACT ();
Xextern void WcPopupGrabACT ();
Xextern void WcPopdownACT ();
Xextern void WcMapACT ();
Xextern void WcUnmapACT ();
Xextern void WcSystemACT ();
Xextern void WcExitACT ();
X
X#endif /* FUNCTION_PROTOTYPES */
X
X#endif /* _WcCreateP_h */
END_OF_FILE
if test 15619 -ne `wc -c <'xrainbow/Wc1_05/Wc/WcCreateP.h'`; then
echo shar: \"'xrainbow/Wc1_05/Wc/WcCreateP.h'\" unpacked with wrong size!
fi
# end of 'xrainbow/Wc1_05/Wc/WcCreateP.h'
fi
if test -f 'xrainbow/include/X11/Xaw_d/DrawingA.h' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'xrainbow/include/X11/Xaw_d/DrawingA.h'\"
else
echo shar: Extracting \"'xrainbow/include/X11/Xaw_d/DrawingA.h'\" \(1399 characters\)
sed "s/^X//" >'xrainbow/include/X11/Xaw_d/DrawingA.h' <<'END_OF_FILE'
X/* DrawingA.h - Public Header file */
X
X/* Copyright 1990, David Nedde
X/*
X/* Permission to use, copy, modify, and distribute this
X/* software and its documentation for any purpose and without fee
X/* is granted provided that the above copyright notice appears in all copies.
X/* It is provided "as is" without express or implied warranty.
X*/
X
X/* Define widget's class pointer and strings used to specify resources */
X
X#ifndef _XawDrawingArea_h
X#define _XawDrawingArea_h
X
X/* Resources ADDED to label widget:
X
X Name Class RepType Default Value
X ---- ----- ------- -------------
X exposeCallback Callback Pointer NULL
X inputCallback Callback Pointer NULL
X motionCallback Callback Pointer NULL
X resizeCallback Callback Pointer NULL
X*/
X
X
Xextern WidgetClass drawingAreaWidgetClass;
X
Xtypedef struct _DrawingAreaClassRec *DrawingAreaWidgetClass;
Xtypedef struct _DrawingAreaRec *DrawingAreaWidget;
X
X
X/* Resource strings */
X#define XtNexposeCallback "exposeCallback"
X#define XtNinputCallback "inputCallback"
X#define XtNmotionCallback "motionCallback"
X#define XtNresizeCallback "resizeCallback"
X
X
Xtypedef struct _XawDrawingAreaCallbackStruct {
X int reason;
X XEvent *event;
X Window window;
X} XawDrawingAreaCallbackStruct;
X
X/* Reasons */
X#define XawCR_EXPOSE 1
X#define XawCR_INPUT 2
X#define XawCR_MOTION 3
X#define XawCR_RESIZE 4
X
X#endif /* _XawDrawingArea_h */
END_OF_FILE
if test 1399 -ne `wc -c <'xrainbow/include/X11/Xaw_d/DrawingA.h'`; then
echo shar: \"'xrainbow/include/X11/Xaw_d/DrawingA.h'\" unpacked with wrong size!
fi
# end of 'xrainbow/include/X11/Xaw_d/DrawingA.h'
fi
echo shar: End of archive 3 \(of 5\).
cp /dev/null ark3isdone
MISSING=""
for I in 1 2 3 4 5 ; do
if test ! -f ark${I}isdone ; then
MISSING="${MISSING} ${I}"
fi
done
if test "${MISSING}" = "" ; then
echo You have unpacked all 5 archives.
echo "Please Read README"
rm -f ark[1-9]isdone
else
echo You still need to unpack the following archives:
echo " " ${MISSING}
fi
## End of shell archive.
exit 0
--
Dan Heller
O'Reilly && Associates Z-Code Software Comp-sources-x:
Senior Writer President comp-sources-x@uunet.uu.net
argv@ora.com argv@zipcode.com