diff options
Diffstat (limited to 'vendor/x11iraf/obm/ObmW/HTMLwidgets.c')
| -rw-r--r-- | vendor/x11iraf/obm/ObmW/HTMLwidgets.c | 4014 |
1 files changed, 4014 insertions, 0 deletions
diff --git a/vendor/x11iraf/obm/ObmW/HTMLwidgets.c b/vendor/x11iraf/obm/ObmW/HTMLwidgets.c new file mode 100644 index 00000000..a4195c45 --- /dev/null +++ b/vendor/x11iraf/obm/ObmW/HTMLwidgets.c @@ -0,0 +1,4014 @@ +/**************************************************************************** + * NCSA Mosaic for the X Window System * + * Software Development Group * + * National Center for Supercomputing Applications * + * University of Illinois at Urbana-Champaign * + * 605 E. Springfield, Champaign IL 61820 * + * mosaic@ncsa.uiuc.edu * + * * + * Copyright (C) 1993, Board of Trustees of the University of Illinois * + * * + * NCSA Mosaic software, both binary and source (hereafter, Software) is * + * copyrighted by The Board of Trustees of the University of Illinois * + * (UI), and ownership remains with the UI. * + * * + * The UI grants you (hereafter, Licensee) a license to use the Software * + * for academic, research and internal business purposes only, without a * + * fee. Licensee may distribute the binary and source code (if released) * + * to third parties provided that the copyright notice and this statement * + * appears on all copies and that no charge is associated with such * + * copies. * + * * + * Licensee may make derivative works. However, if Licensee distributes * + * any derivative work based on or derived from the Software, then * + * Licensee will (1) notify NCSA regarding its distribution of the * + * derivative work, and (2) clearly notify users that such derivative * + * work is a modified version and not the original NCSA Mosaic * + * distributed by the UI. * + * * + * Any Licensee wishing to make commercial use of the Software should * + * contact the UI, c/o NCSA, to negotiate an appropriate license for such * + * commercial use. Commercial use includes (1) integration of all or * + * part of the source code into a product for sale or license by or on * + * behalf of Licensee to third parties, or (2) distribution of the binary * + * code or source code to third parties that need it to utilize a * + * commercial product sold or licensed by or on behalf of Licensee. * + * * + * UI MAKES NO REPRESENTATIONS ABOUT THE SUITABILITY OF THIS SOFTWARE FOR * + * ANY PURPOSE. IT IS PROVIDED "AS IS" WITHOUT EXPRESS OR IMPLIED * + * WARRANTY. THE UI SHALL NOT BE LIABLE FOR ANY DAMAGES SUFFERED BY THE * + * USERS OF THIS SOFTWARE. * + * * + * By using or copying this Software, Licensee agrees to abide by the * + * copyright law and all other applicable laws of the U.S. including, but * + * not limited to, export control laws, and the terms of this license. * + * UI shall have the right to terminate this license immediately by * + * written notice upon Licensee's breach of, or non-compliance with, any * + * of its terms. Licensee may be held legally responsible for any * + * copyright infringement that is caused or encouraged by Licensee's * + * failure to abide by the terms of this license. * + * * + * Comments and questions are welcome and can be sent to * + * mosaic-x@ncsa.uiuc.edu. * + ****************************************************************************/ + +#include <stdio.h> +#include <ctype.h> +#include <string.h> +#ifdef MOTIF +#include <Xm/Xm.h> +#include <Xm/Frame.h> +#include <Xm/DrawingA.h> +#include <Xm/ScrolledW.h> +#include <Xm/Text.h> +#include <Xm/TextF.h> +#include <Xm/ToggleB.h> +#include <Xm/PushB.h> +#include <Xm/RowColumn.h> +#include <Xm/List.h> +#else +#include <X11/Intrinsic.h> +#include <X11/StringDefs.h> +#include <X11/Xaw/Toggle.h> +#include <X11/Xaw/AsciiText.h> +#include <X11/Xaw/List.h> +#include <X11/Xaw/Viewport.h> +#include <X11/Xaw/MenuButton.h> +#include <X11/Xaw/SimpleMenu.h> +#include <X11/Xaw/SmeBSB.h> +#endif /* MOTIF */ +#include "HTMLP.h" + + +#ifdef MOTIF +#define STRING XmString +#else +#define STRING String +#endif /* MOTIF */ + +#define X_NAME "x" +#define Y_NAME "y" + +#define W_TEXTFIELD 0 +#define W_CHECKBOX 1 +#define W_RADIOBOX 2 +#define W_PUSHBUTTON 3 +#define W_PASSWORD 4 +#define W_OPTIONMENU 5 +#define W_TEXTAREA 6 +#define W_LIST 7 +#define W_JOT 8 +#define W_HIDDEN 9 + + +extern void NewJot(); +extern void ClearJot(); +extern void EVJotExpose(); +extern void EVJotPress(); +extern void EVJotMove(); +extern void EVJotRelease(); +extern char *EJB_JOTfromJot(); +extern char *ParseMarkTag(); + + +#ifdef MOTIF +static Boolean ModifyIgnore = False; +#endif /* MOTIF */ + + +char **ParseCommaList(); +void FreeCommaList(); +char *MapOptionReturn(); + + +#ifndef MOTIF +#define FONTHEIGHT(font) (font->max_bounds.ascent + font->max_bounds.descent) + +void +setTextSize(w, columns, lines) + Widget w; + int columns; + int lines; +{ + XFontStruct *font; + Position lm, rm, tm, bm; + int width, height; + + XtVaGetValues(w, XtNfont, &font, + XtNleftMargin, &lm, + XtNrightMargin, &rm, + XtNtopMargin, &tm, + XtNbottomMargin, &bm, + NULL); + width = rm + lm + columns * XTextWidth(font, "0", 1); + height = tm + bm + lines * FONTHEIGHT(font); + XtVaSetValues(w, + XtNwidth, width, + XtNheight, height, + NULL); +} + +void +CBListDestroy(w, client_data, call_data) + Widget w; + caddr_t client_data; + caddr_t call_data; +{ + char **string_list, **p; + int item_count; + + XtVaGetValues(w, + XtNlist, string_list, + XtNnumberStrings, item_count, + NULL); + + p = string_list; + while(item_count > 0) + { + free(*p++); + item_count--; + } + free(string_list); +} + + +void +CBTextDestroy(w, client_data, call_data) + Widget w; + caddr_t client_data; + caddr_t call_data; +{ + char *txt = (char *)client_data; + free(txt); +} + + +void +CBoption(w, client_data, call_data) + Widget w; + caddr_t client_data; + caddr_t call_data; +{ + Widget menuButton = (Widget)client_data; + char *label; + + XtVaGetValues(menuButton, XtNlabel, &label, NULL); + XtVaGetValues(w, XtNlabel, &label, NULL); + XtVaSetValues(menuButton, XtNlabel, label, NULL); +} +#endif /* not MOTIF */ + + +void +AddNewForm(hw, fptr) + HTMLWidget hw; + FormInfo *fptr; +{ + FormInfo *ptr; + + ptr = hw->html.form_list; + if (ptr == NULL) + { + hw->html.form_list = fptr; + fptr->next = NULL; + } + else + { + while (ptr->next != NULL) + { + ptr = ptr->next; + } + ptr->next = fptr; + fptr->next = NULL; + } +} + + +int +CollectSubmitInfo(fptr, name_list, value_list) + FormInfo *fptr; + char ***name_list; + char ***value_list; +{ + HTMLWidget hw = (HTMLWidget)(fptr->hw); + WbFormCallbackData cbdata; + WidgetInfo *wptr; + int cnt; +#ifndef MOTIF + Boolean state; +#endif + + if (fptr->end == -1) /* unterminated FORM tag */ + { + wptr = hw->html.widget_list; + cnt = 0; + while (wptr != NULL) + { + cnt++; + wptr = wptr->next; + } + cbdata.attribute_count = cnt; + } + else + { + cbdata.attribute_count = fptr->end - fptr->start; + } + cbdata.attribute_names = (char **)malloc(cbdata.attribute_count * + sizeof(char *)); + cbdata.attribute_values = (char **)malloc(cbdata.attribute_count * + sizeof(char *)); + + if (fptr->start == 0) + { + wptr = hw->html.widget_list; + } + else + { + wptr = hw->html.widget_list; + while (wptr != NULL) + { + if (wptr->id == fptr->start) + { + wptr = wptr->next; + break; + } + wptr = wptr->next; + } + } + + cnt = 0; + + while ((wptr != NULL)&&(cnt < cbdata.attribute_count)) + { + if ((wptr->name)&&(wptr->type != W_PUSHBUTTON)) + { + Widget child; + STRING *str_list; + int list_cnt; + char *val; +#ifdef MOTIF + STRING label; + Cardinal argcnt; + Arg arg[5]; +#else + XawListReturnStruct *currentSelection; +#endif /* MOTIF */ + + cbdata.attribute_names[cnt] = wptr->name; + switch(wptr->type) + { + case W_TEXTFIELD: +#ifdef MOTIF + cbdata.attribute_values[cnt] = + XmTextFieldGetString(wptr->w); +#else + XtVaGetValues(wptr->w, XtNstring, + &(cbdata.attribute_values[cnt]), + NULL); +#endif /* MOTIF */ + if ((cbdata.attribute_values[cnt] != NULL)&& + (cbdata.attribute_values[cnt][0] == '\0')) + { + cbdata.attribute_values[cnt] = NULL; + } + break; + case W_TEXTAREA: +#ifdef MOTIF + argcnt = 0; + XtSetArg(arg[argcnt], XmNworkWindow, &child); + argcnt++; + XtGetValues(wptr->w, arg, argcnt); + cbdata.attribute_values[cnt] = + XmTextGetString(child); +#else + XtVaGetValues(wptr->w, XtNstring, + &(cbdata.attribute_values[cnt]), + NULL); +#endif /* MOTIF */ + if ((cbdata.attribute_values[cnt] != NULL)&& + (cbdata.attribute_values[cnt][0] == '\0')) + { + cbdata.attribute_values[cnt] = NULL; + } + break; + case W_PASSWORD: + cbdata.attribute_values[cnt] = wptr->password; + if ((cbdata.attribute_values[cnt] != NULL)&& + (cbdata.attribute_values[cnt][0] == '\0')) + { + cbdata.attribute_values[cnt] = NULL; + } + break; + case W_LIST: + /* + * First get the Widget ID of the proper + * list element + */ +#ifdef MOTIF + argcnt = 0; + XtSetArg(arg[argcnt], XmNworkWindow, &child); + argcnt++; + XtGetValues(wptr->w, arg, argcnt); +#else + { + WidgetList wl; + XtVaGetValues(wptr->w, XtNchildren, + &wl, NULL); + child = *++wl; + } +#endif /* MOTIF */ + + /* + * Now get the list of selected items. + */ +#ifdef MOTIF + argcnt = 0; + XtSetArg(arg[argcnt], XmNselectedItemCount, + &list_cnt); + argcnt++; + XtSetArg(arg[argcnt], XmNselectedItems, + &str_list); + argcnt++; + XtGetValues(child, arg, argcnt); +#else + currentSelection = XawListShowCurrent(child); + list_cnt = + currentSelection->list_index == XAW_LIST_NONE? + 0 : 1; + str_list = &(currentSelection->string); +#endif /* MOTIF */ + + if (list_cnt == 0) + { + cnt--; + cbdata.attribute_count--; + } + else /* list_cnt >= 1 */ + { + int j, new_cnt; + char **names; + char **values; + + if (list_cnt > 1) + { + new_cnt = cbdata.attribute_count + + list_cnt - 1; + names = (char **)malloc(new_cnt * + sizeof(char *)); + values = (char **)malloc(new_cnt * + sizeof(char *)); + for (j=0; j<cnt; j++) + { + names[j] = + cbdata.attribute_names[j]; + values[j] = + cbdata.attribute_values[j]; + } + free((char *) + cbdata.attribute_names); + free((char *) + cbdata.attribute_values); + cbdata.attribute_names = names; + cbdata.attribute_values = values; + cbdata.attribute_count = new_cnt; + } + + for (j=0; j<list_cnt; j++) + { + cbdata.attribute_names[cnt + j] + = wptr->name; +#ifdef MOTIF + XmStringGetLtoR(str_list[j], + XmSTRING_DEFAULT_CHARSET, + &val); +#else + val = str_list[j]; +#endif /* MOTIF */ + if ((val != NULL)&& + (val[0] == '\0')) + { + val = NULL; + } + else if (val != NULL) + { + val = MapOptionReturn( + val, + wptr->mapping); + } + cbdata.attribute_values[cnt + j] + = val; + } + cnt = cnt + list_cnt - 1; + } + break; + /* + * For an option menu, first get the label gadget + * which holds the current value. + * Now get the text from that label as a character + * string. + */ + case W_OPTIONMENU: +#ifdef MOTIF + child = XmOptionButtonGadget(wptr->w); + argcnt = 0; + XtSetArg(arg[argcnt], XmNlabelString, &label); + argcnt++; + XtGetValues(child, arg, argcnt); + val = NULL; + XmStringGetLtoR(label, XmSTRING_DEFAULT_CHARSET, + &val); +#else + XtVaGetValues(wptr->w, XtNlabel, &val, NULL); +#endif /* MOTIF */ + if ((val != NULL)&&(val[0] == '\0')) + { + val = NULL; + } + else if (val != NULL) + { + val = MapOptionReturn(val, + wptr->mapping); + } + cbdata.attribute_values[cnt] = val; + if ((cbdata.attribute_values[cnt] != NULL)&& + (cbdata.attribute_values[cnt][0] == '\0')) + { + cbdata.attribute_values[cnt] = NULL; + } + break; + case W_CHECKBOX: + case W_RADIOBOX: +#ifdef MOTIF + if (XmToggleButtonGetState(wptr->w) == True) +#else + XtVaGetValues(wptr->w, XtNstate, &state, NULL); + if (state) +#endif /* MOTIF */ + { + cbdata.attribute_values[cnt] = wptr->value; + } + else + { + cnt--; + cbdata.attribute_count--; + } + break; + case W_HIDDEN: + cbdata.attribute_values[cnt] = wptr->value; + break; +#ifdef MOTIF + case W_JOT: + argcnt = 0; + XtSetArg(arg[argcnt], XmNuserData, + (XtPointer *)&child); + argcnt++; + XtGetValues(wptr->w, arg, argcnt); + cbdata.attribute_values[cnt] = + EJB_JOTfromJot(child); + break; +#endif /* MOTIF */ + default: + cbdata.attribute_values[cnt] = NULL; + break; + } + cnt++; + } + else + { + cbdata.attribute_count--; + } + wptr = wptr->next; + } + cbdata.attribute_count = cnt; + + *name_list = cbdata.attribute_names; + *value_list = cbdata.attribute_values; + return(cbdata.attribute_count); +} + + +void +ImageSubmitForm(fptr, event, name, x, y) + FormInfo *fptr; + XEvent *event; + char *name; + int x, y; +{ + HTMLWidget hw = (HTMLWidget)(fptr->hw); + WbFormCallbackData cbdata; + int i, cnt; + char **name_list; + char **value_list; + char valstr[100]; + + cbdata.event = event; + cbdata.href = fptr->action; + cbdata.method = fptr->method; + cbdata.enctype = fptr->enctype; + cbdata.enc_entity = fptr->enc_entity; + + name_list = NULL; + value_list = NULL; + cnt = CollectSubmitInfo(fptr, &name_list, &value_list); + + cbdata.attribute_count = cnt + 2; + cbdata.attribute_names = (char **)malloc(cbdata.attribute_count * + sizeof(char *)); + cbdata.attribute_values = (char **)malloc(cbdata.attribute_count * + sizeof(char *)); + for (i=0; i<cnt; i++) + { + cbdata.attribute_names[i] = name_list[i]; + cbdata.attribute_values[i] = value_list[i]; + } + if (name_list != NULL) + { + free((char *)name_list); + } + if (value_list != NULL) + { + free((char *)value_list); + } + + if ((name != NULL)&&(name[0] != '\0')) + { + cbdata.attribute_names[cnt] = (char *)malloc(strlen(name) + + strlen(X_NAME) + 2); + strcpy(cbdata.attribute_names[cnt], name); + strcat(cbdata.attribute_names[cnt], "."); + strcat(cbdata.attribute_names[cnt], X_NAME); + } + else + { + cbdata.attribute_names[cnt] = (char *)malloc(strlen(X_NAME) +1); + strcpy(cbdata.attribute_names[cnt], X_NAME); + } + sprintf(valstr, "%d", x); + cbdata.attribute_values[cnt] = (char *)malloc(strlen(valstr) + 1); + strcpy(cbdata.attribute_values[cnt], valstr); + + cnt++; + if ((name != NULL)&&(name[0] != '\0')) + { + cbdata.attribute_names[cnt] = (char *)malloc(strlen(name) + + strlen(Y_NAME) + 2); + strcpy(cbdata.attribute_names[cnt], name); + strcat(cbdata.attribute_names[cnt], "."); + strcat(cbdata.attribute_names[cnt], Y_NAME); + } + else + { + cbdata.attribute_names[cnt] = (char *)malloc(strlen(Y_NAME) +1); + strcpy(cbdata.attribute_names[cnt], Y_NAME); + } + sprintf(valstr, "%d", y); + cbdata.attribute_values[cnt] = (char *)malloc(strlen(valstr) + 1); + strcpy(cbdata.attribute_values[cnt], valstr); + + XtCallCallbackList ((Widget)hw, hw->html.form_callback, + (XtPointer)&cbdata); +} + + +void +CBSubmitForm(w, client_data, call_data) + Widget w; + caddr_t client_data; + caddr_t call_data; +{ + FormInfo *fptr = (FormInfo *)client_data; + HTMLWidget hw = (HTMLWidget)(fptr->hw); + WbFormCallbackData cbdata; +#ifdef MOTIF + XmPushButtonCallbackStruct *pb = + (XmPushButtonCallbackStruct *)call_data; +#endif /* MOTIF */ + +#ifdef MOTIF + cbdata.event = pb->event; +#else + /******* WE HAVE NO EVENT in ATHENA *******/ + cbdata.event = NULL; +#endif /* MOTIF */ + cbdata.href = fptr->action; + cbdata.method = fptr->method; + cbdata.enctype = fptr->enctype; + cbdata.enc_entity = fptr->enc_entity; + + cbdata.attribute_count = CollectSubmitInfo(fptr, + &cbdata.attribute_names, &cbdata.attribute_values); + + XtCallCallbackList ((Widget)hw, hw->html.form_callback, + (XtPointer)&cbdata); +} + + +/* + * A radio buttom was toggled on in a form. + * If there are other radios of the same name, turn them off. + */ +void +CBChangeRadio(w, client_data, call_data) + Widget w; + caddr_t client_data; + caddr_t call_data; +{ + FormInfo *fptr = (FormInfo *)client_data; + HTMLWidget hw = (HTMLWidget)(fptr->hw); + WidgetInfo *wptr; + WidgetInfo *wtmp; + char *name; + int cnt, count; +#ifdef MOTIF + XmToggleButtonCallbackStruct *tb = + (XmToggleButtonCallbackStruct *)call_data; +#else + Boolean state; +#endif /* MOTIF */ + +#ifdef MOTIF + /* + * Bad button + */ + if (tb == NULL) + { + return; + } +#endif /* MOTIF */ + + /* + * Only do stuff when the button is turned on. + * Don't let the button be turned off, by clicking on + * it, as that would leave all buttons off. + */ +#ifdef MOTIF + if ((tb == NULL)||(tb->set == False)) + { + XmToggleButtonSetState(w, True, False); + return; + } +#else + XtVaGetValues(w, XtNstate, &state, NULL); + if (!state) + { + XtVaSetValues(w, XtNstate, 1, NULL); + return; + } +#endif /* MOTIF */ + + /* + * Terminate the form if it was never properly terminated. + */ + if (fptr->end == -1) /* unterminated FORM tag */ + { + wptr = hw->html.widget_list; + cnt = 0; + while (wptr != NULL) + { + cnt++; + wptr = wptr->next; + } + count = cnt; + } + else + { + count = fptr->end - fptr->start; + } + + /* + * Locate the start of the form. + */ + if (fptr->start == 0) + { + wptr = hw->html.widget_list; + } + else + { + wptr = hw->html.widget_list; + while (wptr != NULL) + { + if (wptr->id == fptr->start) + { + wptr = wptr->next; + break; + } + wptr = wptr->next; + } + } + + /* + * Find the name of the toggle button just pressed. + */ + name = NULL; + wtmp = wptr; + while (wtmp != NULL) + { + if (wtmp->w == w) + { + name = wtmp->name; + break; + } + wtmp = wtmp->next; + } + + /* + * Check for other checked radioboxes of the same name. + */ + cnt = 0; + while ((wptr != NULL)&&(cnt < count)) + { +#ifdef MOTIF + if ((wptr->type == W_RADIOBOX)&& + (wptr->w != w)&& + (XmToggleButtonGetState(wptr->w) == True)&& + (wptr->name != NULL)&& + (name != NULL)&& + (strcmp(wptr->name, name) == 0)) + { + XmToggleButtonSetState(wptr->w, False, False); + } +#else + if ((wptr->type == W_RADIOBOX)&& + (wptr->w != w)&& + (wptr->name != NULL)&& + (name != NULL)&& + (strcmp(wptr->name, name) == 0)) + { + XtVaGetValues(wptr->w, XtNstate, &state, NULL); + if (state) + { + XtVaSetValues(wptr->w, XtNstate, 0, NULL); + } + } +#endif /* MOTIF */ + cnt++; + wptr = wptr->next; + } +} + + +#ifdef MOTIF +/* + * Catch all attempted modifications to the textfield for password + * entry. This is so we can prevent the password from showing + * uponm the screen. + * I would prefer that for all insereted characters a random 1-3 '*'s + * were added, and any delete deleted the whole string, but due to + * bugs in somve version of Motif 1.1 this won't work. + */ +void +CBPasswordModify(w, client_data, call_data) + Widget w; + caddr_t client_data; + caddr_t call_data; +{ + FormInfo *fptr = (FormInfo *)client_data; + XmTextVerifyCallbackStruct *tv =(XmTextVerifyCallbackStruct *)call_data; + HTMLWidget hw = (HTMLWidget)(fptr->hw); + WidgetInfo *wptr; + int i, len; + + /* + * by default accept nothing + tv->doit = False; + */ + + /* + * Ignore when ModifyIgnore is true + */ + if (ModifyIgnore == True) + { + return; + } + + /* + * only accept text modification of password fields + */ + if (tv->reason != XmCR_MODIFYING_TEXT_VALUE) + { + return; + } + + /* + * find the structure for this widget + */ + wptr = hw->html.widget_list; + while (wptr != NULL) + { + if (wptr->w == w) + { + break; + } + wptr = wptr->next; + } + if (wptr == NULL) + { + return; + } + + /* + * Deletion. + */ + if (tv->text->ptr == NULL) + { + tv->doit = True; + + /* + * Only can delete if we have stuff to delete. + */ + if ((wptr->password != NULL)&&(wptr->password[0] != '\0')) + { + int start; + char *tptr; + + len = strlen(wptr->password); + /* + * Find the start of the chunk of text to + * delete. + */ + if (tv->startPos < len) + { + start = tv->startPos; + } + else + { + start = len - 1; + } + + /* + * might be more stuff after the end that we + * want to move up + */ + if (tv->endPos > len) + { + tptr = &(wptr->password[len]); + } + else + { + tptr = &(wptr->password[tv->endPos]); + } + wptr->password[start] = '\0'; + strcat(wptr->password, tptr); + } + } + /* + * Else insert character. + */ + else if (tv->text->length >= 1) + { + int maxlength, plen; + Cardinal argcnt; + Arg arg[5]; + + /* + * No insertion if it makes you exceed maxLength + */ + if (wptr->password == NULL) + { + plen = 0; + } + else + { + plen = strlen(wptr->password); + } + maxlength = 1000000; + argcnt = 0; + XtSetArg(arg[argcnt], XmNmaxLength, &maxlength); argcnt++; + XtGetValues(w, arg, argcnt); + if ((plen + tv->text->length) > maxlength) + { + return; + } + + if (wptr->password == NULL) + { + wptr->password = (char *)malloc(tv->text->length + 1); + for (i=0; i < tv->text->length; i++) + { + wptr->password[i] = tv->text->ptr[i]; + } + wptr->password[tv->text->length] = '\0'; + } + /* + * else insert a char somewhere. + * Make a new buffer. Put everything from before the insert + * postion into it. Now insert the character. + * Finally append any remaining text. + */ + else + { + char *buf; + char *tptr; + char tchar; + int start; + + len = strlen(wptr->password); + if (tv->startPos < len) + { + start = tv->startPos; + } + else + { + start = len; + } + tptr = &(wptr->password[start]); + tchar = *tptr; + *tptr = '\0'; + buf = (char *)malloc(len + tv->text->length + 1); + strcpy(buf, wptr->password); + for (i=0; i < tv->text->length; i++) + { + buf[start + i] = tv->text->ptr[i]; + } + buf[start + tv->text->length] = '\0'; + *tptr = tchar; + strcat(buf, tptr); + free(wptr->password); + wptr->password = buf; + } + + tv->doit = True; + /* + * make a '*' show up instead of what they typed + */ + for (i=0; i < tv->text->length; i++) + { + tv->text->ptr[i] = '*'; + } + } +} +#endif /* MOTIF */ + + + +/* + * RETURN was hit in a textfield in a form. + * If this is the only textfield in this form, submit the form. + */ +void +CBActivateField(w, client_data, call_data) + Widget w; + caddr_t client_data; + caddr_t call_data; +{ + FormInfo *fptr = (FormInfo *)client_data; + HTMLWidget hw = (HTMLWidget)(fptr->hw); + WidgetInfo *wptr; + int cnt, count; +#ifdef MOTIF + XmAnyCallbackStruct *cb = (XmAnyCallbackStruct *)call_data; +#endif /* MOTIF */ + + /* + * Terminate the form if it was never properly terminated. + */ + if (fptr->end == -1) /* unterminated FORM tag */ + { + wptr = hw->html.widget_list; + cnt = 0; + while (wptr != NULL) + { + cnt++; + wptr = wptr->next; + } + count = cnt; + } + else + { + count = fptr->end - fptr->start; + } + + /* + * Locate the start of the form. + */ + if (fptr->start == 0) + { + wptr = hw->html.widget_list; + } + else + { + wptr = hw->html.widget_list; + while (wptr != NULL) + { + if (wptr->id == fptr->start) + { + wptr = wptr->next; + break; + } + wptr = wptr->next; + } + } + + /* + * Count the textfields in this form. + */ + cnt = 0; + while ((wptr != NULL)&&(cnt < count)) + { + if ((wptr->type == W_TEXTFIELD)||(wptr->type == W_PASSWORD)) + { + cnt++; + } + wptr = wptr->next; + } + + /* + * If this is the only textfield in this form, submit the form. + */ + if (cnt == 1) + { + CBSubmitForm(w, client_data, call_data); + } +} + + +void +CBResetForm(w, client_data, call_data) + Widget w; + caddr_t client_data; + caddr_t call_data; +{ + FormInfo *fptr = (FormInfo *)client_data; + HTMLWidget hw = (HTMLWidget)(fptr->hw); + WidgetInfo *wptr; + int widget_count, cnt; +#ifdef MOTIF + XmPushButtonCallbackStruct *pb = + (XmPushButtonCallbackStruct *)call_data; +#endif /* MOTIF */ + + if (fptr->end == -1) /* unterminated FORM tag */ + { + wptr = hw->html.widget_list; + cnt = 0; + while (wptr != NULL) + { + cnt++; + wptr = wptr->next; + } + widget_count = cnt; + } + else + { + widget_count = fptr->end - fptr->start; + } + + if (fptr->start == 0) + { + wptr = hw->html.widget_list; + } + else + { + wptr = hw->html.widget_list; + while (wptr != NULL) + { + if (wptr->id == fptr->start) + { + wptr = wptr->next; + break; + } + wptr = wptr->next; + } + } + + cnt = 0; + while ((wptr != NULL)&&(cnt < widget_count)) + { + Widget child; + STRING label; +#ifdef MOTIF + Cardinal argcnt; + Arg arg[5]; +#else + char *txt = NULL; + int length = 0; + Boolean stringInPlace; +#endif /* MOTIF */ + + switch(wptr->type) + { + case W_TEXTFIELD: +#ifdef MOTIF + if (wptr->value == NULL) + { + XmTextFieldSetString(wptr->w, ""); + } + else + { + XmTextFieldSetString(wptr->w, wptr->value); + } +#else + XtVaGetValues(wptr->w, + XtNuseStringInPlace, &stringInPlace, + XtNlength, &length, + NULL); + if (stringInPlace) + { + XtVaGetValues(wptr->w, + XtNstring, &txt, + NULL); + } + if (wptr->value == NULL) + { + if (stringInPlace) + { + if (txt) *txt = '\0'; + XtVaSetValues(wptr->w, + XtNstring, txt, NULL); + } + else + { + XtVaSetValues(wptr->w, + XtNstring, "", NULL); + } + } + else + { + if (stringInPlace) + { + strncpy(txt,wptr->value,length); + XtVaSetValues(wptr->w, + XtNstring, txt, NULL); + } + else + { + XtVaSetValues(wptr->w, + XtNstring, wptr->value, + NULL); + } + } +#endif /* MOTIF */ + break; + case W_TEXTAREA: +#ifdef MOTIF + argcnt = 0; + XtSetArg(arg[argcnt], XmNworkWindow, &child); + argcnt++; + XtGetValues(wptr->w, arg, argcnt); + if (wptr->value == NULL) + { + XmTextSetString(child, ""); + } + else + { + XmTextSetString(child, wptr->value); + } +#else + XtVaSetValues(wptr->w, XtNstring, + wptr->value ? wptr->value : "", + NULL); +#endif /* MOTIF */ + break; + case W_PASSWORD: + if (wptr->value == NULL) + { +#ifdef MOTIF + /* + * Due to errors in Motif1.1, I can't + * call XmTextFieldSetString() here. + * Because I have a modifyVerify callback + * registered for this widget. + * I don't know if this error exists + * in Motif1.2 or not. + */ + argcnt = 0; + XtSetArg(arg[argcnt], XmNvalue, ""); + argcnt++; + XtSetValues(wptr->w, arg, argcnt); +#else + XtVaSetValues(wptr->w, + XtNstring, "", NULL); +#endif /* MOTIF */ + if (wptr->password != NULL) + { + free(wptr->password); + wptr->password = NULL; + } + } + else + { + int i, len; + + if (wptr->password != NULL) + { + free(wptr->password); + wptr->password = NULL; + } + len = strlen(wptr->value); + wptr->password = (char *)malloc(len + 1); + for (i=0; i<len; i++) + { + wptr->password[i] = '*'; + } + wptr->password[len] = '\0'; +#ifdef MOTIF + XmTextFieldSetString(wptr->w, + wptr->password); +#else + XtVaSetValues(wptr->w, + XtNstring, wptr->password, + NULL); +#endif /* MOTIF */ + strcpy(wptr->password, wptr->value); + } + break; + case W_LIST: + { + char **vlist; + int vlist_cnt; + STRING *val_list; + int i; + +#ifdef MOTIF + argcnt = 0; + XtSetArg(arg[argcnt], XmNworkWindow, &child); + argcnt++; + XtGetValues(wptr->w, arg, argcnt); +#else + WidgetList wl; + char **string_list; + int list_cnt; + + XtVaGetValues(wptr->w, XtNchildren, &wl, NULL); + child = *++wl; + XtVaGetValues(child, + XtNlist, &string_list, + XtNnumberStrings, &list_cnt, NULL); +#endif /* MOTIF */ + + if (wptr->value != NULL) + { + vlist = ParseCommaList(wptr->value, + &vlist_cnt); + val_list = (STRING *)malloc(vlist_cnt * + sizeof(STRING)); +#ifdef MOTIF + XmListDeselectAllItems(child); + for (i=0; i<vlist_cnt; i++) + { + val_list[i] = + XmStringCreateSimple(vlist[i]); + } +#else + XawListUnhighlight(child); + for (i=0; i<vlist_cnt; i++) + { + val_list[i] = + XtNewString(vlist[i]); + } +#endif /* MOTIF */ + FreeCommaList(vlist, vlist_cnt); +#ifdef MOTIF + if (vlist_cnt > 0) + { + argcnt = 0; + XtSetArg(arg[argcnt], XmNselectedItems, + val_list); + argcnt++; + XtSetArg(arg[argcnt], + XmNselectedItemCount, + vlist_cnt); + argcnt++; + XtSetValues(child, arg, argcnt); + } + for (i=0; i<vlist_cnt; i++) + { + XmStringFree(val_list[i]); + } +#else + if (vlist_cnt > 0) + { + if (vlist_cnt > 1) + { + fprintf(stderr, + "HTML: only a single selection allowed!\n"); + } + + for (i=0; i<list_cnt; i++) + { + if (!strcmp(string_list[i], + val_list[0])) + { + XawListHighlight(child, i); + break; + } + } + } + for (i=0; i<vlist_cnt; i++) + { + free(val_list[i]); + } +#endif /* MOTIF */ + if (val_list != NULL) + { + free((char *)val_list); + } + } + else + { +#ifdef MOTIF + XmListDeselectAllItems(child); +#else + XawListUnhighlight(child); +#endif /* MOTIF */ + } + } + break; + /* + * gack, we saved the widget id of the starting default + * into the value character pointer, just so we could + * yank it out here, and restore the default. + */ + case W_OPTIONMENU: + if (wptr->value != NULL) + { + Widget hist = (Widget)wptr->value; +#ifdef MOTIF + Cardinal argcnt; + Arg arg[5]; + + argcnt = 0; + XtSetArg(arg[argcnt], XmNmenuHistory, + hist); + argcnt++; + XtSetValues(wptr->w, arg, argcnt); +#else + char *txt; + + XtVaGetValues(hist, XtNlabel,&txt,NULL); + XtVaSetValues(wptr->w,XtNlabel,txt,NULL); +#endif /* MOTIF */ + } + break; + case W_CHECKBOX: + case W_RADIOBOX: +#ifdef MOTIF + if (wptr->checked == True) + { + XmToggleButtonSetState(wptr->w, True, False); + } + else + { + XmToggleButtonSetState(wptr->w, False, False); + } +#else + XtVaSetValues(wptr->w, + XtNstate, wptr->checked, NULL); +#endif /* MOTIF */ + break; + case W_HIDDEN: + break; +#ifdef MOTIF + case W_JOT: + argcnt = 0; + XtSetArg(arg[argcnt], XmNuserData, + (XtPointer *)&child); + argcnt++; + XtGetValues(wptr->w, arg, argcnt); + ClearJot(hw, child, wptr->width, wptr->height); + break; +#endif /* MOTIF */ + default: + break; + } + cnt++; + wptr = wptr->next; + } +} + + +void +PrepareFormEnd(hw, w, fptr) + HTMLWidget hw; + Widget w; + FormInfo *fptr; +{ +#ifdef MOTIF + XtAddCallback(w, XmNactivateCallback, + (XtCallbackProc)CBSubmitForm, (caddr_t)fptr); +#else + XtAddCallback(w, XtNcallback, + (XtCallbackProc)CBSubmitForm, (caddr_t)fptr); +#endif /* MOTIF */ +} + + +void +PrepareFormReset(hw, w, fptr) + HTMLWidget hw; + Widget w; + FormInfo *fptr; +{ +#ifdef MOTIF + XtAddCallback(w, XmNactivateCallback, + (XtCallbackProc)CBResetForm, (caddr_t)fptr); +#else + XtAddCallback(w, XtNcallback, + (XtCallbackProc)CBResetForm, (caddr_t)fptr); +#endif /* MOTIF */ +} + + +void +HideWidgets(hw) + HTMLWidget hw; +{ + WidgetInfo *wptr; + XEvent event; + +#ifdef MOTIF + /* + * Make sure all expose events have been dealt with first. + */ + XmUpdateDisplay((Widget)hw); +#endif /* MOTIF */ + + wptr = hw->html.widget_list; + while (wptr != NULL) + { + if ((wptr->w != NULL)&&(wptr->mapped == True)) + { + XtSetMappedWhenManaged(wptr->w, False); + wptr->mapped = False; + } + wptr = wptr->next; + } + + /* + * Force the exposure events into the queue + */ + XSync(XtDisplay(hw), False); + + /* + * Remove all Expose events for the view window + */ + while (XCheckWindowEvent(XtDisplay(hw->html.view), + XtWindow(hw->html.view), ExposureMask, &event) == True) + { + } +} + + +void +MapWidgets(hw) + HTMLWidget hw; +{ + WidgetInfo *wptr; + + wptr = hw->html.widget_list; + while (wptr != NULL) + { + if ((wptr->w != NULL)&&(wptr->mapped == False)) + { + wptr->mapped = True; + XtSetMappedWhenManaged(wptr->w, True); + } + wptr = wptr->next; + } +} + + +Boolean +AlreadyChecked(hw, fptr, name) + HTMLWidget hw; + FormInfo *fptr; + char *name; +{ + WidgetInfo *wptr; + Boolean radio_checked; + + radio_checked = False; + wptr = hw->html.widget_list; + while (wptr != NULL) + { + if ((wptr->id >= fptr->start)&& + (wptr->type == W_RADIOBOX)&& + (wptr->checked == True)&& + (wptr->name != NULL)&& + (name != NULL)&& + (strcmp(wptr->name, name) == 0)) + { + radio_checked = True; + break; + } + wptr = wptr->next; + } + return(radio_checked); +} + + +WidgetInfo * +AddNewWidget(hw, fptr, w, type, id, x, y, width, height, name, value, mapping, checked) + HTMLWidget hw; + FormInfo *fptr; + Widget w; + int type; + int id; + int x, y; + int width, height; + char *name; + char *value; + char **mapping; + Boolean checked; +{ + WidgetInfo *wptr; + + wptr = hw->html.widget_list; + if (wptr == NULL) + { + wptr = (WidgetInfo *)malloc(sizeof(WidgetInfo)); + wptr->w = w; + wptr->type = type; + wptr->id = id; + wptr->x = x; + wptr->y = y; + wptr->width = width; + wptr->height = height; + wptr->name = name; + wptr->value = value; + wptr->password = NULL; + wptr->mapping = mapping; + wptr->checked = checked; + wptr->mapped = False; + wptr->next = NULL; + hw->html.widget_list = wptr; + } + else + { + while (wptr->next != NULL) + { + wptr = wptr->next; + } + wptr->next = (WidgetInfo *)malloc(sizeof(WidgetInfo)); + wptr = wptr->next; + wptr->w = w; + wptr->type = type; + wptr->id = id; + wptr->x = x; + wptr->y = y; + wptr->width = width; + wptr->height = height; + wptr->name = name; + wptr->value = value; + wptr->password = NULL; + wptr->mapping = mapping; + wptr->checked = checked; + wptr->mapped = False; + wptr->next = NULL; + } + + if ((wptr->type == W_PASSWORD)&&(wptr->value != NULL)) + { + wptr->password = (char *)malloc(strlen(wptr->value) + 1); + strcpy(wptr->password, wptr->value); + } + + return(wptr); +} + + +/* + * For the various widgets, return their fon structures so + * we can use the font's baseline to place them. + */ +XFontStruct * +GetWidgetFont(hw, wptr) + HTMLWidget hw; + WidgetInfo *wptr; +{ + Widget child; + XFontStruct *font; +#ifdef MOTIF + Boolean ret; + Cardinal argcnt; + Arg arg[5]; + XmFontList font_list = (XmFontList)NULL; + XmFontContext font_context; + XmStringCharSet charset; +#endif /* MOTIF */ + + /* + * For option menus we have to first get the child that has the + * font info. + */ + if (wptr->type == W_OPTIONMENU) + { +#ifdef MOTIF + child = XmOptionButtonGadget(wptr->w); + + argcnt = 0; + XtSetArg(arg[argcnt], XmNfontList, &font_list); argcnt++; + XtGetValues(child, arg, argcnt); +#else + XtVaGetValues(wptr->w, XtNfont, &font, NULL); +#endif /* MOTIF */ + } + else + { +#ifdef MOTIF + if ((wptr->type == W_TEXTAREA)||(wptr->type == W_LIST)) + { + child = NULL; + argcnt = 0; + XtSetArg(arg[argcnt], XmNworkWindow, &child); argcnt++; + XtGetValues(wptr->w, arg, argcnt); + argcnt = 0; + XtSetArg(arg[argcnt], XmNfontList,&font_list); argcnt++; + XtGetValues(child, arg, argcnt); + } +#else + if (wptr->type == W_LIST) + { + WidgetList wl; + int nc; + XtVaGetValues(wptr->w, + XtNchildren, &wl, XtNnumChildren, &nc, NULL); + child = *++wl; + XtVaGetValues(child, XtNfont, &font, NULL); + } +#endif /* MOTIF */ + else + { +#ifdef MOTIF + argcnt = 0; + XtSetArg(arg[argcnt], XmNfontList,&font_list); argcnt++; + XtGetValues(wptr->w, arg, argcnt); +#else + XtVaGetValues(wptr->w, XtNfont, &font, NULL); +#endif /* MOTIF */ + } + } + +#ifdef MOTIF + if (font_list == (XmFontList)NULL) + { + return((XFontStruct *)NULL); + } + + ret = XmFontListInitFontContext(&font_context, font_list); + if (ret == False) + { + return((XFontStruct *)NULL); + } + + ret = XmFontListGetNextFont(font_context, &charset, &font); + if (ret == False) + { + return((XFontStruct *)NULL); + } + else + { + XmFontListFreeFontContext(font_context); + free((char *)charset); + return(font); + } +#else + return(font); +#endif /* MOTIF */ +} + + +/* + * Get the next value in a comma separated list. + * Also unescape the '\' escaping done in ComposeCommaList + * and convert the single ''' characters back to '"' + * characters + */ +char * +NextComma(string) + char *string; +{ + char *tptr; + + tptr = string; + while (*tptr != '\0') + { + if (*tptr == '\\') + { + *tptr = '\0'; + strcat(string, (char *)(tptr + 1)); + tptr++; + } + else if (*tptr == '\'') + { + *tptr = '\"'; + tptr++; + } + else if (*tptr == ',') + { + return(tptr); + } + else + { + tptr++; + } + } + return(tptr); +} + + +char ** +ParseCommaList(str, count) + char *str; + int *count; +{ + char *str_copy; + char **list; + char **tlist; + char *tptr; + char *val; + int i, cnt; + int max_cnt; + + *count = 0; + if ((str == NULL)||(*str == '\0')) + { + return((char **)NULL); + } + str_copy = (char *)malloc(strlen(str) + 1); + if (str_copy == NULL) + { + return((char **)NULL); + } + strcpy(str_copy, str); + + list = (char **)malloc(50 * sizeof(char *)); + if (list == NULL) + { + return((char **)NULL); + } + max_cnt = 50; + + /* + * This loop counts the number of objects + * in this list. + * As a side effect, NextComma() unescapes in place so + * "\\" becomes '\' and "\," becomes ',' and "\"" becomes '"' + */ + cnt = 0; + val = str_copy; + tptr = NextComma(val); + while (*tptr != '\0') + { + if ((cnt + 1) == max_cnt) + { + tlist = (char **)malloc((max_cnt +50) * sizeof(char *)); + if (tlist == NULL) + { + return((char **)NULL); + } + for (i=0; i<cnt; i++) + { + tlist[i] = list[i]; + } + free((char *)list); + list = tlist; + max_cnt += 50; + } + *tptr = '\0'; + list[cnt] = (char *)malloc(strlen(val) + 1); + if (list[cnt] == NULL) + { + return((char **)NULL); + } + strcpy(list[cnt], val); + cnt++; + + val = (char *)(tptr + 1); + tptr = NextComma(val); + } + list[cnt] = (char *)malloc(strlen(val) + 1); + if (list[cnt] == NULL) + { + return((char **)NULL); + } + strcpy(list[cnt], val); + cnt++; + + free(str_copy); + tlist = (char **)malloc(cnt * sizeof(char *)); + if (tlist == NULL) + { + return((char **)NULL); + } + for (i=0; i<cnt; i++) + { + tlist[i] = list[i]; + } + free((char *)list); + list = tlist; + + *count = cnt; + return(list); +} + + +/* + * Compose a single string comma separated list from + * an array of strings. Any '\', or ',' in the + * list are escaped with a prepending '\'. + * So they become '\\' and '\,' + * Also we want to allow '"' characters in the list, but + * they would get eaten by the later parsing code, so we will + * turn '"' into ''', and turn ''' into '\'' + */ +char * +ComposeCommaList(list, cnt) + char **list; + int cnt; +{ + int i; + char *fail; + char *buf; + char *tbuf; + int len, max_len; + + fail = (char *)malloc(1); + *fail = '\0'; + + if (cnt == 0) + { + return(fail); + } + + buf = (char *)malloc(1024); + if (buf == NULL) + { + return(fail); + } + max_len = 1024; + len = 0; + buf[0] = '\0'; + + for (i=0; i<cnt; i++) + { + char *option; + char *tptr; + int olen; + + option = list[i]; + if (option == NULL) + { + olen = 0; + } + else + { + olen = strlen(option); + } + if ((len + (olen * 2)) >= max_len) + { + tbuf = (char *)malloc(max_len + olen + 1024); + if (tbuf == NULL) + { + return(fail); + } + strcpy(tbuf, buf); + free(buf); + buf = tbuf; + max_len = max_len + olen + 1024; + } + tptr = (char *)(buf + len); + while ((option != NULL)&&(*option != '\0')) + { + if ((*option == '\\')||(*option == ',')|| + (*option == '\'')) + { + *tptr++ = '\\'; + *tptr++ = *option++; + len += 2; + } + else if (*option == '\"') + { + *tptr++ = '\''; + option++; + len++; + } + else + { + *tptr++ = *option++; + len++; + } + } + if (i != (cnt - 1)) + { + *tptr++ = ','; + len++; + } + *tptr = '\0'; + } + + tbuf = (char *)malloc(len + 1); + if (tbuf == NULL) + { + return(fail); + } + strcpy(tbuf, buf); + free(buf); + buf = tbuf; + free(fail); + return(buf); +} + + +void +FreeCommaList(list, cnt) + char **list; + int cnt; +{ + int i; + + for (i=0; i<cnt; i++) + { + if (list[i] != NULL) + { + free(list[i]); + } + } + if (list != NULL) + { + free((char *)list); + } +} + + +/* + * Clean up the mucked value field for a TEXTAREA. + * Unescape the things with '\' in front of them, and transform + * lone ' back to " + */ +void +UnMuckTextAreaValue(value) + char *value; +{ + char *tptr; + + if ((value == NULL)||(value[0] == '\0')) + { + return; + } + + tptr = value; + while (*tptr != '\0') + { + if (*tptr == '\\') + { + *tptr = '\0'; + strcat(value, (char *)(tptr + 1)); + tptr++; + } + else if (*tptr == '\'') + { + *tptr = '\"'; + tptr++; + } + else + { + tptr++; + } + } +} + + +char * +MapOptionReturn(val, mapping) + char *val; + char **mapping; +{ + int cnt; + + if (mapping == NULL) + { + return(val); + } + + cnt = 0; + while (mapping[cnt] != NULL) + { + if (strcmp(mapping[cnt], val) == 0) + { + return(mapping[cnt + 1]); + } + cnt += 2; + } + return(val); +} + + +char ** +MakeOptionMappings(list1, list2, list_cnt) + char **list1; + char **list2; + int list_cnt; +{ + int i, cnt; + char **list; + + /* + * pass through to see how many mappings we have. + */ + cnt = 0; + for (i=0; i<list_cnt; i++) + { + if ((list2[i] != NULL)&&(*list2[i] != '\0')) + { + cnt++; + } + } + + if (cnt == 0) + { + return(NULL); + } + + list = (char **)malloc(((2 * cnt) + 1) * sizeof(char *)); + if (list == NULL) + { + return(NULL); + } + + cnt = 0; + for (i=0; i<list_cnt; i++) + { + if ((list2[i] != NULL)&&(*list2[i] != '\0')) + { + list[cnt] = (char *)malloc(strlen(list1[i]) + 1); + list[cnt + 1] = (char *)malloc(strlen(list2[i]) + 1); + if ((list[cnt] == NULL)||(list[cnt + 1] == NULL)) + { + return(NULL); + } + strcpy(list[cnt], list1[i]); + strcpy(list[cnt + 1], list2[i]); + cnt += 2; + } + } + list[cnt] = NULL; + + return(list); +} + + +#ifdef MOTIF +/********** MOTIF VERSION *************/ +/* + * Make the appropriate widget for this tag, and fill in an + * WidgetInfo structure and return it. + */ +WidgetInfo * +MakeWidget(hw, text, x, y, id, fptr) + HTMLWidget hw; + char *text; + int x, y; + int id; + FormInfo *fptr; +{ + Arg arg[30]; + Cardinal argcnt; + Widget w; + WidgetInfo *wlist; + WidgetInfo *wptr; + Dimension width, height; + + wlist = hw->html.widget_list; + while (wlist != NULL) + { + if (wlist->id == id) + { + break; + } + wlist = wlist->next; + } + + /* + * If this widget is not on the list, we have never + * used it before. Create it now. + */ + if (wlist == NULL) + { + char widget_name[100]; + char **mapping; + char *tptr; + char *value; + char *name; + char *type_str; + int type; + short size; + int maxlength; + Boolean checked; + + mapping = NULL; + + checked = False; + name = ParseMarkTag(text, MT_INPUT, "NAME"); + + /* + * We may need to shorten the name for the widgets, + * which can't handle long names. + */ + if (name == NULL) + { + widget_name[0] = '\0'; + } + else if (strlen(name) > 99) + { + strncpy(widget_name, name, 99); + widget_name[99] = '\0'; + } + else + { + strcpy(widget_name, name); + } + + type_str = ParseMarkTag(text, MT_INPUT, "TYPE"); + if ((type_str != NULL)&&(strcmp(type_str, "checkbox") == 0)) + { + XmString label; + + type = W_CHECKBOX; + value = ParseMarkTag(text, MT_INPUT, "VALUE"); + if (value == NULL) + { + value = (char *)malloc(strlen("on") + 1); + strcpy(value, "on"); + } + + tptr = ParseMarkTag(text, MT_INPUT, "CHECKED"); + + /* We want no text on our toggles */ + label = XmStringCreateSimple(""); + + argcnt = 0; + XtSetArg(arg[argcnt], XmNlabelString, label); argcnt++; + XtSetArg(arg[argcnt], XmNx, x); argcnt++; + XtSetArg(arg[argcnt], XmNy, y); argcnt++; + if (tptr != NULL) + { + XtSetArg(arg[argcnt], XmNset, True); argcnt++; + checked = True; + free(tptr); + } + w = XmCreateToggleButton(hw->html.view, widget_name, + arg, argcnt); + XtSetMappedWhenManaged(w, False); + XtManageChild(w); + + XmStringFree(label); + } + else if ((type_str != NULL)&&(strcmp(type_str, "hidden") == 0)) + { + type = W_HIDDEN; + value = ParseMarkTag(text, MT_INPUT, "VALUE"); + if (value == NULL) + { + value = (char *)malloc(1); + value[0] = '\0'; + } + + w = NULL; + } + else if ((type_str != NULL)&&(strcmp(type_str, "radio") == 0)) + { + XmString label; + + type = W_RADIOBOX; + value = ParseMarkTag(text, MT_INPUT, "VALUE"); + if (value == NULL) + { + value = (char *)malloc(strlen("on") + 1); + strcpy(value, "on"); + } + + /* + * Only one checked radio button with the + * same name per form + */ + tptr = ParseMarkTag(text, MT_INPUT, "CHECKED"); + if ((tptr != NULL)&& + (AlreadyChecked(hw, fptr, name) == True)) + { + free(tptr); + tptr = NULL; + } + + /* We want no text on our toggles */ + label = XmStringCreateSimple(""); + + argcnt = 0; + XtSetArg(arg[argcnt], XmNlabelString, label); argcnt++; + XtSetArg(arg[argcnt], XmNx, x); argcnt++; + XtSetArg(arg[argcnt], XmNy, y); argcnt++; + XtSetArg(arg[argcnt], XmNindicatorType, XmONE_OF_MANY); + argcnt++; + if (tptr != NULL) + { + XtSetArg(arg[argcnt], XmNset, True); argcnt++; + checked = True; + free(tptr); + } + w = XmCreateToggleButton(hw->html.view, widget_name, + arg, argcnt); + XtSetMappedWhenManaged(w, False); + XtManageChild(w); + XtAddCallback(w, XmNvalueChangedCallback, + (XtCallbackProc)CBChangeRadio, (caddr_t)fptr); + + XmStringFree(label); + } + else if ((type_str != NULL)&&(strcmp(type_str, "submit") == 0)) + { + XmString label; + + type = W_PUSHBUTTON; + label = NULL; + value = ParseMarkTag(text, MT_INPUT, "VALUE"); + if ((value == NULL)||(*value == '\0')) + { + value = (char *)malloc(strlen("Submit Query") + + 1); + strcpy(value, "Submit Query"); + } + + argcnt = 0; + XtSetArg(arg[argcnt], XmNx, x); argcnt++; + XtSetArg(arg[argcnt], XmNy, y); argcnt++; + if (value != NULL) + { + label = XmStringCreateSimple(value); + XtSetArg(arg[argcnt], XmNlabelString, label); + argcnt++; + } + w = XmCreatePushButton(hw->html.view, widget_name, + arg, argcnt); + XtSetMappedWhenManaged(w, False); + XtManageChild(w); + if (label != NULL) + { + XmStringFree(label); + } + PrepareFormEnd(hw, w, fptr); + } + else if ((type_str != NULL)&&(strcmp(type_str, "reset") == 0)) + { + XmString label; + + type = W_PUSHBUTTON; + label = NULL; + value = ParseMarkTag(text, MT_INPUT, "VALUE"); + if ((value == NULL)||(*value == '\0')) + { + value = (char *)malloc(strlen("Reset") + 1); + strcpy(value, "Reset"); + } + + argcnt = 0; + XtSetArg(arg[argcnt], XmNx, x); argcnt++; + XtSetArg(arg[argcnt], XmNy, y); argcnt++; + if (value != NULL) + { + label = XmStringCreateSimple(value); + XtSetArg(arg[argcnt], XmNlabelString, label); + argcnt++; + } + w = XmCreatePushButton(hw->html.view, widget_name, + arg, argcnt); + XtSetMappedWhenManaged(w, False); + XtManageChild(w); + if (label != NULL) + { + XmStringFree(label); + } + PrepareFormReset(hw, w, fptr); + } + else if ((type_str != NULL)&&(strcmp(type_str, "button") == 0)) + { + XmString label; + + type = W_PUSHBUTTON; + label = NULL; + value = ParseMarkTag(text, MT_INPUT, "VALUE"); + + argcnt = 0; + XtSetArg(arg[argcnt], XmNx, x); argcnt++; + XtSetArg(arg[argcnt], XmNy, y); argcnt++; + if (value != NULL) + { + label = XmStringCreateSimple(value); + XtSetArg(arg[argcnt], XmNlabelString, label); + argcnt++; + } + w = XmCreatePushButton(hw->html.view, widget_name, + arg, argcnt); + XtSetMappedWhenManaged(w, False); + XtManageChild(w); + if (label != NULL) + { + XmStringFree(label); + } + } + else if ((type_str != NULL)&&(strcmp(type_str, "jot") == 0)) + { + XmString label; + Dimension width, height; + Widget frame; + char **list; + int list_cnt; + + type = W_JOT; + label = NULL; + value = ParseMarkTag(text, MT_INPUT, "VALUE"); + + /* + * SIZE is WIDTH,HEIGHT + */ + tptr = ParseMarkTag(text, MT_INPUT, "SIZE"); + list = ParseCommaList(tptr, &list_cnt); + if (tptr != NULL) + { + free(tptr); + } + + width = 200; + height = 50; + if (list_cnt == 1) + { + width = atoi(list[0]); + } + else if (list_cnt > 1) + { + width = atoi(list[0]); + height = atoi(list[1]); + } + FreeCommaList(list, list_cnt); + + argcnt = 0; + XtSetArg(arg[argcnt], XmNx, x); argcnt++; + XtSetArg(arg[argcnt], XmNy, y); argcnt++; + XtSetArg(arg[argcnt], XmNshadowType, XmSHADOW_IN); + argcnt++; + frame = XmCreateFrame(hw->html.view, "Frame", + arg, argcnt); + + argcnt = 0; + XtSetArg(arg[argcnt], XmNwidth, width); argcnt++; + XtSetArg(arg[argcnt], XmNheight, height); argcnt++; + w = XmCreateDrawingArea(frame, widget_name, + arg, argcnt); + XtManageChild(w); + + NewJot(w, width, height); + XtAddEventHandler(w, ExposureMask, 0, + EVJotExpose, (XtPointer)hw); + XtAddEventHandler(w, ButtonPressMask, 0, + EVJotPress, (XtPointer)hw); + XtAddEventHandler(w, ButtonMotionMask, 0, + EVJotMove, (XtPointer)hw); + XtAddEventHandler(w, ButtonReleaseMask, 0, + EVJotRelease, (XtPointer)hw); + + argcnt = 0; + XtSetArg(arg[argcnt], XmNuserData, (XtPointer)w); + argcnt++; + XtSetValues(frame, arg, argcnt); + + w = frame; + + XtSetMappedWhenManaged(w, False); + XtManageChild(w); + if (label != NULL) + { + XmStringFree(label); + } + } + else if ((type_str != NULL)&&(strcmp(type_str, "select") == 0)) + { + XmString label; + Widget scroll; + Widget pulldown, button, hist; + char *options; + char *returns; + char **list; + int list_cnt; + char **ret_list; + int return_cnt; + char **vlist; + int vlist_cnt; + int i, mult, size; + + type = -1; + tptr = ParseMarkTag(text, MT_INPUT, "HINT"); + if ((tptr != NULL)&&(strcmp(tptr, "list") == 0)) + { + type = W_LIST; + } + else if ((tptr != NULL)&&(strcmp(tptr, "menu") == 0)) + { + type = W_OPTIONMENU; + } + if (tptr != NULL) + { + free(tptr); + } + + size = 5; + tptr = ParseMarkTag(text, MT_INPUT, "SIZE"); + if (tptr != NULL) + { + size = atoi(tptr); + if ((size > 1)&&(type == -1)) + { + type = W_LIST; + } + free(tptr); + } + + mult = 0; + tptr = ParseMarkTag(text, MT_INPUT, "MULTIPLE"); + if (tptr != NULL) + { + if (type == -1) + { + type = W_LIST; + } + mult = 1; + free(tptr); + } + + if (type == -1) + { + type = W_OPTIONMENU; + } + + label = NULL; + hist = NULL; + value = ParseMarkTag(text, MT_INPUT, "VALUE"); + options = ParseMarkTag(text, MT_INPUT, "OPTIONS"); + returns = ParseMarkTag(text, MT_INPUT, "RETURNS"); + list = ParseCommaList(options, &list_cnt); + if (options != NULL) + { + free(options); + } + + ret_list = ParseCommaList(returns, &return_cnt); + if (returns != NULL) + { + free(returns); + } + + /* + * If return_cnt is less than list_cnt, the user made + * a serious error. Try to recover by padding out + * ret_list with NULLs + */ + if (list_cnt > return_cnt) + { + int rcnt; + char **rlist; + + rlist = (char **)malloc(list_cnt * + sizeof(char *)); + for (rcnt = 0; rcnt < return_cnt; rcnt++) + { + rlist[rcnt] = ret_list[rcnt]; + } + for (rcnt = return_cnt; rcnt < list_cnt; rcnt++) + { + rlist[rcnt] = NULL; + } + if (ret_list != NULL) + { + free((char *)ret_list); + } + ret_list = rlist; + } + + vlist = ParseCommaList(value, &vlist_cnt); + + if (size > list_cnt) + { + size = list_cnt; + } + if (size < 1) + { + size = 1; + } + + mapping = MakeOptionMappings(list, ret_list, list_cnt); + + if (type == W_OPTIONMENU) + { + Widget child; + XmString xmstr; + argcnt = 0; + pulldown = XmCreatePulldownMenu(hw->html.view, + widget_name, arg, argcnt); + + for (i=0; i<list_cnt; i++) + { + char bname[30]; + + sprintf(bname, "Button%d", (i + 1)); + label = XmStringCreateSimple(list[i]); + argcnt = 0; + XtSetArg(arg[argcnt], XmNlabelString, + label); + argcnt++; + button = XmCreatePushButton(pulldown, + bname, arg, argcnt); + XtManageChild(button); + XmStringFree(label); + + if ((vlist_cnt > 0)&& + (vlist[0] != NULL)&& + (strcmp(vlist[0], list[i]) ==0)) + { + hist = button; + } + + /* + * Start hist out as the first button + * so that if the user didn't set a + * default we always default to the + * first element. + */ + if ((i == 0)&&(hist == NULL)) + { + hist = button; + } + } + + FreeCommaList(list, list_cnt); + FreeCommaList(ret_list, list_cnt); + FreeCommaList(vlist, vlist_cnt); + if (value != NULL) + { + free(value); + } + + argcnt = 0; + XtSetArg(arg[argcnt], XmNx, x); argcnt++; + XtSetArg(arg[argcnt], XmNy, y); argcnt++; + XtSetArg(arg[argcnt], XmNsubMenuId, pulldown); + argcnt++; + if (hist != NULL) + { + XtSetArg(arg[argcnt], XmNmenuHistory, + hist); + argcnt++; + /* + * A gaggage. Value is used to later + * restore defaults. For option menu + * this means we need to save a child + * widget id as opposed to the + * character string everyone else uses. + */ + value = (char *)hist; + } + w = XmCreateOptionMenu(hw->html.view, + widget_name, arg, argcnt); + argcnt = 0; + xmstr = XmStringCreateSimple (""); + XtSetArg(arg[argcnt], XmNlabelString, + (XtArgVal)xmstr); + argcnt++; + child = XmOptionLabelGadget (w); + XtSetValues (child, arg, argcnt); + XmStringFree (xmstr); + } + else /* type == W_LIST */ + { + XmString *string_list; + XmString *val_list; + + if ((!mult)&&(vlist_cnt > 1)) + { + free(value); + value = (char *)malloc( + strlen(vlist[0]) + 1); + strcpy(value, vlist[0]); + } + + string_list = (XmString *)malloc(list_cnt * + sizeof(XmString)); + val_list = (XmString *)malloc(vlist_cnt * + sizeof(XmString)); + + for (i=0; i<list_cnt; i++) + { + string_list[i] = + XmStringCreateSimple(list[i]); + } + for (i=0; i<vlist_cnt; i++) + { + val_list[i] = + XmStringCreateSimple(vlist[i]); + } + + FreeCommaList(list, list_cnt); + FreeCommaList(ret_list, list_cnt); + FreeCommaList(vlist, vlist_cnt); + + argcnt = 0; + XtSetArg(arg[argcnt], XmNx, x); argcnt++; + XtSetArg(arg[argcnt], XmNy, y); argcnt++; + scroll = XmCreateScrolledWindow(hw->html.view, + "Scroll", arg, argcnt); + + argcnt = 0; + XtSetArg(arg[argcnt], XmNitems, string_list); + argcnt++; + XtSetArg(arg[argcnt], XmNitemCount, list_cnt); + argcnt++; + XtSetArg(arg[argcnt], XmNvisibleItemCount,size); + argcnt++; + if (mult) + { + XtSetArg(arg[argcnt],XmNselectionPolicy, + XmEXTENDED_SELECT); + argcnt++; + } + else + { + XtSetArg(arg[argcnt],XmNselectionPolicy, + XmBROWSE_SELECT); + argcnt++; + } + if ((vlist_cnt > 0)&&(mult)) + { + XtSetArg(arg[argcnt], XmNselectedItems, + val_list); + argcnt++; + XtSetArg(arg[argcnt], + XmNselectedItemCount, + vlist_cnt); + argcnt++; + } + else if ((vlist_cnt > 0)&&(!mult)) + { + XtSetArg(arg[argcnt], XmNselectedItems, + &val_list[0]); + argcnt++; + XtSetArg(arg[argcnt], + XmNselectedItemCount, 1); + argcnt++; + } + w = XmCreateList(scroll, widget_name, + arg, argcnt); + XtManageChild(w); + w = scroll; + + for (i=0; i<list_cnt; i++) + { + XmStringFree(string_list[i]); + } + if (string_list != NULL) + { + free((char *)string_list); + } + for (i=0; i<vlist_cnt; i++) + { + XmStringFree(val_list[i]); + } + if (val_list != NULL) + { + free((char *)val_list); + } + } + XtSetMappedWhenManaged(w, False); + XtManageChild(w); + } + else if ((type_str != NULL)&&(strcmp(type_str, "password") ==0)) + { + type = W_PASSWORD; + value = ParseMarkTag(text, MT_INPUT, "VALUE"); + + size = -1; + maxlength = -1; + + tptr = ParseMarkTag(text, MT_INPUT, "SIZE"); + if (tptr != NULL) + { + size = atoi(tptr); + free(tptr); + } + + tptr = ParseMarkTag(text, MT_INPUT, "MAXLENGTH"); + if (tptr != NULL) + { + maxlength = atoi(tptr); + free(tptr); + } + + argcnt = 0; + XtSetArg(arg[argcnt], XmNx, x); argcnt++; + XtSetArg(arg[argcnt], XmNy, y); argcnt++; + if (size > 0) + { + XtSetArg(arg[argcnt], XmNcolumns, size); + argcnt++; + } + if (maxlength > 0) + { + XtSetArg(arg[argcnt], XmNmaxLength, maxlength); + argcnt++; + } + if (value != NULL) + { + int i, len; + char *bval; + + len = strlen(value); + bval = (char *)malloc(len + 1); + for (i=0; i<len; i++) + { + bval[i] = '*'; + } + bval[len] = '\0'; + XtSetArg(arg[argcnt], XmNvalue, bval); + argcnt++; + } + w = XmCreateTextField(hw->html.view, widget_name, + arg, argcnt); +/* + * The proper order here is XtSetMappedWhenManaged, XtManageChild. But a bug + * in some versions of Motif1.1 makes us do it the other way. All versions + * of 1.2 should have this fixed + */ +#ifdef MOTIF1_2 + XtSetMappedWhenManaged(w, False); + XtManageChild(w); +#else + XtManageChild(w); + XtSetMappedWhenManaged(w, False); +#endif /* MOTIF1_2 */ + XtAddCallback(w, XmNactivateCallback, + (XtCallbackProc)CBActivateField, (caddr_t)fptr); + XtAddCallback(w, XmNmodifyVerifyCallback, + (XtCallbackProc)CBPasswordModify, (caddr_t)fptr); + } + else if ((type_str != NULL)&&(strcmp(type_str, "textarea") ==0)) + { + char **list; + int list_cnt; + int rows, cols; + Widget scroll; + + type = W_TEXTAREA; + + /* + * If there is no SIZE, look for ROWS and COLS + * directly. + * SIZE is COLUMNS,ROWS parse the list + */ + rows = -1; + cols = -1; + tptr = ParseMarkTag(text, MT_INPUT, "SIZE"); + if (tptr == NULL) + { + tptr = ParseMarkTag(text, MT_INPUT, "ROWS"); + if (tptr != NULL) + { + rows = atoi(tptr); + free(tptr); + } + tptr = ParseMarkTag(text, MT_INPUT, "COLS"); + if (tptr != NULL) + { + cols = atoi(tptr); + free(tptr); + } + } + else + { + list = ParseCommaList(tptr, &list_cnt); + free(tptr); + + if (list_cnt == 1) + { + cols = atoi(list[0]); + } + else if (list_cnt > 1) + { + cols = atoi(list[0]); + rows = atoi(list[1]); + } + FreeCommaList(list, list_cnt); + } + + /* + * Grab the starting value of the text here. + * NULL if none. + */ + value = ParseMarkTag(text, MT_INPUT, "VALUE"); + UnMuckTextAreaValue(value); + + argcnt = 0; + XtSetArg(arg[argcnt], XmNx, x); argcnt++; + XtSetArg(arg[argcnt], XmNy, y); argcnt++; + scroll = XmCreateScrolledWindow(hw->html.view, + "Scroll", arg, argcnt); + + argcnt = 0; + XtSetArg(arg[argcnt], XmNeditMode, XmMULTI_LINE_EDIT); + argcnt++; + if (cols > 0) + { + XtSetArg(arg[argcnt], XmNcolumns, cols); + argcnt++; + } + if (rows > 0) + { + XtSetArg(arg[argcnt], XmNrows, rows); + argcnt++; + } + if (value != NULL) + { + XtSetArg(arg[argcnt], XmNvalue, value); + argcnt++; + } + w = XmCreateText(scroll, widget_name, arg, argcnt); + XtManageChild(w); + w = scroll; + + XtSetMappedWhenManaged(w, False); + XtManageChild(w); + } + else /* if no type, assume type=text */ + { + char **list; + int list_cnt; + int rows, cols; + Widget scroll; + + /* + * SIZE can be either COLUMNS or COLUMNS,ROWS + * we assume COLUMNS,ROWS and parse the list + */ + tptr = ParseMarkTag(text, MT_INPUT, "SIZE"); + list = ParseCommaList(tptr, &list_cnt); + if (tptr != NULL) + { + free(tptr); + } + + /* + * If only COLUMNS specified, or SIZE not specified + * assume a TEXTFIELD + * Otherwise a TEXTAREA. + */ + if (list_cnt <= 1) + { + type = W_TEXTFIELD; + if (list_cnt == 1) + { + cols = atoi(list[0]); + } + else + { + cols = -1; + } + } + else + { + type = W_TEXTAREA; + cols = atoi(list[0]); + rows = atoi(list[1]); + } + /* + * Now that we have cols, and maybe rows, free the list + */ + FreeCommaList(list, list_cnt); + + /* + * Grab the starting value of the text here. + * NULL if none. + */ + value = ParseMarkTag(text, MT_INPUT, "VALUE"); + + /* + * For textfileds parse maxlength and + * set up the widget. + */ + if (type == W_TEXTFIELD) + { + maxlength = -1; + tptr = ParseMarkTag(text, MT_INPUT,"MAXLENGTH"); + if (tptr != NULL) + { + maxlength = atoi(tptr); + free(tptr); + } + + argcnt = 0; + XtSetArg(arg[argcnt], XmNx, x); argcnt++; + XtSetArg(arg[argcnt], XmNy, y); argcnt++; + if (cols > 0) + { + XtSetArg(arg[argcnt], XmNcolumns, cols); + argcnt++; + } + if (maxlength > 0) + { + XtSetArg(arg[argcnt], XmNmaxLength, + maxlength); + argcnt++; + } + if (value != NULL) + { + XtSetArg(arg[argcnt], XmNvalue, value); + argcnt++; + } + w = XmCreateTextField(hw->html.view, + widget_name, arg, argcnt); + } + /* + * Else this is a TEXTAREA. Maxlength is ignored, + * and we set up the scrolled window + */ + else + { + argcnt = 0; + XtSetArg(arg[argcnt], XmNx, x); argcnt++; + XtSetArg(arg[argcnt], XmNy, y); argcnt++; + scroll = XmCreateScrolledWindow(hw->html.view, + "Scroll", arg, argcnt); + + argcnt = 0; + XtSetArg(arg[argcnt], XmNeditMode, + XmMULTI_LINE_EDIT); + argcnt++; + if (cols > 0) + { + XtSetArg(arg[argcnt], XmNcolumns, cols); + argcnt++; + } + if (rows > 0) + { + XtSetArg(arg[argcnt], XmNrows, rows); + argcnt++; + } + if (value != NULL) + { + XtSetArg(arg[argcnt], XmNvalue, value); + argcnt++; + } + w = XmCreateText(scroll, widget_name, + arg, argcnt); + XtManageChild(w); + w = scroll; + } + +/* + * The proper order here is XtSetMappedWhenManaged, XtManageChild. But a bug + * in some versions of Motif1.1 makes us do it the other way. All versions + * of 1.2 should have this fixed + */ +#ifdef MOTIF1_2 + XtSetMappedWhenManaged(w, False); + XtManageChild(w); +#else + XtManageChild(w); + XtSetMappedWhenManaged(w, False); +#endif /* MOTIF1_2 */ + + /* + * For textfields, a CR might be an activate + */ + if (type == W_TEXTFIELD) + { + XtAddCallback(w, XmNactivateCallback, + (XtCallbackProc)CBActivateField, (caddr_t)fptr); + } + } + if (type_str != NULL) + { + free(type_str); + } + + /* + * Don't want to do GetValues if this is HIDDEN input + * tag with no widget. + */ + if (w != NULL) + { + argcnt = 0; + XtSetArg(arg[argcnt], XmNwidth, &width); argcnt++; + XtSetArg(arg[argcnt], XmNheight, &height); argcnt++; + XtGetValues(w, arg, argcnt); + } + else + { + width = 0; + height = 0; + } + + wptr = AddNewWidget(hw, fptr, w, type, id, x, y, width, height, + name, value, mapping, checked); + } + else + /* + * We found this widget on the list of already created widgets. + * Put it in place for reuse. + */ + { + wlist->x = x; + wlist->y = y; + + /* + * Don't want to SetValues if type HIDDEN which + * has no widget. + */ + if (wlist->w != NULL) + { + argcnt = 0; + XtSetArg(arg[argcnt], XmNx, x); argcnt++; + XtSetArg(arg[argcnt], XmNy, y); argcnt++; + XtSetValues(wlist->w, arg, argcnt); + } + + wptr = wlist; + } + + return(wptr); +} +#else +/********** ATHENA VERSION *************/ +/* + * Make the appropriate widget for this tag, and fill in an + * WidgetInfo structure and return it. + */ +WidgetInfo * +MakeWidget(hw, text, x, y, id, fptr) + HTMLWidget hw; + char *text; + int x, y; + int id; + FormInfo *fptr; +{ + Arg arg[30]; + Cardinal argcnt; + Widget w; + WidgetInfo *wlist; + WidgetInfo *wptr; + Dimension width, height; + + wlist = hw->html.widget_list; + while (wlist != NULL) + { + if (wlist->id == id) + { + break; + } + wlist = wlist->next; + } + + /* + * If this widget is not on the list, we have never + * used it before. Create it now. + */ + if (wlist == NULL) + { + char *tptr; + char *value; + char *name; + char *type_str; + int type; + short size; + int maxlength; + Boolean checked; + + checked = False; + name = ParseMarkTag(text, MT_INPUT, "NAME"); + + type_str = ParseMarkTag(text, MT_INPUT, "TYPE"); + if ((type_str != NULL)&&(strcmp(type_str, "checkbox") == 0)) + { + type = W_CHECKBOX; + value = ParseMarkTag(text, MT_INPUT, "VALUE"); + if (value == NULL) + { + value = (char *)malloc(strlen("on") + 1); + strcpy(value, "on"); + } + + tptr = ParseMarkTag(text, MT_INPUT, "CHECKED"); + + argcnt = 0; + XtSetArg(arg[argcnt], XtNx, x); argcnt++; + XtSetArg(arg[argcnt], XtNy, y); argcnt++; + if (tptr != NULL) + { + XtSetArg(arg[argcnt], XtNstate, True); argcnt++; + checked = True; + free(tptr); + } + XtSetArg(arg[argcnt], XtNlabel, ""); argcnt++; + w = XtCreateWidget(name, toggleWidgetClass, + hw->html.view, arg, argcnt); + XtSetMappedWhenManaged(w, False); + XtManageChild(w); + } + else if ((type_str != NULL)&&(strcmp(type_str, "hidden") == 0)) + { + type = W_HIDDEN; + value = ParseMarkTag(text, MT_INPUT, "VALUE"); + if (value == NULL) + { + value = (char *)malloc(1); + value[0] = '\0'; + } + + w = NULL; + } + else if ((type_str != NULL)&&(strcmp(type_str, "radio") == 0)) + { + type = W_RADIOBOX; + value = ParseMarkTag(text, MT_INPUT, "VALUE"); + if (value == NULL) + { + value = (char *)malloc(strlen("on") + 1); + strcpy(value, "on"); + } + + /* + * Only one checked radio button with the + * same name per form + */ + tptr = ParseMarkTag(text, MT_INPUT, "CHECKED"); + if ((tptr != NULL)&& + (AlreadyChecked(hw, fptr, name) == True)) + { + free(tptr); + tptr = NULL; + } + + argcnt = 0; + XtSetArg(arg[argcnt], XtNx, x); argcnt++; + XtSetArg(arg[argcnt], XtNy, y); argcnt++; + if (tptr != NULL) + { + XtSetArg(arg[argcnt], XtNstate, True); argcnt++; + checked = True; + free(tptr); + } + XtSetArg(arg[argcnt], XtNlabel, ""); argcnt++; + w = XtCreateWidget(name, toggleWidgetClass, + hw->html.view, arg, argcnt); + XtSetMappedWhenManaged(w, False); + XtManageChild(w); + XtAddCallback(w, XtNcallback, + (XtCallbackProc)CBChangeRadio, (caddr_t)fptr); + } + else if ((type_str != NULL)&&(strcmp(type_str, "submit") == 0)) + { + type = W_PUSHBUTTON; + value = ParseMarkTag(text, MT_INPUT, "VALUE"); + if ((value == NULL)||(*value == '\0')) + { + value = (char *)malloc(strlen("Submit Query") + + 1); + strcpy(value, "Submit Query"); + } + + argcnt = 0; + XtSetArg(arg[argcnt], XtNx, x); argcnt++; + XtSetArg(arg[argcnt], XtNy, y); argcnt++; + if (value != NULL) + { + XtSetArg(arg[argcnt], XtNlabel, value); + argcnt++; + } + w = XtCreateWidget(name, commandWidgetClass, + hw->html.view, arg, argcnt); + XtSetMappedWhenManaged(w, False); + XtManageChild(w); + PrepareFormEnd(hw, w, fptr); + } + else if ((type_str != NULL)&&(strcmp(type_str, "reset") == 0)) + { + type = W_PUSHBUTTON; + value = ParseMarkTag(text, MT_INPUT, "VALUE"); + if ((value == NULL)||(*value == '\0')) + { + value = (char *)malloc(strlen("Reset") + 1); + strcpy(value, "Reset"); + } + + argcnt = 0; + XtSetArg(arg[argcnt], XtNx, x); argcnt++; + XtSetArg(arg[argcnt], XtNy, y); argcnt++; + if (value != NULL) + { + XtSetArg(arg[argcnt], XtNlabel, value); + argcnt++; + } + w = XtCreateWidget(name, commandWidgetClass, + hw->html.view, arg, argcnt); + XtSetMappedWhenManaged(w, False); + XtManageChild(w); + PrepareFormReset(hw, w, fptr); + } + else if ((type_str != NULL)&&(strcmp(type_str, "button") == 0)) + { + type = W_PUSHBUTTON; + value = ParseMarkTag(text, MT_INPUT, "VALUE"); + + argcnt = 0; + XtSetArg(arg[argcnt], XtNx, x); argcnt++; + XtSetArg(arg[argcnt], XtNy, y); argcnt++; + if (value != NULL) + { + XtSetArg(arg[argcnt], XtNlabel, value); + argcnt++; + } + w = XtCreateWidget(name, commandWidgetClass, + hw->html.view, arg, argcnt); + XtSetMappedWhenManaged(w, False); + XtManageChild(w); + } + else if ((type_str != NULL)&&(strcmp(type_str, "select") == 0)) + { + STRING label; + Widget scroll; + Widget pulldown, button, hist; + char *options; + char **list; + int list_cnt; + char **vlist; + int vlist_cnt; + int i, mult, size; + + type = -1; + tptr = ParseMarkTag(text, MT_INPUT, "HINT"); + if ((tptr != NULL)&&(strcmp(tptr, "list") == 0)) + { + type = W_LIST; + } + else if ((tptr != NULL)&&(strcmp(tptr, "menu") == 0)) + { + type = W_OPTIONMENU; + } + if (tptr != NULL) + { + free(tptr); + } + + size = 5; + tptr = ParseMarkTag(text, MT_INPUT, "SIZE"); + if (tptr != NULL) + { + size = atoi(tptr); + if ((size > 1)&&(type == -1)) + { + type = W_LIST; + } + free(tptr); + } + + mult = 0; + tptr = ParseMarkTag(text, MT_INPUT, "MULTIPLE"); + if (tptr != NULL) + { + if (type == -1) + { + type = W_LIST; + } + mult = 1; + free(tptr); + } + + if (type == -1) + { + type = W_OPTIONMENU; + } + + label = NULL; + hist = NULL; + value = ParseMarkTag(text, MT_INPUT, "VALUE"); + options = ParseMarkTag(text, MT_INPUT, "OPTIONS"); + list = ParseCommaList(options, &list_cnt); + if (options != NULL) + { + free(options); + } + + vlist = ParseCommaList(value, &vlist_cnt); + + if (size > list_cnt) + { + size = list_cnt; + } + if (size < 1) + { + size = 1; + } + + if (type == W_OPTIONMENU) + { + XFontStruct *font; + Dimension maxWidth = 0, width, iW; + + argcnt = 0; + XtSetArg(arg[argcnt], XtNx, x); argcnt++; + XtSetArg(arg[argcnt], XtNy, y); argcnt++; + w = XtCreateWidget(name, + menuButtonWidgetClass, + hw->html.view, arg, argcnt); + argcnt = 0; + pulldown = XtCreatePopupShell("menu", + simpleMenuWidgetClass, w, + arg, argcnt); + + for (i=0; i<list_cnt; i++) + { + char bname[30]; + + sprintf(bname, "Button%d", (i + 1)); + argcnt = 0; + XtSetArg(arg[argcnt], XtNlabel, + list[i]); + argcnt++; + button = XtCreateWidget(bname, + smeBSBObjectClass, + pulldown, arg, argcnt); + XtManageChild(button); + + XtAddCallback(button, XtNcallback, + CBoption, (XtPointer)w); + + if (i==0) + { + XtVaGetValues(w, + XtNfont, &font, + XtNinternalWidth, &iW, + NULL); + } + + width = XTextWidth(font, list[i], + strlen(list[i])); + + if (width > maxWidth) maxWidth = width; + + if ((vlist_cnt > 0)&& + (vlist[0] != NULL)&& + (strcmp(vlist[0], list[i]) ==0)) + { + hist = button; + XtVaSetValues(w, + XtNlabel, + XtNewString(list[i]), + NULL); + } + + /* + * Start hist out as the first button + * so that if the user didn't set a + * default we always default to the + * first element. + */ + if ((i == 0)&&(hist == NULL)) + { + hist = button; + } + } + + XtVaSetValues(w, XtNwidth, maxWidth + (4 * iW), + NULL); + + FreeCommaList(vlist, vlist_cnt); + if (value != NULL) + { + free(value); + } + + if (hist != NULL) + { + /* + * A gaggage. Value is used to later + * restore defaults. For option menu + * this means we need to save a child + * widget id as opposed to the + * character string everyone else uses. + */ + value = (char *)hist; + } + } + else /* type == W_LIST */ + { + STRING *string_list; + STRING *val_list; + + if ((!mult)&&(vlist_cnt > 1)) + { + free(value); + value = (char *)malloc( + strlen(vlist[0]) + 1); + strcpy(value, vlist[0]); + } + + string_list = (STRING *)malloc(list_cnt * + sizeof(STRING)); + val_list = (STRING *)malloc(vlist_cnt * + sizeof(STRING)); + + for (i=0; i<list_cnt; i++) + { + string_list[i] = + XtNewString(list[i]); + } + for (i=0; i<vlist_cnt; i++) + { + val_list[i] = + XtNewString(vlist[i]); + } + + FreeCommaList(list, list_cnt); + FreeCommaList(vlist, vlist_cnt); + + argcnt = 0; + XtSetArg(arg[argcnt], XtNx, x); argcnt++; + XtSetArg(arg[argcnt], XtNy, y); argcnt++; + XtSetArg(arg[argcnt], XtNallowVert, True); + argcnt++; + scroll = XtCreateWidget("Scroll", + viewportWidgetClass, + hw->html.view, arg, argcnt); + + argcnt = 0; + XtSetArg(arg[argcnt], XtNdefaultColumns, 1); + argcnt++; + w = XtCreateWidget(name, + listWidgetClass, + scroll, arg, argcnt); + XtManageChild(w); + + XtAddCallback(w, XtNdestroyCallback, + CBListDestroy, NULL); + + XawListChange(w, string_list, list_cnt, + 0, True); + + if (vlist_cnt > 0) + { + if (vlist_cnt > 1) + { + fprintf(stderr, + "HTML: only a single selection allowed!\n"); + } + + for (i=0; i<list_cnt; i++) + { + if (!strcmp(string_list[i],val_list[0])) + { + XawListHighlight(w, i); + break; + } + } + } + + if (size>list_cnt) size=list_cnt; + if (size>1) + { + XFontStruct *font; + Dimension h,width, s; + + XtVaGetValues(w, XtNfont, &font, + XtNinternalHeight, &h, + XtNwidth, &width, + XtNrowSpacing, &s, + NULL); + XtVaSetValues(scroll, + XtNheight, + h + size*(s+FONTHEIGHT(font)), + XtNwidth, width + 20, + NULL); + } + + w = scroll; + + for (i=0; i<vlist_cnt; i++) + { + free(val_list[i]); + } + if (val_list != NULL) + { + free((char *)val_list); + } + } + XtSetMappedWhenManaged(w, False); + XtManageChild(w); + } + else if ((type_str != NULL)&&(strcmp(type_str, "password") ==0)) + { + char *txt; + + type = W_PASSWORD; + value = ParseMarkTag(text, MT_INPUT, "VALUE"); + + size = -1; + maxlength = -1; + + tptr = ParseMarkTag(text, MT_INPUT, "SIZE"); + if (tptr != NULL) + { + size = atoi(tptr); + free(tptr); + } + + tptr = ParseMarkTag(text, MT_INPUT, "MAXLENGTH"); + if (tptr != NULL) + { + maxlength = atoi(tptr); + free(tptr); + } + + argcnt = 0; + XtSetArg(arg[argcnt], XtNx, x); argcnt++; + XtSetArg(arg[argcnt], XtNy, y); argcnt++; + XtSetArg(arg[argcnt], XtNeditType, XawtextEdit); + argcnt++; + + if (maxlength > 0) + { + if (value) + { + txt = XtNewString(value); + txt = (char*)realloc(txt, + sizeof(char)*(maxlength+1)); + } + else + { + txt = (char *)malloc(sizeof(char)* + (maxlength+1)); + *txt = '\0'; + } + XtSetArg(arg[argcnt], XtNuseStringInPlace, 1); + argcnt++; + XtSetArg(arg[argcnt], XtNlength, maxlength); + argcnt++; + } + else + { + XtSetArg(arg[argcnt], XtNuseStringInPlace, 0); + argcnt++; + } + + + if (value != NULL) + { + int i, len; + char *bval; + + len = strlen(value); + if (maxlength > 0) + { + bval = txt; + if (maxlength<len) len = maxlength+1; + } + else + { + bval = (char *)malloc(len + 1); + } + for (i=0; i<len; i++) + { + bval[i] = '*'; + } + bval[len] = '\0'; + XtSetArg(arg[argcnt], XtNstring, bval); + argcnt++; + } + else /* value == NULL */ + { + if (maxlength>0) /* stringInPlace */ + { + XtSetArg(arg[argcnt], XtNstring, txt); + argcnt++; + } + } + + w = XtCreateWidget(name, asciiTextWidgetClass, + hw->html.view, arg, argcnt); + + if (maxlength > 0) + { + XtAddCallback(w, XtNdestroyCallback, + (XtCallbackProc)CBTextDestroy, + (caddr_t)txt); + } + + XtOverrideTranslations(w, + XtParseTranslationTable("<Key>: HTMLpwdInput()")); + XtOverrideTranslations(w, + XtParseTranslationTable("<Key>Return: no-op(RingBell)")); + + setTextSize(w,size<1?20:size,1); + XtSetMappedWhenManaged(w, False); + XtManageChild(w); + } + else if ((type_str != NULL)&&(strcmp(type_str, "textarea") ==0)) + { + char **list; + int list_cnt; + int rows, cols; + + type = W_TEXTAREA; + + /* + * If there is no SIZE, look for ROWS and COLS + * directly. + * SIZE is COLUMNS,ROWS parse the list + */ + rows = -1; + cols = -1; + tptr = ParseMarkTag(text, MT_INPUT, "SIZE"); + if (tptr == NULL) + { + tptr = ParseMarkTag(text, MT_INPUT, "ROWS"); + if (tptr != NULL) + { + rows = atoi(tptr); + free(tptr); + } + tptr = ParseMarkTag(text, MT_INPUT, "COLS"); + if (tptr != NULL) + { + cols = atoi(tptr); + free(tptr); + } + } + else + { + list = ParseCommaList(tptr, &list_cnt); + free(tptr); + + if (list_cnt == 1) + { + cols = atoi(list[0]); + } + else if (list_cnt > 1) + { + cols = atoi(list[0]); + rows = atoi(list[1]); + } + FreeCommaList(list, list_cnt); + } + + /* + * Grab the starting value of the text here. + * NULL if none. + */ + value = ParseMarkTag(text, MT_INPUT, "VALUE"); + UnMuckTextAreaValue(value); + + argcnt = 0; + XtSetArg(arg[argcnt], XtNx, x); argcnt++; + XtSetArg(arg[argcnt], XtNy, y); argcnt++; + XtSetArg(arg[argcnt], XtNeditType, XawtextEdit); + argcnt++; + + if (value != NULL) + { + XtSetArg(arg[argcnt], XtNstring, value); + argcnt++; + } + w = XtCreateWidget(name, asciiTextWidgetClass, + hw->html.view, arg, argcnt); + + setTextSize(w,cols>0?cols:20,rows>0?rows:1); + + XtSetMappedWhenManaged(w, False); + XtManageChild(w); + } + else /* if no type, assume type=text */ + { + char **list; + int list_cnt; + int rows, cols; + + /* + * SIZE can be either COLUMNS or COLUMNS,ROWS + * we assume COLUMNS,ROWS and parse the list + */ + tptr = ParseMarkTag(text, MT_INPUT, "SIZE"); + list = ParseCommaList(tptr, &list_cnt); + if (tptr != NULL) + { + free(tptr); + } + + /* + * If only COLUMNS specified, or SIZE not specified + * assume a TEXTFIELD + * Otherwise a TEXTAREA. + */ + if (list_cnt <= 1) + { + type = W_TEXTFIELD; + if (list_cnt == 1) + { + cols = atoi(list[0]); + } + else + { + cols = -1; + } + } + else + { + type = W_TEXTAREA; + cols = atoi(list[0]); + rows = atoi(list[1]); + } + /* + * Now that we have cols, and maybe rows, free the list + */ + FreeCommaList(list, list_cnt); + + /* + * Grab the starting value of the text here. + * NULL if none. + */ + value = ParseMarkTag(text, MT_INPUT, "VALUE"); + + /* + * For textfileds parse maxlength and + * set up the widget. + */ + if (type == W_TEXTFIELD) + { + char *txt; + + maxlength = -1; + tptr = ParseMarkTag(text, MT_INPUT,"MAXLENGTH"); + if (tptr != NULL) + { + maxlength = atoi(tptr); + free(tptr); + } + + argcnt = 0; + XtSetArg(arg[argcnt], XtNx, x); argcnt++; + XtSetArg(arg[argcnt], XtNy, y); argcnt++; + + if (maxlength > 0) + { + if (value) + { + txt = XtNewString(value); + txt = (char *)realloc(txt, + maxlength); + } + else + { + txt = (char *)malloc(maxlength); + *txt = '\0'; + } + XtSetArg(arg[argcnt], + XtNuseStringInPlace,1); + argcnt++; + XtSetArg(arg[argcnt], + XtNlength, maxlength); + argcnt++; + XtSetArg(arg[argcnt], XtNstring, txt); + argcnt++; + } + else + { + if (value != NULL) + { + XtSetArg(arg[argcnt], + XtNuseStringInPlace,0); + argcnt++; + txt = value; + XtSetArg(arg[argcnt], + XtNstring, txt); + argcnt++; + } + } + + XtSetArg(arg[argcnt], XtNeditType, XawtextEdit); + argcnt++; + w = XtCreateWidget(name, + asciiTextWidgetClass, + hw->html.view, arg, argcnt); + + if (maxlength > 0) + { + XtAddCallback(w, XtNdestroyCallback, + CBTextDestroy, (caddr_t)txt); + } + + XtOverrideTranslations(w, + XtParseTranslationTable( + "<Key>Return: no-op(RingBell)")); + setTextSize(w,cols>0?cols:20,1); + XtSetMappedWhenManaged(w, False); + XtManageChild(w); + } + /* + * Else this is a TEXTAREA. Maxlength is ignored, + * and we set up the scrolled window + */ + else + { + argcnt = 0; + XtSetArg(arg[argcnt], XtNx, x); argcnt++; + XtSetArg(arg[argcnt], XtNy, y); argcnt++; + XtSetArg(arg[argcnt], XtNeditType, XawtextEdit); + argcnt++; + + if (value != NULL) + { + XtSetArg(arg[argcnt], XtNstring, value); + argcnt++; + } + w = XtCreateWidget(name, + asciiTextWidgetClass, + hw->html.view, arg, argcnt); + setTextSize(w,cols>0?cols:20,rows>0?rows:1); + XtSetMappedWhenManaged(w, False); + XtManageChild(w); + } + + XtSetMappedWhenManaged(w, False); + XtManageChild(w); + } + if (type_str != NULL) + { + free(type_str); + } + + /* + * Don't want to do GetValues if this is HIDDEN input + * tag with no widget. + */ + if (w != NULL) + { + argcnt = 0; + XtSetArg(arg[argcnt], XtNwidth, &width); argcnt++; + XtSetArg(arg[argcnt], XtNheight, &height); argcnt++; + XtGetValues(w, arg, argcnt); + } + else + { + width = 0; + height = 0; + } + + wptr = AddNewWidget(hw, fptr, w, type, id, x, y, width, height, + name, value, checked); + } + else + /* + * We found this widget on the list of already created widgets. + * Put it in place for reuse. + */ + { + wlist->x = x; + wlist->y = y; + + /* + * Don't want to SetValues if type HIDDEN which + * has no widget. + */ + if (wlist->w != NULL) + { + XtUnmanageChild(wlist->w); + argcnt = 0; + XtSetArg(arg[argcnt], XtNx, x); argcnt++; + XtSetArg(arg[argcnt], XtNy, y); argcnt++; + XtSetValues(wlist->w, arg, argcnt); + XtManageChild(wlist->w); + } + + wptr = wlist; + } + + return(wptr); +} +#endif /* MOTIF */ + + +void +WidgetRefresh(hw, eptr) + HTMLWidget hw; + struct ele_rec *eptr; +{ + if ((eptr->widget_data != NULL)&&(eptr->widget_data->mapped == False)&& + (eptr->widget_data->w != NULL)) + { + eptr->widget_data->mapped = True; + XtSetMappedWhenManaged(eptr->widget_data->w, True); + } + +#if 0 + if (eptr->pic_data != NULL) + { + int x, y, extra; + + x = eptr->x; + y = eptr->y + eptr->y_offset; + + if ((hw->html.border_images == True)|| + (eptr->anchorHRef != NULL)) + { + extra = IMAGE_BORDER; + } + else + { + extra = 0; + } + + x = x - hw->html.scroll_x; + y = y - hw->html.scroll_y; + XSetForeground(XtDisplay(hw), hw->html.drawGC, eptr->fg); + XSetBackground(XtDisplay(hw), hw->html.drawGC, eptr->bg); + XFillRectangle(XtDisplay(hw->html.view), + XtWindow(hw->html.view), hw->html.drawGC, + x, y, + (eptr->pic_data->width + (2 * extra)), + extra); + XFillRectangle(XtDisplay(hw->html.view), + XtWindow(hw->html.view), hw->html.drawGC, + x, + (y + eptr->pic_data->height + extra), + (eptr->pic_data->width + (2 * extra)), + extra); + XFillRectangle(XtDisplay(hw->html.view), + XtWindow(hw->html.view), hw->html.drawGC, + x, y, + extra, + (eptr->pic_data->height + (2 * extra))); + XFillRectangle(XtDisplay(hw->html.view), + XtWindow(hw->html.view), hw->html.drawGC, + (x + eptr->pic_data->width + extra), + y, + extra, + (eptr->pic_data->height + (2 * extra))); + + if (eptr->pic_data->image == (Pixmap)NULL) + { + if (eptr->pic_data->image_data != NULL) + { + eptr->pic_data->image = InfoToImage(hw, + eptr->pic_data); + } + else + { + eptr->pic_data->image = NoImage(hw); + } + } + + if (eptr->pic_data->image != (Pixmap)NULL) + { + XCopyArea(XtDisplay(hw->html.view), + eptr->pic_data->image, + XtWindow(hw->html.view), hw->html.drawGC, 0, 0, + eptr->pic_data->width, eptr->pic_data->height, + (x + extra), + (y + extra)); + } + } +#endif +} + |