LispObj *
Lisp_XawTextSetInsertionPoint(LispBuiltin *builtin)
/*
xaw-text-set-insertion-point widget position
*/
{
Widget widget;
XawTextPosition position;
LispObj *owidget, *oposition;
oposition = ARGUMENT(1);
owidget = ARGUMENT(0);
if (!CHECKO(owidget, xawWidget_t))
LispDestroy("%s: cannot convert %s to Widget",
STRFUN(builtin), STROBJ(owidget));
widget = (Widget)(owidget->data.opaque.data);
CHECK_INDEX(oposition);
position = (XawTextPosition)FIXNUM_VALUE(oposition);
XawTextSetInsertionPoint(widget, position);
return (oposition);
}
void create_dialog(uschar *label, uschar *value)
{
Arg warg[4];
Dimension x, y, xx, yy;
XtTranslations pop_trans;
Widget text;
/* Get the position of a reference widget so the dialog box can be put
near to it. */
get_pos_args[0].value = (XtArgVal)(&x);
get_pos_args[1].value = (XtArgVal)(&y);
XtGetValues(dialog_ref_widget, get_pos_args, 2);
/* When this is not a message_specific thing, the position of the reference
widget is relative to the window. Get the position of the top level widget and
add to the position. */
if (dialog_ref_widget != menushell)
{
get_pos_args[0].value = (XtArgVal)(&xx);
get_pos_args[1].value = (XtArgVal)(&yy);
XtGetValues(toplevel_widget, get_pos_args, 2);
x += xx;
y += yy;
}
/* Create a transient shell for the dialog box. */
XtSetArg(warg[0], XtNtransientFor, queue_widget);
XtSetArg(warg[1], XtNx, x + 50);
XtSetArg(warg[2], XtNy, y + 50);
XtSetArg(warg[3], XtNallowShellResize, True);
dialog_shell = XtCreatePopupShell("forDialog", transientShellWidgetClass,
toplevel_widget, warg, 4);
/* Create the dialog box. */
dialog_arg[0].value = (XtArgVal)label;
dialog_arg[1].value = (XtArgVal)value;
dialog_widget = XtCreateManagedWidget("dialog", dialogWidgetClass, dialog_shell,
dialog_arg, XtNumber(dialog_arg));
/* Get the text widget from within the dialog box, give it the keyboard focus,
make it wider than the default, and override its translations to make Return
call the dialog action function. */
text = XtNameToWidget(dialog_widget, "value");
XawTextSetInsertionPoint(text, Ustrlen(value));
XtSetKeyboardFocus(dialog_widget, text);
xs_SetValues(text, 1, "width", 200);
pop_trans = XtParseTranslationTable(
"<Key>Return: dialogAction()\n");
XtOverrideTranslations(text, pop_trans);
/* Pop the thing up. */
XtPopup(dialog_shell, XtGrabExclusive);
XFlush(X_display);
}
static void
TextAppend(Widget w, char *s, int len)
{
long last, current;
XawTextBlock block;
current = XawTextGetInsertionPoint (w);
last = TextLength (w);
block.ptr = s;
block.firstPos = 0;
block.length = len;
block.format = FMT8BIT;
/*
* If saveLines is 1, just replace the entire contents of the widget
* each time, so the test in ExceededMaxLines() isn't fooled.
*/
if (app_resources.saveLines == 1)
TextReplace (w, 0, last, &block);
else
TextReplace (w, last, last, &block);
if (current == last)
XawTextSetInsertionPoint (w, last + block.length);
if (ExceededMaxLines(w))
ScrollLine(w);
}
static void
show_search_result(char *format,...)
{
va_list ap;
XawTextBlock block;
static char tmpstr[300];
va_start(ap, format);
vsprintf(tmpstr, format, ap );
va_end(ap);
strcat(tmpstr,"\n");
/* append this message to the file message widget string */
block.firstPos = 0;
block.ptr = tmpstr;
block.length = strlen(tmpstr);
block.format = FMT8BIT;
/* make editable to add new message */
FirstArg(XtNeditType, XawtextEdit);
SetValues(search_results_win);
/* insert the new message after the end */
(void) XawTextReplace(search_results_win, msg_length, msg_length, &block);
(void) XawTextSetInsertionPoint(search_results_win, msg_length);
/* make read-only again */
FirstArg(XtNeditType, XawtextRead);
SetValues(search_results_win);
msg_length += block.length;
}
static void
MouseDeviceCallback(Widget w, XtPointer user_data, XtPointer call_data)
{
XawListReturnStruct *info = (XawListReturnStruct *)call_data;
Arg args[1];
XtSetArg(args[0], XtNstring, info->string);
XtSetValues((Widget)user_data, args, 1);
XawTextSetInsertionPoint((Widget)user_data, strlen(info->string));
}
void SFsetText (char *path) {
XawTextBlock text;
text.firstPos = 0;
text.length = strlen (path);
text.ptr = path;
text.format = FMT8BIT;
XawTextReplace (selFileField, 0, strlen (SFtextBuffer), &text);
XawTextSetInsertionPoint (selFileField, strlen (SFtextBuffer));
}
void text_show(Widget w, uschar *s)
{
XawTextBlock b;
b.firstPos = 0;
b.ptr = CS s;
b.format = FMT8BIT;
b.length = Ustrlen(s);
XawTextReplace(w, text_count, text_count, &b);
text_count += b.length;
XawTextSetInsertionPoint(w, text_count);
}
void text_empty(Widget w)
{
XawTextBlock b;
b.firstPos = 0;
b.ptr = CS &b;
b.format = FMT8BIT;
b.length = 0;
XawTextReplace(w, 0, text_count, &b);
text_count = 0;
XawTextSetInsertionPoint(w, text_count);
}
void
XeditPrintf (char *str)
{
XawTextBlock text;
static XawTextPosition pos = 0;
text.length = strlen (str);
text.ptr = str;
text.firstPos = 0;
text.format = FMT8BIT;
XawTextReplace (messwidget, pos, pos, &text);
pos += text.length;
XawTextSetInsertionPoint (messwidget, pos);
}
static void
TextInsert(Widget w, char *s, int len)
{
XawTextBlock block;
long current;
current = XawTextGetInsertionPoint (w);
block.ptr = s;
block.firstPos = 0;
block.length = len;
block.format = FMT8BIT;
TextReplace (w, 0, 0, &block);
if (current == 0)
XawTextSetInsertionPoint (w, len);
if (ExceededMaxLines(w))
ScrollLine(w);
}
/*******************************************************************************
Name: printMatchForTextEdit
Description: Simulates callbacks for dialog widget
Arguments: w - Dialog widget
client_data - Dialog widget
call_data - Not Used
Returns: None
*******************************************************************************/
static void printMatchForTextEdit(
Widget w,
XtPointer client_data,
XtPointer call_data)
{
XawTextBlock text;
String aString = XawDialogGetValueString(XtParent(w));
Widget text_widget = (Widget)client_data;
int length;
length = strlen(completionString);
text.firstPos = 0;
text.length = strlen(&(aString[length]));
text.ptr = &(aString[length]);
XawTextReplace(text_widget,
XawTextGetInsertionPoint(text_widget),
XawTextGetInsertionPoint(text_widget),&text);
XawTextSetInsertionPoint(text_widget,
XawTextGetInsertionPoint(text_widget) + text.length);
XtDestroyWidget(XtParent(XtParent(XtParent(w))));
}
/*
* Function:
* InsertFileNamed
*
* Parameters:
* tw - text widget to insert this file into
* str - name of the file to insert
*
* Description:
* Inserts a file into the text widget.
*
* Returns:
* True if the insert was sucessful, False otherwise.
*/
static Bool
InsertFileNamed(Widget tw, char *str)
{
FILE *file;
XawTextBlock text;
XawTextPosition pos;
if (str == NULL || strlen(str) == 0 || (file = fopen(str, "r")) == NULL)
return (False);
pos = XawTextGetInsertionPoint(tw);
fseek(file, 0L, 2);
text.firstPos = 0;
text.length = ftell(file);
text.ptr = XtMalloc(text.length + 1);
text.format = XawFmt8Bit;
fseek(file, 0L, 0);
if (fread(text.ptr, 1, text.length, file) != text.length)
XtErrorMsg("readError", "insertFileNamed", "XawError",
"fread returned error", NULL, NULL);
if (XawTextReplace(tw, pos, pos, &text) != XawEditDone) {
XtFree(text.ptr);
fclose(file);
return (False);
}
pos += text.length;
XtFree(text.ptr);
fclose(file);
XawTextSetInsertionPoint(tw, pos);
_XawTextShowPosition((TextWidget)tw);
return (True);
}
void
DoChangeDir(char *dir)
{
char *p;
char ndir[PATH_MAX];
if (browse_up) {
strcpy(ndir, cur_browse_dir);
} else if (file_up) {
strcpy(ndir, cur_file_dir);
} else if (export_up) {
strcpy(ndir, cur_export_dir);
}
if (dir != NULL && dir[0] != '/') { /* relative path, prepend current dir */
if (dir[strlen(dir) - 1] == '/')
dir[strlen(dir) - 1] = '\0';
if (strcmp(dir, "..")==0) { /* Parent directory. */
if (*ndir == '\0')
return; /* no current directory, */
/* can't do anything unless absolute path */
p = strrchr(ndir, '/');
*p = EOS;
if (ndir[0] == EOS)
strcpy(ndir, "/");
} else if (strcmp(dir, ".")!=0) {
if (strcmp(ndir, "/")) /* At the root already */
strcat(ndir, "/");
strcat(ndir, dir);
}
} else {
strcpy(ndir, dir); /* abs path copy to ndir */
}
if (change_directory(ndir) != 0 ) {
return; /* some problem, return */
} else if (MakeFileList(ndir, dirmask, &dirlist, &filelist) == False) {
file_msg("Unable to list directory %s", ndir);
return;
}
FirstArg(XtNstring, ndir);
/* update the current directory and file/dir list widgets */
if (browse_up) {
SetValues(browse_dir);
strcpy(cur_browse_dir,ndir); /* update global var */
XawTextSetInsertionPoint(browse_dir, strlen(ndir));
NewList(browse_flist, filelist);
NewList(browse_dlist, dirlist);
} else if (file_up) {
SetValues(file_dir);
strcpy(cur_file_dir,ndir); /* update global var */
strcpy(cur_export_dir,ndir); /* set export directory to file directory */
XawTextSetInsertionPoint(file_dir, strlen(ndir));
NewList(file_flist,filelist);
NewList(file_dlist,dirlist);
} else if (export_up) {
SetValues(exp_dir);
strcpy(cur_export_dir,ndir); /* update global var */
XawTextSetInsertionPoint(exp_dir, strlen(ndir));
NewList(exp_flist, filelist);
NewList(exp_dlist, dirlist);
}
CurrentSelectionName[0] = '\0';
}
static void show_log(char *s, ...)
{
int length, newtop;
va_list ap;
XawTextBlock b;
uschar buffer[log_buffer_len + 24];
/* Do nothing if not tailing a log */
if (log_widget == NULL) return;
/* Initialize the text block structure */
b.firstPos = 0;
b.ptr = CS buffer;
b.format = FMT8BIT;
/* We want to know whether the window has been scrolled back or not,
so that we can cease automatically scrolling with new text. This turns
out to be tricky with the text widget. We can detect whether the
scroll bar has been operated by checking on the "top" value, but it's
harder to detect that it has been returned to the bottom. The following
heuristic does its best. */
newtop = XawTextTopPosition(log_widget);
if (newtop != top)
{
if (!scrolled)
{
visible = size - top; /* save size of window */
scrolled = newtop < top;
}
else if (newtop > size - visible) scrolled = FALSE;
top = newtop;
}
/* Format the text that is to be written. */
va_start(ap, s);
vsprintf(CS buffer, s, ap);
va_end(ap);
length = Ustrlen(buffer);
/* If we are anonymizing for screen shots, flatten various things. */
#ifdef ANONYMIZE
{
uschar *p = buffer + 9;
if (p[6] == '-' && p[13] == '-') p += 17;
while (p < buffer + length)
{
int i;
/* Check for strings to be left alone */
for (i = 0; i < oklist_size; i++)
{
int len = Ustrlen(oklist[i]);
if (Ustrncmp(p, oklist[i], len) == 0)
{
p += len;
break;
}
}
if (i < oklist_size) continue;
/* Leave driver names, size, protocol, alone */
if ((*p == 'D' || *p == 'P' || *p == 'T' || *p == 'S' || *p == 'R') &&
p[1] == '=')
{
p += 2;
while (*p != ' ' && *p != 0) p++;
continue;
}
/* Leave C= text alone */
if (Ustrncmp(p, "C=\"", 3) == 0)
{
p += 3;
while (*p != 0 && *p != '"') p++;
continue;
}
/* Flatten remaining chars */
if (isdigit(*p)) *p++ = 'x';
else if (isalpha(*p)) *p++ = 'x';
else *p++ = '$';
}
}
#endif
/* If this would overflow the buffer, throw away 50% of the
current stuff in the buffer. Code defensively against odd
extreme cases that shouldn't actually arise. */
if (size + length > log_buffer_size)
{
if (size == 0) length = log_buffer_size/2; else
{
int cutcount = log_buffer_size/2;
if (cutcount > size) cutcount = size; else
{
while (cutcount < size && log_display_buffer[cutcount] != '\n')
cutcount++;
cutcount++;
}
b.length = 0;
XawTextReplace(log_widget, 0, cutcount, &b);
size -= cutcount;
top -= cutcount;
if (top < 0) top = 0;
if (top < cutcount) XawTextInvalidate(log_widget, 0, 999999);
xs_SetValues(log_widget, 1, "displayPosition", top);
}
}
/* Insert the new text at the end of the buffer. */
b.length = length;
XawTextReplace(log_widget, 999999, 999999, &b);
size += length;
/* When not scrolled back, we want to keep the bottom line
always visible. Put the insert point at the start of it because
this stops left/right scrolling with some X libraries. */
if (!scrolled)
{
XawTextSetInsertionPoint(log_widget, size - length);
top = XawTextTopPosition(log_widget);
}
}
int
main(int argc, char *argv[])
{
Boolean exists;
char *filename;
FileAccess file_access;
Widget source;
XtAppContext appcon;
Boolean show_dir;
xedit_flist_item *first_item;
unsigned int i, lineno;
lineno = 0;
show_dir = FALSE;
first_item = NULL;
topwindow = XtAppInitialize(&appcon, "Xedit", NULL, 0, &argc, argv,
NULL,
NULL, 0);
XtAppAddActions(appcon, actions, XtNumber(actions));
XtOverrideTranslations(topwindow,
XtParseTranslationTable("<Message>WM_PROTOCOLS: quit()"));
XtGetApplicationResources(topwindow, (XtPointer) &app_resources, resources,
XtNumber(resources), NULL, 0);
CurDpy = XtDisplay(topwindow);
XawSimpleMenuAddGlobalActions(appcon);
XtRegisterGrabAction(PopupMenu, True,
ButtonPressMask | ButtonReleaseMask,
GrabModeAsync, GrabModeAsync);
makeButtonsAndBoxes(topwindow);
StartHints();
StartFormatPosition();
(void)StartHooks(appcon);
if (position_format_mask == 0) {
for (i = 0; i < 3; i++)
XtRemoveCallback(texts[i], XtNpositionCallback,
PositionChanged, NULL);
}
XtRealizeWidget(topwindow);
#ifndef __UNIXOS2__
XeditLispInitialize();
#endif
options_popup = XtCreatePopupShell("optionsMenu", simpleMenuWidgetClass,
topwindow, NULL, 0);
XtRealizeWidget(options_popup);
XtAddCallback(XtCreateManagedWidget("ispell", smeBSBObjectClass,
options_popup, NULL, 0),
XtNcallback, IspellCallback, NULL);
CreateEditPopup();
wm_delete_window = XInternAtom(XtDisplay(topwindow), "WM_DELETE_WINDOW",
False);
(void)XSetWMProtocols(XtDisplay(topwindow), XtWindow(topwindow),
&wm_delete_window, 1);
/* This first call is just to save the default font and colors */
UpdateTextProperties(0);
if (argc > 1) {
xedit_flist_item *item;
Arg args[2];
unsigned int num_args;
for (i = 1; i < argc; i++) {
struct stat st;
if (argv[i][0] == '+') {
char *endptr;
lineno = strtol(argv[i], &endptr, 10);
/* Don't warn about incorrect input? */
if (*endptr)
lineno = 0;
continue;
}
filename = ResolveName(argv[i]);
if (filename == NULL || FindTextSource(NULL, filename) != NULL)
continue;
num_args = 0;
if (stat(filename, &st) == 0 && !S_ISREG(st.st_mode)) {
if (S_ISDIR(st.st_mode)) {
if (!first_item) {
char path[BUFSIZ + 1];
strncpy(path, filename, sizeof(path) - 2);
path[sizeof(path) - 2] = '\0';
if (*path) {
if (path[strlen(path) - 1] != '/')
strcat(path, "/");
}
else
strcpy(path, "./");
XtSetArg(args[0], XtNlabel, "");
XtSetValues(dirlabel, args, 1);
SwitchDirWindow(True);
DirWindowCB(dirwindow, path, NULL);
show_dir = True;
}
continue;
}
}
switch (file_access = CheckFilePermissions(filename, &exists)) {
case NO_READ:
if (exists)
XeditPrintf("File %s exists, and could not be opened for "
"reading.\n", argv[i]);
else
XeditPrintf("File %s does not exist, and the directory "
"could not be opened for writing.\n", argv[i]);
break;
case READ_OK:
XtSetArg(args[num_args], XtNeditType, XawtextRead); num_args++;
XeditPrintf("File %s opened READ ONLY.\n", argv[i]);
break;
case WRITE_OK:
XtSetArg(args[num_args], XtNeditType, XawtextEdit); num_args++;
XeditPrintf("File %s opened read - write.\n", argv[i]);
break;
}
if (file_access != NO_READ) {
int flags;
if (exists) {
flags = EXISTS_BIT;
XtSetArg(args[num_args], XtNstring, filename);num_args++;
}
else {
flags = 0;
XtSetArg(args[num_args], XtNstring, NULL); num_args++;
}
source = XtVaCreateWidget("textSource", international ?
multiSrcObjectClass
: asciiSrcObjectClass, topwindow,
XtNtype, XawAsciiFile,
XtNeditType, XawtextEdit,
NULL, NULL);
XtSetValues(source, args, num_args);
item = AddTextSource(source, argv[i], filename,
flags, file_access);
XtAddCallback(item->source, XtNcallback, SourceChanged,
(XtPointer)item);
if (exists && file_access == WRITE_OK) {
item->mode = st.st_mode & (S_IRWXU | S_IRWXG | S_IRWXO);
item->mtime = st.st_mtime;
}
if (!first_item && !show_dir)
first_item = item;
ResetSourceChanged(item);
}
}
}
if (!flist.pixmap && strlen(app_resources.changed_pixmap_name)) {
XrmValue from, to;
from.size = strlen(app_resources.changed_pixmap_name);
from.addr = app_resources.changed_pixmap_name;
to.size = sizeof(Pixmap);
to.addr = (XtPointer)&(flist.pixmap);
XtConvertAndStore(flist.popup, XtRString, &from, XtRBitmap, &to);
}
if (first_item == NULL) {
XtSetKeyboardFocus(topwindow, filenamewindow);
XtVaSetValues(textwindow, XtNwrap, XawtextWrapLine, NULL);
}
else {
SwitchTextSource(first_item);
XtSetKeyboardFocus(topwindow, textwindow);
if (lineno) {
XawTextPosition position;
source = XawTextGetSource(textwindow);
position = RSCAN(XawTextGetInsertionPoint(textwindow),
lineno, False);
position = LSCAN(position, 1, False);
XawTextSetInsertionPoint(textwindow, position);
}
}
XtAppMainLoop(appcon);
return EXIT_SUCCESS;
}
/*******************************************************************************
Name: CompletionEditCallback
Description: Called when Completion is selected form File menu
in the editor.
Arguments: w - menu item that was selected
client_data - dialog window or edit window
call_data - not used
Returns: None
*******************************************************************************/
void CompletionEditCallback(
Widget w,
XtPointer client_data,
XtPointer call_data)
{
int NumberOfMatches,i,length;
Boolean tempFlag;
struct symbolMatch *matches;
extern char* GetCommandString();
XawTextBlock text;
char *matchString = NULL;
Widget source = XawTextGetSource((Widget)client_data);
XawTextPosition CurrentPosition,EndPosition;
/* ================================================== */
/* Free the memory of completionString before assign */
/* it to the new string. */
/* ================================================== */
if(completionString != NULL)
{
free(completionString);
completionString = NULL;
}
/* =================================================== */
/* Get the beginning and ending positions of the */
/* selection. If there is no selection get the last */
/* word from the cursor. */
/* ====================================================*/
XawTextGetSelectionPos((Widget)client_data,&CurrentPosition,&EndPosition);
if(CurrentPosition == EndPosition) /* No selection was made */
{
matchString = GetBufferFromTextEdit((Widget)client_data);
length = strlen(matchString);
}
else
{
XawTextSourceRead(source,CurrentPosition,&text,EndPosition - CurrentPosition);
XawTextUnsetSelection((Widget)client_data);
XawTextSetInsertionPoint((Widget)client_data,EndPosition);
matchString = text.ptr;
length = text.length;
}
/* ======================================= */
/* Determine if the word can be matched. */
/* ======================================= */
matchString = GetCommandCompletionString(matchString,length);
if(matchString == NULL)
{
XBell(XtDisplay(toplevel),100);
return;
}
completionString = (char*)malloc(strlen(matchString) + 1);
strcpy(completionString,matchString);
matches = FindSymbolMatches(completionString,&NumberOfMatches,NULL);
if(NumberOfMatches == 0)
{
XBell(XtDisplay(toplevel),100);
return;
}
else if (NumberOfMatches == 1)
{
length = strlen(completionString);
text.firstPos = 0;
text.length = strlen(&(matches->match->contents[length]));
text.ptr = &(matches->match->contents[length]);
XawTextReplace((Widget)client_data,
XawTextGetInsertionPoint((Widget)client_data),
XawTextGetInsertionPoint((Widget)client_data),&text);
XawTextSetInsertionPoint((Widget)client_data,
XawTextGetInsertionPoint((Widget)client_data) + text.length);
}
else
{
DisplayMatchedList((Widget)client_data,matches);
}
}
int GTsetwidgetattr (Gwidget_t *widget, int attrn, Gwattr_t *attrp) {
PIXsize_t ps;
XawTextBlock tb;
int ai, li;
XColor c;
int color;
RESETARGS;
for (ai = 0; ai < attrn; ai++) {
switch (attrp[ai].id) {
case G_ATTRSIZE:
GETSIZE (attrp[ai].u.s, ps, MINTWSIZE);
ADD2ARGS (XtNwidth, ps.x);
ADD2ARGS (XtNheight, ps.y);
break;
case G_ATTRBORDERWIDTH:
ADD2ARGS (XtNborderWidth, attrp[ai].u.i);
break;
case G_ATTRTEXT:
ADD2ARGS (XtNstring, attrp[ai].u.t);
break;
case G_ATTRAPPENDTEXT:
XawTextSetInsertionPoint (widget->w, 327670000);
li = XawTextGetInsertionPoint (widget->w);
tb.firstPos = 0, tb.length = strlen (attrp[ai].u.t);
tb.ptr = attrp[ai].u.t, tb.format = FMT8BIT;
XawTextReplace (widget->w, li, li, &tb);
li = XawTextGetInsertionPoint (widget->w);
tb.firstPos = 0, tb.length = 1;
tb.ptr = "\n", tb.format = FMT8BIT;
XawTextReplace (widget->w, li, li, &tb);
break;
case G_ATTRMODE:
if (strcmp ("oneline", attrp[ai].u.t) == 0)
ADD2ARGS (XtNeditType, XawtextAppend);
else if (strcmp ("input", attrp[ai].u.t) == 0)
ADD2ARGS (XtNeditType, XawtextEdit);
else if (strcmp ("output", attrp[ai].u.t) == 0)
ADD2ARGS (XtNeditType, XawtextRead);
else {
Gerr (POS, G_ERRBADATTRVALUE, attrp[ai].u.t);
return -1;
}
break;
case G_ATTRCOLOR:
color = attrp[ai].u.c.index;
if (color != 0 && color != 1) {
Gerr (POS, G_ERRBADCOLORINDEX, color);
return -1;
}
c.red = attrp[ai].u.c.r * 257;
c.green = attrp[ai].u.c.g * 257;
c.blue = attrp[ai].u.c.b * 257;
if (XAllocColor (
Gdisplay, DefaultColormap (Gdisplay, Gscreenn), &c
))
if (color == 0)
ADD2ARGS (XtNbackground, c.pixel);
else
ADD2ARGS (XtNforeground, c.pixel);
break;
case G_ATTRWINDOWID:
Gerr (POS, G_ERRCANNOTSETATTR2, "windowid");
return -1;
case G_ATTRNEWLINECB:
WTU->func = (Gtwnewlinecb) attrp[ai].u.func;
break;
case G_ATTRUSERDATA:
widget->udata = attrp[ai].u.u;
break;
default:
Gerr (POS, G_ERRBADATTRID, attrp[ai].id);
return -1;
}
}
XtSetValues (widget->w, argp, argn);
return 0;
}