/**
*
* $Header: /cvsroot/lesstif/lesstif/lib/Mrm-2.1/Mrm.c,v 1.2 2004/11/30 17:37:16 dannybackx Exp $
*
* Copyright (C) 1995 Free Software Foundation, Inc.
* Copyright Š 1995-2002, 2004 LessTif Development Team
*
* This file is part of the GNU LessTif Library.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the Free
* Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*
*
* Original author: Geoffrey W. Ritchey
* codesmit@southwind.net
*
*/
#include <LTconfig.h>
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <X11/Xlib.h>
#include <Xm/XmP.h>
#include <XmI/XpmI.h>
#include <Mrm/MrmPublic.h>
#include "Mrm.h"
#include "uil.h"
#include "lookup.h"
#include "misc.h"
#include <XmI/DebugUtil.h>
#ifndef X_LIB_PATH
#define X_LIB_PATH "/usr/X11/lib"
#endif
#ifndef LESSTIFHOME
#define LESSTIFHOME "/usr/local"
#endif
/*
* Macros and types
*/
#define MAX_ARGS 40
#define MAX_BUFFER 2048
#define MAX_HIER 20
#define MAX_DEF 2048
#define MAX_STR 256
enum
{
GEO, LATE, ON_CREATE
};
#define ANOTHER_WIDGET -1
typedef struct _MyHierStruct
{
char *CreateName;
int CreateClass;
Arg *args;
int argCount;
int SizeArgs;
} MyHierStruct;
typedef struct _SymbolTable
{
struct _SymbolTable *Next;
int type;
int Index;
char *Name;
char *value;
char Access;
} SymbolTableType;
typedef struct _callbackType
{
struct _callbackType *next;
int id;
int index;
char *argName;
char *functionName;
SymbolTableType *Parameters;
}
callbackType;
typedef struct _DummyWidget
{
char *Name;
int wclass;
char managed;
int parent;
int NumberOfInherit;
int *inherit;
int NumberOfChildren;
int *children;
callbackType *callbacks;
SymbolTableType *attributes;
}
DummyWidget;
typedef struct _UilModuleType
{
char **Definitions;
char **Names;
int NumberOfWidgets;
Widget *WidgetArray;
DummyWidget *DummyWidgetArray;
SymbolTableType *SymbolTable;
}
UilModuleType;
typedef struct _GeoType
{
int module_id;
int this_id;
struct _GeoType *next;
DummyWidget *DW;
}
GeoType;
typedef struct _ColorTableType
{
char *Reference;
int IsAddress;
char *Color;
char *StringXPM;
}
ColorTableType;
typedef struct _ColorTableHeaderType
{
int NumColors;
ColorTableType *ColorTable;
}
ColorTableHeaderType;
typedef struct _FontTableType
{
FontSetType Tag;
char *FontName;
}
FontTableType;
typedef struct _FontTableHeaderType
{
int NumFonts;
FontTableType *FontTable;
}
FontTableHeaderType;
/*
* Variables
*/
static Boolean init = False;
static Display *display = NULL;
static Colormap colormap;
static Screen *theScreen;
static Window window;
static Widget parent;
static char *theName;
static char *theClass;
static GeoType *GeometryList = NULL;
static SymbolTableType *GlobalSymbolTable = NULL;
static int NumberFiles;
static String *FileList;
static int MaxAttributes;
static int MaxHier;
static UilModuleType UilModule[MAX_HIER];
static int FetchCount = 0;
static SymbolTableType *InstantationSymbolTable = NULL;
static char *uidpath;
/* exported stuff */
int NumberRegisteredFunctions = 0;
MrmRegisterArg *RegisteredFunctions = NULL;
/*
* Forward declarations of functions
*/
static int GetSymbolTableValue(XtArgVal *, SymbolTableType *, int, SymbolTableType *);
static SymbolTableType *GetSymbolTable(SymbolTableType *);
static SymbolTableType *LookupValue(SymbolTableType *SymbolTable, char *name);
static FILE *UILOpen(char *FileName, char *mode, FILE * old);
static char *Substitute(char *buffer);
static void ReadWidgetTree(UilModuleType *Module);
static void PrintWidgetTree(UilModuleType *Module);
static void PrintWidgets(UilModuleType *Module);
static void MakePixmap(Display *d, Pixmap *pixmap, PixmapType * data, Pixel fg, Pixel bg);
static void FreeSymbolTable(SymbolTableType *t);
static void GetCallbacks(int filenr, int wid_id, DummyWidget *DW);
static void AddGeometryAttributes(GeoType **GeometryList, int module_id, int this_id,
DummyWidget *DW);
static void SetGeometryAttributes(GeoType **GeometryList);
static void ReadList(UilModuleType *Module);
static void ReadWidgets(UilModuleType *Module);
static void PrintArgs(SymbolTableType *Next);
static void PrintControls(int count, int *ids, DummyWidget *Array);
static void PrintCallbacks(callbackType *Next);
static void PrintSymbolTable(SymbolTableType *SymbolTable);
static SymbolTableType *LookUpAddr(char *temp, int module_id);
/* static char *CreateFontListFromFontName(char *FontName); */
static SymbolTableType *ReadAttributes(void);
static void ReadCallbacks(callbackType **last);
static char *ReadType(int type);
static XmString DecodeComplexString(StringType * value, int module_id, char *ascii);
static void Xm_List(Widget parent_widget, DummyWidget *DW, int module_id);
static void GetAttributes(Display *d, Window w, int module_id,
int *n, Arg *args,
DummyWidget *DW, SymbolTableType
*FormSymbolTable, int OnGeometry);
extern void
MrmInitialize(void)
{
if (!init) {
uidpath = getenv("UIDPATH");
init = True;
}
}
extern Cardinal
MrmCloseHierarchy(MrmHierarchy hierarchy_id)
{
return MrmSUCCESS;
}
extern Cardinal
MrmOpenHierarchy(MrmCount num_files, String *name_list, MrmOsOpenParamPtr *os_ext_list, MrmHierarchy *hierarchy_id_return)
{
if (display)
return MrmOpenHierarchyPerDisplay(display, num_files, name_list, os_ext_list, hierarchy_id_return);
else {
__MrmExit(LOC, "MrmOpenHierarchy(): no display set yet!\n");
return MrmFAILURE;
}
}
extern Cardinal
MrmOpenHierarchyFromBuffer(unsigned char uid_buffer,
MrmHierarchy *hierarchy_id)
{
_XmWarning(NULL, "MrmOpenHierarchyFromBuffer() is not yet implemented!");
return MrmFAILURE;
}
extern Cardinal
MrmOpenHierarchyPerDisplay(Display *theDisplay, MrmCount num_files, String *name_list, MrmOsOpenParamPtr *os_ext_list, MrmHierarchy *hierarchy_id_return)
{
int fileIndex;
/*
MrmSUCCESS The function executed successfully.
MrmFAILURE The function failed.
*/
display = theDisplay;
window = DefaultRootWindow(theDisplay);
theScreen = XDefaultScreenOfDisplay(theDisplay);
colormap = DefaultColormapOfScreen(theScreen);
XtGetApplicationNameAndClass(display, &theName, &theClass);
NumberFiles = num_files;
FileList = name_list;
hierarchy_id_return = NULL;
for (fileIndex = 0; fileIndex < num_files; fileIndex++)
{
if (NULL == UILOpen(FileList[fileIndex], "r", stdin))
{
__MrmExit(LOC, "Can't open %s\n", FileList[fileIndex]);
}
ReadWidgetTree(&UilModule[fileIndex]);
if (1)
{
fprintf(stderr, "GLOBAL *******\n");
PrintSymbolTable(GlobalSymbolTable);
fprintf(stderr, "LOCAL %d\n", fileIndex);
PrintSymbolTable(UilModule[fileIndex].SymbolTable);
PrintWidgetTree(&UilModule[fileIndex]);
}
}
MaxHier = fileIndex;
return MrmSUCCESS;
}
extern Cardinal
MrmRegisterNames(MrmRegisterArglist reglist, MrmCount num_reg)
{
/*
MrmSUCCESS The function executed successfully.
MrmFAILURE The function failed.
*/
NumberRegisteredFunctions = num_reg;
RegisteredFunctions = reglist;
return MrmSUCCESS;
}
extern Cardinal
MrmRegisterClass(MrmType class_code, String class_name, String create_name,
Widget (*creator) (void), WidgetClass class_record)
{
return MrmFAILURE;
}
extern Cardinal
MrmFetchIconLiteral(MrmHierarchy hierarchy_id, String index,
Screen *scrn, Display *d, Pixel fg, Pixel bg,
Pixmap *pixmap)
{
SymbolTableType *symbol;
for (symbol = GlobalSymbolTable; symbol; symbol = symbol->Next)
if (strcmp(index, symbol->Name) == 0)
{
if (MrmRtypeXBitmapFile == symbol->type)
{
BitMapType *bm = (BitMapType *) symbol->value;
*pixmap = XCreatePixmapFromBitmapData(d, window, bm->data,
bm->width, bm->height,
fg, bg,
DefaultDepth(display, 0));
}
else
MakePixmap(d, pixmap, (PixmapType *) symbol->value, fg, bg);
return MrmSUCCESS;
}
return MrmNOT_FOUND;
}
extern Cardinal
MrmFetchColorLiteral(MrmHierarchy hierarchy_id, String index,
Display *display, Colormap cmap,
Pixel *pixel_return)
{
/*
XColor exact, def;
SymbolTableType *value;
MrmCode type = 3;
if (MrmSUCCESS == MrmMrmFetchLiteral(hierarchy_id, index, *display, (XtPointer *) value, &type)) {
XAllocNamedColor(display, cmap, value->value, &def, &exact);
*pixel_return = (XtArgVal)def.pixel;
return MrmSUCCESS;
}
*/
return MrmFAILURE;
}
extern Cardinal
MrmFetchLiteral(MrmHierarchy hierarchy_id, String index, Display *d, XtPointer *value, MrmCode *type)
{
SymbolTableType *symbol;
/*
MrmBAD_HIERARCHY
MrmNOT_FOUND
MrmWRONG_TYPE
MrmFAILURE
*/
fprintf(stderr, "HEHE\n");
for (symbol = GlobalSymbolTable; symbol; symbol = symbol->Next)
{
if (strcmp(index, symbol->Name) == 0)
{
*value = (XtPointer)&symbol->value;
#if 0
if (*type != symbol->type)
return MrmWRONG_TYPE;
#endif
return MrmSUCCESS;
}
}
return MrmNOT_FOUND;
}
extern Cardinal
MrmFetchWidgetOverride(MrmHierarchy hierarchy_id, String index, Widget parent_widget, String override_name, ArgList override_args, Cardinal override_num_args, Widget *widget, MrmType *wclass)
{
Cardinal returnValue =
MrmFetchWidget(hierarchy_id, index, parent_widget, widget, wclass);
XtSetValues(*widget, override_args, override_num_args);
return returnValue;
}
extern Cardinal
MrmFetchSetValues(MrmHierarchy hierarchy_id,
Widget w,
ArgList args,
Cardinal num_args)
{
/* Fix Me ! */
_XmWarning(NULL, "MrmFetchSetValues() is not yet implemented!");
return MrmFAILURE;
}
extern Cardinal
MrmFetchBitmapLiteral(MrmHierarchy hierarchy_id,
String index,
Screen *screen,
Display *display,
Pixmap *pixmap_return,
Dimension *width,
Dimension *height)
{
/* Fix Me ! */
_XmWarning(NULL, "MrmFetchBitmapLiteral() is not yet implemented!");
return MrmFAILURE;
}
extern Cardinal
MrmFetchWidget(MrmHierarchy hierarchy_id, String index, Widget parent_widget, Widget *widget, MrmType *wclass)
{
DummyWidget *DW = NULL;
int this_id = -1, child_id = -1;
int i = 0;
int k, n;
int module_id = 0;
Widget child;
MrmType type;
Bool Found = False;
int file;
Arg *args, ARGS[MAX_ARGS];
int SizeArgs = 0;
MyHierStruct *MyHier = (MyHierStruct *)hierarchy_id;
char *CreateName;
int CreateClass;
FetchCount++;
if (1 == FetchCount)
{
FreeSymbolTable(InstantationSymbolTable);
InstantationSymbolTable = NULL;
}
parent = parent_widget;
for (file = 0; !Found && (file < NumberFiles); file++)
{
for (k = 0; k < UilModule[file].NumberOfWidgets; k++)
{
if (strcmp(index, UilModule[file].DummyWidgetArray[k].Name) == 0)
{
module_id = file;
Found = True;
DW = &UilModule[file].DummyWidgetArray[k];
this_id = k;
break;
}
}
}
if (NULL == DW)
__MrmExit(LOC, "Looks like a corrupt uid file\n");
if ((FetchCount != 1) && (NULL != hierarchy_id))
{
args = MyHier->args;
n = MyHier->argCount;
SizeArgs = MyHier->SizeArgs;
CreateName = MyHier->CreateName;
CreateClass = MyHier->CreateClass;
}
else
{
CreateName = DW->Name;
CreateClass = DW->wclass;
n = 0;
args = ARGS;
SizeArgs = 0;
}
if (!Found)
{
fprintf(stderr, "Fetch return Not FOUND\n");
FetchCount--;
return (MrmNOT_FOUND);
}
GetAttributes( /*display */ NULL, /*window */ 0,
module_id, &n, args,
DW, InstantationSymbolTable, ON_CREATE);
if (DW->NumberOfInherit)
{
for (i = 0; i < DW->NumberOfInherit; i++)
{
char *index;
int inherit_id;
MyHierStruct *Hier;
if (NULL == MyHier)
{
Hier = (MyHierStruct *)malloc(sizeof(MyHierStruct));
Hier->CreateName = DW->Name;
Hier->CreateClass = DW->wclass;
Hier->args = args;
Hier->argCount = n;
Hier->SizeArgs = SizeArgs;
}
else
Hier = MyHier;
inherit_id = DW->inherit[i];
index = UilModule[module_id].DummyWidgetArray[inherit_id - 1].Name;
MrmFetchWidget((MrmHierarchy)Hier, index, parent_widget, widget, wclass);
}
}
else
{
if (XM_LIST_INDEX == CreateClass)
{
Xm_List(parent_widget, DW, module_id);
*widget = NULL;
FetchCount--;
return MrmSUCCESS;
}
if (NULL == CreateFunctions[CreateClass].function)
{
char Name[20];
strcpy(Name, &CreateFunctions[CreateClass].Name[2]);
Name[0] = '*';
*widget = XtNameToWidget(parent_widget, Name);
}
else
{
SymbolTableType *newent = (SymbolTableType *)malloc(sizeof(SymbolTableType));
*widget = CreateFunctions[CreateClass].function(parent_widget,
CreateName, args, n);
newent->value = (char *)*widget;
newent->Name = __MrmStore(CreateName);
newent->Next = InstantationSymbolTable;
InstantationSymbolTable = newent;
newent->type = ANOTHER_WIDGET;
}
}
if (NULL == *widget)
{
__MrmExit(LOC, "Couldn't create widget %s", DW->Name);
}
UilModule[module_id].WidgetArray[this_id] = *widget;
for (i = 0; i < DW->NumberOfChildren; i++)
{
Cardinal returnCode;
DummyWidget *ChildDummy;
child_id = DW->children[i];
ChildDummy = &UilModule[module_id].DummyWidgetArray[child_id - 1];
if (MrmSUCCESS !=
(returnCode =
MrmFetchWidget(NULL, ChildDummy->Name,
UilModule[module_id].WidgetArray[this_id],
&child, &type)))
{
FetchCount--;
return (returnCode);
}
if ((0 == strcmp(CreateFunctions[DW->wclass].Name, "XmCascadeButton")) ||
(0 == strcmp(CreateFunctions[DW->wclass].Name, "XmOptionMenu")))
{
Arg args[1];
XtSetArg(args[0], XmNsubMenuId, child);
XtSetValues(UilModule[module_id].WidgetArray[this_id], args, 1);
}
if (child && UilModule[module_id].DummyWidgetArray[child_id - 1].managed)
{
XtManageChild(child);
}
}
n = 0;
GetAttributes( /*display */ NULL, /*window */ 0,
module_id, &n, args,
DW, InstantationSymbolTable, LATE);
XtSetValues(*widget, args, n);
GetCallbacks(module_id, this_id, DW);
UilModule[module_id].WidgetArray[this_id] = *widget;
AddGeometryAttributes(&GeometryList, module_id, this_id, DW);
if (1 == FetchCount)
{ /* Just before we return to initial caller do GEOM */
SetGeometryAttributes(&GeometryList);
}
FetchCount--;
return MrmSUCCESS;
}
extern Cardinal
MrmFetchInterfaceModule(MrmHierarchy hierarchy_id ,
char *module_name,
Widget parent,
Widget *w_return)
{
/* This is a legacy call, which is no longer documented in
2.1 docs, but seems to be present at least in 2.0 still */
_XmWarning(NULL, "MrmFetchInterfaceModule() is not implemented!");
return MrmFAILURE;
}
static void
MakePixmap(Display *d, Pixmap *pixmap, PixmapType * data, Pixel fg,
Pixel bg)
{
char *temp, *value;
char buffer[256];
int filenr;
ColorTableHeaderType *ColorTableHeader;
ColorTableType *ColorTable;
XpmAttributes attributes;
char Header[256];
char **andrew = NULL;
int NumColors;
int i, j, k, Index;
SymbolTableType *symbol;
GC *GCTable;
XColor exact, def;
char *Image;
ColorDefType *Color;
attributes.valuemask = 0;
temp = data->ColorTable;
if (NULL == (symbol = LookupValue(GlobalSymbolTable, temp)))
{
for (filenr = 0; filenr < NumberFiles; filenr++)
{
if (NULL !=
(symbol = LookupValue(UilModule[filenr].SymbolTable, temp)))
break;
}
if (NULL == symbol)
__MrmExit(LOC, "Couldn't find %s in symbol tables\n", temp);
}
ColorTableHeader = (ColorTableHeaderType *)symbol->value;
ColorTable = ColorTableHeader->ColorTable;
NumColors = ColorTableHeader->NumColors;
GCTable = (GC *)malloc(sizeof(GC) * NumColors);
if (NULL == ColorTable[0].StringXPM)
{
for (i = 0; i < NumColors; i++)
{
long theColor = 0;
value = ColorTable[i].Color;
if (ColorTable[i].IsAddress)
{
if (NULL == (symbol = LookupValue(GlobalSymbolTable, value)))
{
for (filenr = 0; filenr < MaxHier; filenr++)
{
if (NULL !=
(symbol = LookupValue(UilModule[filenr].SymbolTable, value)))
break;
}
if (NULL == symbol)
__MrmExit(LOC, "Couldn't find %s in symbol tables\n", value);
}
value = symbol->value;
}
Color = (ColorDefType *) value;
sprintf(buffer, "%s c %s", ColorTable[i].Reference, Color->name);
GCTable[i] = XCreateGC(d, window, 0, NULL);
if (Color->name)
{
if (strcmp(Color->name, "_fg") == 0)
theColor = fg;
else if (strcmp(Color->name, "_bg") == 0)
theColor = bg;
else
{
XAllocNamedColor(d, colormap, Color->name, &def, &exact);
theColor = def.pixel;
}
}
else
{
def.red = Color->r;
def.green = Color->g;
def.blue = Color->b;
if (XAllocColor(display, colormap, &def))
theColor = def.pixel;
else
__MrmExit(LOC, "Couldn't resolve color: %s\n",
Color->r, Color->g, Color->b);
}
XSetForeground(d, GCTable[i], theColor);
/* ColorTable[i].StringXPM = __MrmStore(buffer); */
}
}
andrew = (char **)malloc(sizeof(char *) * (1 + NumColors + data->width));
sprintf(Header, "%d %d %d 1 -1 -1", data->width, data->height, NumColors);
andrew[0] = Header;
for (i = 0; i < NumColors; i++)
andrew[i + 1] = ColorTable[i].StringXPM;
for (i = 0; i < (int)data->width; i++)
andrew[i + NumColors + 1] = &data->data[i * data->width];
Image = data->data;
/* the following is a total hack because I want to go to bed. The Pixel
* value in XmGetPixmapByDepth are totally made up. */
*pixmap = XCreatePixmap(display, window, data->width, data->height,
DefaultDepth(display, 0));
for (i = 0; i < (int)data->height; i++)
{
for (j = 0; j < (int)data->width; j++)
{
Index = -1;
for (k = 0; k < NumColors; k++)
{
/* FIX ME -- the following may need to compare more than one
byte in case each pixel of the image is wider
*/
if (strncmp(ColorTable[k].Reference, Image, 1) == 0)
{
Index = k;
break;
}
}
if (Index == -1)
__MrmExit(LOC, "Color Error\n");
XDrawPoint(display, *pixmap, GCTable[Index], j, i);
Image += 1;
}
}
#if 0
if (_LtXmXpmCreateImageFromData(d, andrew, &im, &imshape, &attributes) ==
_LtXpmSuccess)
{
GC gc;
*pixmap = XCreatePixmap(d, window, im->width, im->height, im->depth);
gc = XCreateGC(d, window, 0, NULL);
XPutImage(d, *pixmap, gc, im, 0, 0, 0, 0, im->width, im->height);
XFreeGC(d, gc);
/* this should probably be enabled */
#if 0
XDestroyImage(im);
if (imshape)
XDestroyImage(imshape);
#endif
_LtXmXpmFreeAttributes(&attributes);
}
#endif
free(andrew);
free(GCTable);
}
static void
AddGeometryAttributes(GeoType **GeometryList, int module_id, int this_id,
DummyWidget *DW)
{
GeoType *node = (GeoType *)malloc(sizeof(GeoType));
node->module_id = module_id;
node->this_id = this_id;
node->next = *GeometryList;
*GeometryList = node;
node->DW = DW;
}
static void
SetGeometryAttributes(GeoType **GeometryList)
{
GeoType *node = *GeometryList;
GeoType *next;
Arg args[MAX_ARGS];
int n;
Widget widget;
while (node)
{
next = node->next;
widget = UilModule[node->module_id].WidgetArray[node->this_id];
n = 0;
GetAttributes( /*display */ NULL, /*window */ 0,
node->module_id, &n, args,
node->DW, InstantationSymbolTable, GEO);
XtSetValues(widget, args, n);
free(node);
node = next;
}
*GeometryList = NULL;
}
static void
GetCallbacks(int filenr, int wid_id, DummyWidget *DW)
{
callbackType *Next = DW->callbacks;
XtPointer ParameterValue;
SymbolTableType *SymbolTable = NULL;
Widget w = UilModule[filenr].WidgetArray[wid_id];
while (Next)
{
if (Next->Parameters)
{
if (MrmRtypeAddrName == Next->Parameters->type)
{
char *temp;
temp = Next->Parameters->value;
if (1 != __MrmLookUpPredefines(temp, (long *)&ParameterValue))
if (NULL ==
(SymbolTable = LookupValue(UilModule[filenr].SymbolTable, temp)))
{
if (NULL == (SymbolTable = LookupValue(GlobalSymbolTable, temp)))
{
__MrmExit(LOC, "Couldn't find %s in symbol tables\n", temp);
}
}
}
else
SymbolTable = (SymbolTableType *)(Next->Parameters);
}
else
ParameterValue = NULL;
if (SymbolTable)
{
if (MrmRtypeInteger != SymbolTable->type)
ParameterValue = (XtPointer)SymbolTable->value;
else
ParameterValue = (XtPointer)&(SymbolTable->value);
}
if (strcmp("createCallback", Next->argName) != 0)
XtAddCallback(w, Next->argName,
(XtCallbackProc)__MrmLookUpFunction(Next->functionName),
ParameterValue);
else
((XtCallbackProc)
__MrmLookUpFunction(Next->functionName)) (w, ParameterValue, NULL);
Next = Next->next;
}
return;
}
static void
GetAttributes(Display *d, Window w, int module_id,
int *n, Arg *args,
DummyWidget *DW, SymbolTableType
*FormSymbolTable, int State)
{
int count = 0;
XtArgVal value;
SymbolTableType *Next = DW->attributes;
int Do;
/* *n = 0; We will append to existing attributes - make sure n is 0
before calling this routine if that is intended
*/
while (Next)
{
if (Next->Access & S)
{ /* Attribute can be set after widget creation */
Do = (LATE == State);
}
else if (Next->Access & C)
{ /* Attribute must be set at creation time */
Do = (ON_CREATE == State);
}
else
{ /* Special '0' case - very late attribute setting */
Do = (GEO == State);
}
if (Do)
{
count = GetSymbolTableValue(&value, Next, module_id, FormSymbolTable);
XtSetArg(args[*n], Next->Name, value);
(*n)++;
if (*n >= MAX_ARGS)
__MrmExit(LOC, "Too many args\n");
if (count > 0)
{ /* Certain attributes have a count associated */
char buff[256]; /* with them. This is a temporary(?) way to */
/* identify them and automatically include it */
if (0 == strcmp(Next->Name, XmNitems))
strcpy(buff, XmNitemCount);
#if XmVERSION > 1
else if (0 == strcmp(Next->Name, XmNdetail))
strcpy(buff, XmNdetailCount);
else if (0 == strcmp(Next->Name, XmNdetailColumnHeading))
strcpy(buff, XmNdetailColumnHeadingCount);
else if (0 == strcmp(Next->Name, XmNvalues))
strcpy(buff, XmNnumValues);
#endif
else
__MrmWarn(LOC, "Can't find %s\n", Next->Name);
XtSetArg(args[*n], buff, count);
(*n)++;
if (*n >= MAX_ARGS)
__MrmExit(LOC, "You guessed it - Too many args\n");
}
}
Next = Next->Next;
}
}
static int
GetSymbolTableValue(XtArgVal *value, SymbolTableType *Next,
int module_id, SymbolTableType *FormSymbolTable)
{
int status = 0;
char *temp;
BitMapType *bitmap;
SymbolTableType *SymbolTable;
switch (Next->type)
{
case MrmRtypePixmapImage:
{
PixmapType *data;
char *Image;
Pixel fg, bg;
Pixmap icon;
data = (PixmapType *) Next->value;
Image = data->data;
XtVaGetValues(parent, XmNforeground, &fg, XmNbackground, &bg, NULL, NULL);
MakePixmap(display, &icon, data, fg, bg);
*value = (long)icon;
break;
}
case MrmRtypeXBitmapFile:
bitmap = (BitMapType *) Next->value;;
*value = (long)XCreateBitmapFromData(display, window,
bitmap->data,
bitmap->width, bitmap->height);
break;
case MrmRtypeKeysym:
{
char *sym = (char *)Next->value;
if ('~' == sym[0])
{
temp = &sym[1];
if (NULL ==
(SymbolTable = LookupValue(UilModule[module_id].SymbolTable, temp)))
{
if (NULL == (SymbolTable = LookupValue(GlobalSymbolTable, temp)))
{
if (NULL == (SymbolTable = LookupValue(FormSymbolTable, temp)))
{
__MrmExit(LOC, "Could not find %s\n", temp);
}
}
}
*value = XStringToKeysym(SymbolTable->value);
}
else
*value = XStringToKeysym(Next->value);
break;
}
case MrmRtypeInteger:
case MrmRtypeBoolean:
*value = (long)Next->value;
break;
case MrmRtypeFont:
{
XFontStruct *theFont = XLoadQueryFont(display, Next->value);
XmFontListEntry theEntry;
if (NULL == theFont)
__MrmExit(LOC, "Can't load font %s\n", Next->value);
theEntry = XmFontListEntryCreate(XmFONTLIST_DEFAULT_TAG,
XmFONT_IS_FONT,
(XtPointer)theFont);
*value = (long)XmFontListAppendEntry(NULL, theEntry);
break;
}
case MrmRtypeFontList:
{
int i;
FontTableHeaderType *theHeader = (FontTableHeaderType *) Next->value;
XmFontList theFontList = NULL;
XmFontListEntry theEntry;
char *FontName;
char *TagName;
SymbolTableType *symbolTable;
for (i = 0; i < theHeader->NumFonts; i++)
{
FontName = theHeader->FontTable[i].FontName;
TagName = theHeader->FontTable[i].Tag.name;
if (0 == TagName[0])
TagName = XmFONTLIST_DEFAULT_TAG;
symbolTable = LookUpAddr(FontName, module_id);
fprintf(stderr, "LOOKUP FONT %s\n", FontName);
if (NULL == symbolTable)
__MrmExit(LOC, "Can't find %s in the symbol tables\n", FontName);
FontName = (char *)symbolTable->value;
/* RtoL = theHeader->FontTable[i].Tag.DirectionRtoL; */
/* WideChar = theHeader->FontTable[i].Tag.WideChar; */
theEntry = XmFontListEntryLoad(display, FontName, XmFONT_IS_FONT,
TagName);
theFontList = XmFontListAppendEntry(theFontList, theEntry);
XmFontListEntryFree(&theEntry);
}
*value = (long)theFontList;
break;
}
case MrmRtypeColor:
{
XColor exact, def;
ColorDefType *Color = (ColorDefType *) (Next->value);
if (Color->name)
{
if (XAllocNamedColor(display, colormap, Color->name, &def, &exact))
{
*value = (XtArgVal)def.pixel;
}
else
__MrmExit(LOC, "Couldn't resolve color: %s\n", Next->value);
}
else
{
def.red = Color->r;
def.green = Color->g;
def.blue = Color->b;
if (XAllocColor(display, colormap, &def))
*value = (XtArgVal)def.pixel;
else
__MrmExit(LOC, "Couldn't resolve color: %s\n", Next->value);
}
break;
}
case MrmRtypeAddrName:
temp = Next->value;
if (1 == __MrmLookUpPredefines(temp, value))
break;
if (NULL ==
(SymbolTable = LookupValue(UilModule[module_id].SymbolTable, temp)))
{
if (NULL == (SymbolTable = LookupValue(GlobalSymbolTable, temp)))
{
if (NULL == (SymbolTable = LookupValue(FormSymbolTable, temp)))
{
__MrmExit(LOC, "Could not find %s\n", temp);
}
}
}
status = GetSymbolTableValue(value, SymbolTable, module_id, FormSymbolTable);
break;
case MrmRtypeChar8Vector:
{
XmString *strings;
char **array;
char **temparray;
int i = 0;
array = (char **)Next->value;
for (temparray = array; *temparray; temparray++)
i++;
strings = (XmString *)malloc(i * sizeof(XmString *));
for (i = 0; *array; array++, i++)
{
char *sym;
sym = *array;
if ('~' == sym[0])
{
temp = &sym[1];
if (NULL ==
(SymbolTable = LookupValue(UilModule[module_id].SymbolTable, temp)))
{
if (NULL == (SymbolTable = LookupValue(GlobalSymbolTable, temp)))
{
if (NULL == (SymbolTable = LookupValue(FormSymbolTable, temp)))
{
__MrmExit(LOC, "Could not find %s\n", temp);
}
}
}
strings[i] = XmStringCreate(SymbolTable->value, XmFONTLIST_DEFAULT_TAG);
}
else
strings[i] = XmStringCreate(*array, XmFONTLIST_DEFAULT_TAG);
}
*value = (XtArgVal)strings;
status = i;
break;
}
case MrmRtypeChar8:
*value = (XtArgVal)XmStringCreateSimple(Next->value);
break;
case MrmRtypeCString:
*value = (XtArgVal)
DecodeComplexString((StringType *) Next->value, module_id, NULL);
break;
case ANOTHER_WIDGET: /* Another Widget */
*value = (XtArgVal)(Next->value);
break;
default:
__MrmExit(LOC, "UNKNOWN ATTRIBUTE: %d\n", Next->type);
}
return status;
}
static XmString
DecodeComplexString(StringType * stringC, int module_id, char *ascii)
{
SymbolTableType *st;
StringType *tempC;
XmString s = NULL;
static char a[2048];
a[0] = 0;
for (; stringC; stringC = stringC->Next)
{
if (stringC->IsAddr)
{
tempC = stringC;
st = LookUpAddr(stringC->theString, module_id);
if (NULL == st)
__MrmExit(LOC, "Could not find %s\n", stringC->theString);
tempC = (StringType *) st->value;
s = XmStringConcat(s, DecodeComplexString(tempC, module_id, NULL));
}
else
{
s = XmStringConcat(s, XmStringCreate(stringC->theString,
stringC->theFontSet));
strncat(a, stringC->theString, 2048);
if (stringC->IsSeparator)
{
strcat(a, "\n");
s = XmStringConcat(s, XmStringSeparatorCreate());
}
}
}
if (ascii != NULL)
ascii = &a[0];
return s;
}
static SymbolTableType *
GetSymbolTable(SymbolTableType *Table)
{
char name[256], ch;
int i;
SymbolTableType *NewTable = NULL;
SymbolTableType *LastTable = NULL;
if (Table)
for (LastTable = Table; LastTable->Next; LastTable = LastTable->Next)
;
for (ch = getchar(); ch; ch = getchar())
{
for (i = 0, name[i] = ch; name[i] != '"'; i++, name[i] = getchar())
;
name[i] = 0;
NewTable = (SymbolTableType *)malloc(sizeof(SymbolTableType));
NewTable->Next = NULL;
if (LastTable)
{
LastTable->Next = NewTable;
}
else if (NULL == Table)
Table = NewTable;
LastTable = NewTable;
NewTable->Name = __MrmStore(name);
NewTable->type = getchar();
NewTable->value = ReadType(NewTable->type);
}
if (NULL == Table)
return NewTable;
else
return Table;
}
static SymbolTableType *
LookupValue(SymbolTableType *SymbolTable, char *name)
{
while (SymbolTable)
{
if (0 == strcmp(SymbolTable->Name, name))
return SymbolTable;
else
SymbolTable = SymbolTable->Next;
}
return NULL;
}
static void
PrintWidgetTree(UilModuleType *Module)
{
PrintWidgets(Module);
}
/* LIST SYMBOL_TABLE(Global) SYMBOL_TABLE(local) WIDGETS */
static void
ReadWidgetTree(UilModuleType *Module)
{
ReadList(Module);
GlobalSymbolTable =
GetSymbolTable(GlobalSymbolTable);
Module->SymbolTable =
GetSymbolTable(NULL);
ReadWidgets(Module);
}
/* LIST = INT(count) NAMES CHAR(0) */
static void
ReadList(UilModuleType *Module)
{
int NumberOfWidgets;
int i, c;
fread(&NumberOfWidgets, sizeof(int), 1, stdin); /* INT(widget count) */
fread(&MaxAttributes, sizeof(int), 1, stdin); /* INT(max attributes) */
Module->NumberOfWidgets = NumberOfWidgets;
Module->Definitions = (char **)malloc(sizeof(char *) * NumberOfWidgets);
Module->WidgetArray = (Widget *)malloc(sizeof(Widget) * NumberOfWidgets);
Module->DummyWidgetArray = (DummyWidget *)
malloc(sizeof(DummyWidget) * NumberOfWidgets);
for (i = 0; (((c = getc(stdin)) != EOF) && c); i++)
{ /* NAMES CHAR(0) */
char string[MAX_STR];
int j = 0;
for (j = 0; (c != EOF) && (c != '"'); j++)
{ /* NAMES = NAME " */
string[j] = (char)c; /* NAME = [^"]* */
if (j >= MAX_STR)
__MrmExit(LOC, "String def too long\n");
c = getc(stdin);
}
string[j] = 0;
Module->DummyWidgetArray[i].Name = __MrmStore(string);
}
if (c)
__MrmExit(LOC, "ERROR in header\n");
}
static void
PrintWidgets(UilModuleType *Module)
{
DummyWidget *DW;
int i;
for (i = 0; i < Module->NumberOfWidgets; i++)
{
DW = &Module->DummyWidgetArray[i];
fprintf(stderr, "oject %s: %s {\n", DW->Name,
CreateFunctions[DW->wclass].Name);
PrintArgs(DW->attributes);
PrintControls(DW->NumberOfChildren, DW->children, Module->DummyWidgetArray);
PrintCallbacks(DW->callbacks);
fprintf(stderr, "};\n");
}
}
static void
PrintArgs(SymbolTableType *Next)
{
fprintf(stderr, "\targuments {\n");
while (Next)
{
switch (Next->type)
{
case MrmRtypeInteger:
case MrmRtypeBoolean:
fprintf(stderr, "\t\t%s = %ld;\n", Next->Name, (long)Next->value);
break;
case MrmRtypeKeysym:
case MrmRtypeAddrName:
fprintf(stderr, "\t\t%s = \"%s\";\n", Next->Name, Next->value);
break;
case MrmRtypeChar8:
fprintf(stderr, "\t\t%s = \"%s\";\n", Next->Name,
((StringType *)Next->value)->theString);
break;
case MrmRtypeCString:
fprintf(stderr, "\t\t%s = \"%s\";\n", Next->Name,
((StringType *)Next->value)->theString);
break;
default:
fprintf(stderr, "! ???? %s \n", Next->Name);
break;
}
Next = Next->Next;
}
fprintf(stderr, "\t};\n");
}
static void
PrintControls(int count, int *ids, DummyWidget *Array)
{
int i;
DummyWidget *DW;
fprintf(stderr, "\tcontrols {\n");
for (i = 0; i < count; i++)
{
DW = &Array[ids[i] - 1];
fprintf(stderr, "\t\t%s %s;\n", CreateFunctions[DW->wclass].Name, DW->Name);
};
fprintf(stderr, "\t}\n");
}
static void
PrintCallbacks(callbackType *Next)
{
SymbolTableType *NextParam;
fprintf(stderr, "\tcallbacks {\n");
while (Next)
{
fprintf(stderr, "\t\t%s = procedure %s(",
Next->argName, Next->functionName);
for (NextParam = Next->Parameters; NextParam; NextParam = NextParam->Next)
switch (NextParam->type)
{
case MrmRtypeInteger:
case MrmRtypeBoolean:
fprintf(stderr, "%ld", (long)NextParam->value);
break;
case MrmRtypeKeysym:
case MrmRtypeAddrName:
fprintf(stderr, "%s", NextParam->value);
break;
case MrmRtypeChar8:
fprintf(stderr, "%s",
((StringType *)NextParam->value)->theString);
break;
case MrmRtypeCString:
fprintf(stderr, "%s",
((StringType *)NextParam->value)->theString);
break;
default:
break;
}
fprintf(stderr, ");\n");
Next = Next->next;
};
fprintf(stderr, "\t};\n");
}
/*
// WIDGETS = WIDGET WIDGETS
// | NULL
*/
static void
ReadWidgets(UilModuleType *Module)
{
char c;
int WidgetIndex;
DummyWidget *DW;
int i, index, size;
int this_id, child_id, inherit_id;
char temp[256];
/*
In the following definition:
integer size = 4 bytes
INT(0) - an integer sized zero to mark
the end of a list e.g. INHERIT is a list of inherited widgets but
if a widget id of zero is read, we know we have come to the end of the list
CHAR(MrmTypeClassRecName) - a byte sized value of 22 (MrmTypeClassRecName)
to indicate the start of a widget.
*/
/* WIDGET = CHAR(MrmTypeClassRecName) NAME(widget's name) " INT(id) INT(class)
// CHAR(managed) INT(parent) INHERIT INT(0) CHILDREN INT(0)
// CALLBACKS TABLE(attributes)
*/
for (c = getc(stdin), WidgetIndex = 0;
c == MrmRtypeClassRecName;
c = getc(stdin), WidgetIndex++)
{ /* CHAR(MrmTypeClassRecName) */
for (i = 0, c = getchar(); c != '"'; c = getchar(), i++)
{ /* NAME " */
temp[i] = c;
}
temp[i] = 0;
DW = &Module->DummyWidgetArray[WidgetIndex];
DW->Name = __MrmStore(temp);
if (strcmp(DW->Name, "templatePick") == 0)
fprintf(stderr, "STOP\n");
fread(&this_id, sizeof(this_id), 1, stdin); /*INT(id) */
if (this_id != (WidgetIndex + 1))
__MrmExit(LOC, "INDEX ERROR:widgets should be stored in file by id number\n");
fread(&DW->wclass, sizeof(DW->wclass), 1, stdin); /*INT(class) */
fread(&DW->managed, sizeof(DW->managed), 1, stdin); /*CHAR(managed) */
fread(&DW->parent, sizeof(DW->parent), 1, stdin); /*INT(parent) */
DW->inherit = NULL;
size = 0;
index = 0;
for (fread(&inherit_id, sizeof(inherit_id), 1, stdin); /*INHERIT = INT INH */
inherit_id; /*INT(0) */
fread(&inherit_id, sizeof(inherit_id), 1, stdin))
{
if (size <= index)
{
size += 10;
DW->inherit = (int *)realloc(DW->inherit, size * sizeof(inherit_id));
}
DW->inherit[index] = inherit_id;
index++;
}
DW->NumberOfInherit = index;
DW->children = NULL, size = 0, index = 0;
for (fread(&child_id, sizeof(child_id), 1, stdin); /*CHILDREN=INT CHILDREN */
child_id; /*INT(0) */
fread(&child_id, sizeof(child_id), 1, stdin))
{
if (size <= index)
{
size += 10;
if (DW->children)
DW->children =
(int *)realloc(DW->children, size * sizeof(child_id));
else
DW->children =
(int *)malloc(size * sizeof(child_id));
}
DW->children[index] = child_id;
index++;
}
DW->NumberOfChildren = index;
ReadCallbacks(&(DW->callbacks));
DW->attributes = ReadAttributes();
}
}
/* CALLBACKS = CHAR(MrmRtypeCallback) INT(id) INT(index) NAME(argname) "
// NAME(function name) " CHAR(# of params) PARAMS CALLBACKS
// | NULL
// PARAMS = CHAR(type) INT(value) PARAMS integer,bool
// | CHAR(type) STRING CHAR(0) PARAMS AddrName,CString,String,keysym
*/
static void
ReadCallbacks(callbackType **first)
{
char c, temp[MAX_BUFFER];
int i;
SymbolTableType **ParamPointer;
char NumberOfParams;
callbackType *last;
callbackType *newc;
*first = last = NULL;
c = getchar();
for (; c == MrmRtypeCallback; c = getchar())
{ /* CHAR(MrmRtypeCallback) */
newc = (callbackType *)malloc(sizeof(callbackType));
newc->Parameters = NULL;
newc->next = NULL;
if (last)
last->next = newc;
last = newc;
if (NULL == *first)
*first = newc;
fread(&newc->id, sizeof(newc->id), 1, stdin); /* INT(id) */
for (i = 0, c = getchar(); c != '"'; c = getchar()) /* NAME(argname) */
temp[i++] = c;
temp[i] = 0;
newc->argName = __MrmStore(temp);
for (i = 0, c = getchar(); c != '"'; c = getchar()) /* NAME(function name) */
temp[i++] = c;
temp[i] = 0;
newc->functionName = __MrmStore(temp);
/* PARAMS = CHAR(type) INT(value) PARAMS integer,bool */
/* | CHAR(type) STRING CHAR(0) PARAMS AddrName,CString,String,keysym */
NumberOfParams = getchar();
ParamPointer = &(newc->Parameters);
newc->Parameters = NULL;
for (i = 0; i < NumberOfParams; i++)
{
*ParamPointer = (SymbolTableType *)malloc(sizeof(SymbolTableType));
(*ParamPointer)->type = getchar();
(*ParamPointer)->value = ReadType((*ParamPointer)->type);
(*ParamPointer)->Next = NULL;
ParamPointer = &((*ParamPointer)->Next);
}
}
ungetc(c, stdin);
}
/* TABLE(attributes) = EXPRESSION TABLE(attributes)
// | NULL
*/
static SymbolTableType *
ReadAttributes(void)
{
char c;
SymbolTableType *Return = NULL, *Next, *Last = NULL;
fprintf(stderr, "READ ATTRIBUTES\n");
/* EXPRESSION = CHAR(MrmRtypeResource) NAME " CHAR(type) INT(value)
// | CHAR(MrmRtypeResource) NAME " CHAR(type) NAME(string value) CHAR(0)
// | CHAR(MrmRtypeResource) NAME " CHAR(type) NAME(bitmap value) CHAR(0)
// | CHAR(MrmRtypeResource) NAME " CHAR(type) NAME(pixmap value) CHAR(0)
*/
for (c = getchar();
c == MrmRtypeResource;
c = getchar())
{ /* CHAR(MrmRtypeResource) */
Next = (SymbolTableType *)malloc(sizeof(SymbolTableType));
Next->Next = NULL;
if (NULL == Last)
Return = Next;
else
Last->Next = Next;
fread(&(Next->Index), sizeof(Next->Index), 1, stdin);
__MrmGetArgValues(Next->Index, &Next->Name, &Next->Access);
Next->type = getchar(); /* CHAR(type) */
Next->value = ReadType(Next->type);
Last = Next;
}
ungetc(c, stdin);
return Return;
}
static char *
ReadType(int type)
{
int i, j;
char buffer[MAX_BUFFER];
char *temp;
char *ReturnValue;
switch (type)
{
case MrmRtypeInteger:
case MrmRtypeBoolean:
fread(&ReturnValue, sizeof(long), 1, stdin);
break;
case MrmRtypeXBitmapFile:
{
int SizeOfData;
BitMapType *bitmap;
bitmap = (BitMapType *) malloc(sizeof(BitMapType));
fread(bitmap, sizeof(BitMapType) - sizeof(long), 1, stdin);
SizeOfData = bitmap->width * bitmap->height >> 3;
bitmap->data = (char *)malloc(SizeOfData);
fread(bitmap->data, sizeof(char), SizeOfData, stdin);
ReturnValue = (char *)bitmap;
break;
}
case MrmRtypeChar8Vector:
{
char *last;
char **array = NULL;
int size = 0;
int index = 0;
temp = last = &buffer[0];
while ((*temp = getchar()))
{
if ('"' == *temp)
{
*temp = 0;
if (size <= index)
{
size += 10;
array = (char **)realloc(array, size * sizeof(char *));
}
array[index] = __MrmStore(last);
index++;
last = temp + 1;
}
temp++;
}
array[index] = NULL;
ReturnValue = (char *)array;
break;
}
case MrmRtypeKeysym:
case MrmRtypeAddrName:
temp = &buffer[0];
while ((*temp++ = getchar()));
ReturnValue = (char *)__MrmStore(buffer);
break;
case MrmRtypeChar8:
{
StringType *theString = (StringType *) malloc(sizeof(StringType));
temp = &buffer[0];
while ((*temp++ = getchar()));
fprintf(stderr, "name = %s ", buffer);
theString->theString = (char *)__MrmStore(buffer);
temp = &buffer[0];
while ((*temp++ = getchar()));
theString->theFontSet = __MrmStore(buffer);
ReturnValue = (char *)theString;
break;
}
case MrmRtypeCString:
{
StringType **handle;
fprintf(stderr, "READING COMPLEX STRING\n");
ReturnValue = NULL;
handle = (StringType **) & ReturnValue;
while (1)
{
for (i = 0; (i < MAX_BUFFER) && (buffer[i] = getchar()); i++);
if (0 == i)
{
break;
}
if (MAX_BUFFER == i)
__MrmExit(LOC, "Static storage area exhausted\n");
(*handle) = (StringType *) malloc(sizeof(StringType));
(*handle)->theString = __MrmStore(buffer);
for (i = 0; (i < MAX_BUFFER) && (buffer[i] = getchar()); i++);
if (MAX_BUFFER == i)
__MrmExit(LOC, "Static storage area exhausted: %s\n", buffer);
(*handle)->theFontSet = __MrmStore(buffer);
(*handle)->IsAddr = getchar();
(*handle)->IsSeparator = getchar();
(*handle)->Next = NULL;
handle = &((*handle)->Next);
}
fprintf(stderr, "COMPLEX DONE\n");
break;
}
case MrmRtypeFontList:
{ /* INT(size) FONT_TABLE */
FontTableType *FontTable;
FontTableHeaderType *FontTableHeader;
int NumFonts;
fread(&NumFonts, sizeof(int), 1, stdin);
FontTable = (FontTableType *) malloc(sizeof(FontTableType) * NumFonts);
FontTableHeader = (FontTableHeaderType *) malloc(sizeof(FontTableHeader));
/* FONT_TABLE = FONT_SET FONT FONT_TABLE */
/* FONT_SET = CHAR(MrmRtypeFontSet) NAME INT(dir)
INT(wideChar) */
FontTableHeader->FontTable = FontTable;
FontTableHeader->NumFonts = NumFonts;
for (j = 0; j < NumFonts; j++)
{
char tempType;
fread(&tempType, sizeof(char), 1, stdin);
if (tempType != MrmRtypeFontSet)
__MrmExit(LOC, "There may be an internal bug with font table decoding. "
"%d read != %d from header.\n", tempType, MrmRtypeFontSet);
for (i = 0; (i < MAX_BUFFER) && (buffer[i] = getchar()); i++);
if (MAX_BUFFER == i)
__MrmExit(LOC, "Static storage area exhausted\n");
FontTable[j].Tag.name = __MrmStore(buffer);
fread(&FontTable[j].Tag.DirectionRtoL, sizeof(int), 1, stdin);
fread(&FontTable[j].Tag.WideChar, sizeof(int), 1, stdin);
/* FONT = CHAR(MrmTypeFont) NAME */
fread(&tempType, sizeof(char), 1, stdin);
if (tempType != MrmRtypeFont)
__MrmExit(LOC, "There may be an internal bug with font table decoding\n");
for (i = 0; (i < MAX_BUFFER) && (buffer[i] = getchar()); i++);
if (MAX_BUFFER == i)
__MrmExit(LOC, "Static storage area exhausted\n");
FontTable[j].FontName = __MrmStore(buffer);
}
ReturnValue = (char *)FontTableHeader;
break;
}
case MrmRtypeColorTable:
{
ColorTableType *ColorTable;
ColorTableHeaderType *ColorTableHeader;
int NumColors;
char type;
fread(&NumColors, sizeof(int), 1, stdin);
ColorTable = (ColorTableType *)malloc(sizeof(ColorTableType) * NumColors);
ColorTableHeader = (ColorTableHeaderType *)
malloc(sizeof(ColorTableHeaderType));
ColorTableHeader->ColorTable = ColorTable;
ColorTableHeader->NumColors = NumColors;
for (j = 0; j < NumColors; j++)
{
for (i = 0; (i < MAX_BUFFER) && (buffer[i] = getchar()); i++);
if (MAX_BUFFER == i)
__MrmExit(LOC, "Static storage area exhausted\n");
ColorTable[j].Reference = __MrmStore(buffer);
fread(&type, sizeof(type), 1, stdin);
ColorTable[j].IsAddress = (MrmRtypeAddrName == type);
ColorTable[j].StringXPM = NULL;
ColorTable[j].Color=ReadType(type);
}
ReturnValue = (char *)ColorTableHeader;
break;
}
case MrmRtypeColor:
{
ColorDefType *Color = (ColorDefType *) malloc(sizeof(ColorDefType));
for (i = 0; (i < MAX_BUFFER) && (buffer[i] = getchar()); i++);
if (MAX_BUFFER == i)
__MrmExit(LOC, "Static storage area exhausted\n");
if (0 == i)
{
Color->name = NULL;
fread(&Color->r, sizeof(int), 1, stdin);
fread(&Color->g, sizeof(int), 1, stdin);
fread(&Color->b, sizeof(int), 1, stdin);
}
else
{
Color->name = __MrmStore(buffer);
}
ReturnValue = (char *)Color;
break;
}
case MrmRtypeFont:
for (i = 0; (i < MAX_BUFFER) && (buffer[i] = getchar()); i++);
if (MAX_BUFFER == i)
__MrmExit(LOC, "Static storage area exhausted\n");
ReturnValue = __MrmStore(buffer);
break;
case MrmRtypePixmapImage:
{
PixmapType *pixmap;
int SizeOfData;
int i;
pixmap = (PixmapType *) malloc(sizeof(PixmapType));
fread(&pixmap->width, sizeof(int), 1, stdin);
fread(&pixmap->height, sizeof(int), 1, stdin);
SizeOfData = pixmap->width * pixmap->height;
for (i = 0; (i < MAX_BUFFER) && (buffer[i] = getchar()); i++);
if (MAX_BUFFER == i)
__MrmExit(LOC, "Static storage area exhausted\n");
pixmap->ColorTable = __MrmStore(buffer);
pixmap->data = (char *)malloc(SizeOfData);
fread(pixmap->data, sizeof(char), SizeOfData, stdin);
ReturnValue = (char *)pixmap;
break;
}
default:
__MrmExit(LOC, "UNKNOWN ATTRIBUTE: code = %d\n", type);
}
return ReturnValue;
#if 0
char *ReturnValue;
switch (Next->type)
{
case MrmRtypePixmapImage:
{
int SizeOfData;
PixmapType *pixmap;
char temp[MAX_BUFFER];
int i;
pixmap = (PixmapType *) malloc(sizeof(PixmapType));
fread(pixmap, sizeof(PixmapType) - sizeof(long), 1, stdin); /*NAME(pixmap) */
for (i = 0; (i < MAX_BUFFER) && (temp[i] = getchar()); i++); /*NAME(colortab */
if (2048 == i)
__MrmExit(LOC, "Static storage area exhausted\n");
pixmap->ColorTable = __MrmStore(temp);
SizeOfData = pixmap->width * pixmap->height;
pixmap->data = (char *)malloc(SizeOfData);
fread(pixmap->data, sizeof(char), SizeOfData, stdin); /* image data */
return ((char *)pixmap);
break;
}
case MrmRtypeXBitmapFile:
{
int SizeOfData;
BitMapType *bitmap;
bitmap = (BitMapType *) malloc(sizeof(BitMapType));
fread(bitmap, sizeof(BitMapType) - sizeof(long), 1, stdin); /*NAME(bitmap) */
SizeOfData = bitmap->width * bitmap->height >> 3;
bitmap->data = (char *)malloc(SizeOfData);
fread(bitmap->data, sizeof(char), SizeOfData, stdin);
return ((char *)bitmap);
break;
}
case MrmRtypeInteger:
case MrmRtypeBoolean:
fread(&ReturnValue, sizeof(ReturnValue), 1, stdin); /* INT(value) */
return (ReturnValue);
break;
case MrmRtypeCString:
case MrmRtypeChar8:
i = 0; /* NAME(value) CHAR(0) */
while ((i < MAX_BUFFER) && (temp[i++] = getchar()));
if (MAX_BUFFER == i)
{
temp[256] = 0;
__MrmExit(LOC, "String too complex: %s", temp);
}
temp[i] = 0;
ReturnValue = __MrmStore(temp);
i = 0; /* NAME(tag) CHAR(0) */
while ((i < MAX_BUFFER) && (temp[i++] = getchar()));
if (MAX_BUFFER == i)
{
temp[256] = 0;
__MrmExit(LOC, "String too complex: %s", temp);
}
temp[i] = 0;
fprintf(stderr, "TAG = %s\n", temp);
return (ReturnValue);
break;
case MrmRtypeKeysym:
case MrmRtypeColor:
case MrmRtypeAddrName:
i = 0; /* NAME(value) CHAR(0) */
while ((i < MAX_BUFFER) && (temp[i++] = getchar()));
if (MAX_BUFFER == i)
{
temp[256] = 0;
__MrmExit(LOC, "String too complex: %s", temp);
}
temp[i] = 0;
return (__MrmStore(temp));
break;
default:
__MrmExit(LOC, "Unknown Attribute type: %d\n", c);
}
#endif /* #if 0 */
}
static void
Xm_List(Widget parent_widget, DummyWidget *DW, int module_id)
{
Arg args[10];
int n = 0;
int i;
int ListCount = 0;
SymbolTableType *Next;
XtArgVal value;
char *temp;
SymbolTableType *SymbolTable;
XmString *ListItem;
for (Next = DW->attributes; Next; Next = Next->Next)
{
switch (Next->type)
{
case MrmRtypeInteger:
value = (long)Next->value;
break;
case MrmRtypeAddrName:
temp = Next->value;
if (NULL == (SymbolTable = LookUpAddr(temp, module_id)))
{
__MrmLookUpPredefines(temp, &value);
break;
}
if (0 == strcmp(Next->Name, "items"))
{
char **strings = (char **)SymbolTable->value;
while (*strings++)
ListCount++;
ListItem = (XmString *)malloc(ListCount * sizeof(XmString));
strings = (char **)SymbolTable->value;
for (i = 0; i < ListCount; i++)
{
char *sym = strings[i];
char s[256];
if ('~' == sym[0])
{
temp = &sym[1];
if (NULL ==
(SymbolTable = LookupValue(UilModule[module_id].SymbolTable,
temp)))
{
if (NULL == (SymbolTable = LookupValue(GlobalSymbolTable, temp)))
{
__MrmExit(LOC, "Could not find %s\n", temp);
}
}
strcpy(s, SymbolTable->value);
ListItem[i] = XmStringCreate(s, XmFONTLIST_DEFAULT_TAG);
}
else
ListItem[i] = XmStringCreate(strings[i], XmFONTLIST_DEFAULT_TAG);
}
value = (XtArgVal)ListItem;
}
else
value = (XtArgVal)SymbolTable->value;
break;
default:
__MrmExit(LOC, "UNKNOWN ATTRIBUTE\n");
}
XtSetArg(args[n], Next->Name, value);
n++;
};
XtSetArg(args[n], XmNitemCount, ListCount);
n++;
XtSetValues(XtNameToWidget(parent_widget, "*List"), args, n);
}
static FILE *
UILOpen(char *tFileName, char *mode, FILE * old)
{
FILE *Return = NULL;
int i, j;
char *theBase;
char buffer[256];
static char Eval = 0;
char *Base[] =
{
"$HOME",
X_LIB_PATH "/lib/X11", /* X installation path */
LESSTIFHOME "/lib/X11" /* LessTif installation path */
};
char *Paths[] =
{
"%L/uid/%N/%U%S",
"%l/uid/%N/%U%S",
"uid/%N/%U%S",
"%L/uid/%U%S",
"%l/uid/%U%S",
"uid/%U%S",
"%U%S",
"%T",
};
static int BaseSize = sizeof(Base) / sizeof(Base[0]);
static int PathSize = sizeof(Paths) / sizeof(Paths[0]);
char *UILPath;
char FileName[256];
for (i = 0; *tFileName; i++)
FileName[i] = *tFileName++;
FileName[i] = 0;
if ((i < 4) || (strcmp(&FileName[i - 4], ".uid") != 0))
strcat(FileName, ".uid");
if (NULL != (Return = freopen(FileName, mode, old)))
{
fprintf(stderr, "Opening %s\n", FileName);
return Return;
}
if (!Eval)
{
Eval = 1;
for (j = 0; j < BaseSize; j++)
{
theBase = Base[j];
if ('$' == theBase[0])
Base[j] = getenv(&theBase[1]);
fprintf(stderr, "Base %d = %s\n", j, Base[j]);
}
}
UILPath = getenv("UILPATH");
if (NULL != UILPath)
{
for (i = j = 0;; j++, i++)
{
if ((':' == UILPath[i]) || (0 == UILPath[i]))
{
buffer[j++] = '/';
strcpy(&buffer[j], FileName);
j = -1;
if (NULL != (Return = freopen(Substitute(buffer), mode, old)))
{
__MrmWarn(LOC, "Opening %s\n", buffer);
return Return;
}
if (0 == UILPath[i])
break;
}
else
buffer[j] = UILPath[i];
}
}
for (j = 1; (NULL == Return) && (j < BaseSize); j++)
if (Base[j])
for (i = 0, sprintf(buffer, "%s/%s/%s", Base[j], Paths[i], FileName);
(NULL == (Return = freopen(Substitute(buffer), mode, old))) &&
(i < PathSize);
i++, sprintf(buffer, "%s/%s/%s", Base[j], Paths[i], FileName))
{
};
if (NULL != Return)
__MrmWarn(LOC, "Opening %s\n", buffer);
return Return;
}
static char *
Substitute(char *buffer)
{
static char buffer2[256];
char *string = buffer2;
while (*buffer)
{
if ('%' == *buffer)
{
buffer++;
switch (*buffer++)
{
case 'N':
strcpy(string, theName);
string += strlen(theName);
break;
case 'U':
strcpy(string, "FROM_LIST"); /* FIX ME */
string += 9;
break;
case 'T':
strcpy(string, "uid");
string += 3;
break;
case 'S':
strcpy(string, ".uid");
string += 4;
break;
case 'L':
strcpy(string, "LANG"); /* FIX ME */
string += 4;
break;
case 'l':
strcpy(string, "lang"); /* FIX ME */
string += 4;
break;
default:
__MrmExit(LOC, "Unknown format\n");
}
}
else
{
*string++ = *buffer++;
}
}
*string = 0;
return buffer2;
}
static void
PrintSymbolTable(SymbolTableType *SymbolTable)
{
for (; SymbolTable; SymbolTable = SymbolTable->Next)
fprintf(stderr, " %s\n", SymbolTable->Name);
}
static void
FreeSymbolTable(SymbolTableType *t)
{
SymbolTableType *n;
while (t)
{
n = t->Next;
free(t);
t = n;
}
}
static SymbolTableType *
LookUpAddr(char *temp, int module_id)
{
SymbolTableType *SymbolTable;
SymbolTable = LookupValue(UilModule[module_id].SymbolTable, temp);
if (NULL == SymbolTable)
{
SymbolTable = LookupValue(GlobalSymbolTable, temp);
}
return SymbolTable;
}
extern Cardinal
MrmRegisterNamesInHierarchy(MrmHierarchy hierarchy_id,
MrmRegisterArglist reglist,
MrmCount num_reg)
{
/* FIX ME */
_XmWarning(NULL, "MrmRegisterNamesInHierarchy() is not yet implemented!");
return MrmFAILURE;
}