开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > 浏览器 > 查看源码
forms.c
资源名称：arena-beta-2b-src.tar.gz　[点击查看]
上传用户：zlh9724
上传日期：2007-01-04
资源大小：1991k
文件大小：44k
源码类别：

浏览器

开发平台：

Unix_Linux

forms.c：源码内容
  1. /* forms.c - forms handling for html+
  3. ParseHTML() creates a linked list of forms. Each form has a linked
  4. list of fields. This file includes routines for drawing fields,
  5. handling mouse clicks/drags and key presses on fields, plus sending
  6. the contents of forms to HTTP servers.
  8. When resizing windows, it is important to keep the existing form
  9. data structures as otherwise the current values of fields will be
  10. lost and overridden by the original starting values. This requires
  11. the global new_form to be set to false. It should be set to true
  12. when reading new documents. In addition, The browser history list
  13. needs to preserve the form data structures so that they can be
  14. reused upon backtracking to restore previous field values.
  16. The desire to evolve to a wysiwyg editor means that its a bad idea
  17. to have pointers into the paint stream as this would be expensive
  18. to update when users edit the html document source . Consequently,
  19. one has to search the form structure to find fields that need to
  20. be redrawn under programatic control, e.g. unsetting of radio
  21. buttons. Note that anyway, the y-position of a field is unresolved
  22. when it is added to the paint stream, and only becomes fixed when
  23. the end of the line is reached. A compromise is to cache the
  24. baseline position when painting each field and trash the cache
  25. each time the user alters the document.
  27. Another complication is the need to save current field values
  28. when following a link to another document, as otherwise there
  29. is now way of restoring them when the user backtracks to the
  30. document containing the form. A simple approach is to save the
  31. linked list of forms in memory as part of a memory resident
  32. history list. Note for local links, the same form data should
  33. be used, rather than recreating the list from new. The corollary
  34. is that the list should only be freed when backtracking the
  35. document containing the form or reloading the same.
  37. Note that in many cases a sequence of form interactions with
  38. a server causes a state change in the server (e.g. updating a
  39. database) and hence is not simply reversed by backtracking in
  40. the normal way. In this case it makes sense to avoid pushing
  41. intermediate steps onto the history stack, e.g. when submitting
  42. the form. This probably requires the document or server to
  43. disable the history nechanism via suitable attributes.
  45. */
  47. #include <stdio.h>
  48. #include <string.h>
  49. #include <ctype.h>
  51. #include "www.h"
  52. #include "types.h"
  53. #include "neweditor.h"
  55. extern Display *display;
  56. extern int screen;
  57. extern Window win;
  58. extern GC disp_gc, gc_fill;
  59. extern Cursor hourglass;
  60. extern int UsePaper;
  62. extern int debug;  /* controls display of errors */
  63. extern int document;  /* HTMLDOCUMENT or TEXTDOCUMENT */
  64. extern int busy;
  65. extern int OpenURL;
  66. extern int IsIndex;
  67. extern int FindStr;
  68. extern int Authorize;
  69. extern char *FindNextStr;
  70. extern int SaveFile;
  71. extern int sbar_width;
  72. extern int statusHeight;
  73. extern int ToolBarHeight;
  74. extern unsigned long windowColor;
  75. extern unsigned int win_width, win_height, tileWidth, tileHeight;
  77. extern unsigned long textColor, labelColor, windowTopShadow,
  78.                      strikeColor, windowBottomShadow, statusColor, windowColor;
  80. /*
  81.     The current top line is displayed at the top of the window,the pixel
  82.     offset is the number of pixels from the start of the document.
  83. */
  85. extern char *buffer;            /* the start of the document buffer */
  86. extern long PixelOffset;        /* the pixel offset to top of window */
  87. extern int PixelIndent;
  88. extern Doc *CurrentDoc;
  89. extern XFontStruct *pFontInfo;
  90. extern XFontStruct *Fonts[FONTS];
  91. extern int LineSpacing[FONTS], BaseLine[FONTS], StrikeLine[FONTS];
  92. extern int preformatted;
  93. extern int font;  /* index into Fonts[] array */
  94. extern int above, below;
  95. extern XRectangle displayRect; /* clipping limits for painting html */
  97. Form *forms = NULL;
  98. Field *focus;   /* which field has focus (NULL if none do) */
  99. int cursorpos = 5; /* cursor position in characters */
  100. Bool TextFieldFocus = FALSE;
  102. /*
  103.    The next 3 pointers indicate records to reuse for next form/field/option
  104.    when resizing a document or during 2nd pass thru table data. If NULL the
  105.    corresponding record is created from scratch
  106. */
  108. Form *next_form = NULL;
  109. Field *next_field = NULL;
  110. Option *next_option = NULL;
  112. /* version of strdup that copes with null string pointers */
  114. char *strsav(char *s)
  115. {
  116.     if (s)
  117.         return strdup(s);
  119.     return NULL;
  120. }
  122. /* version of strdup for use with non-terminated strings */
  124. char *strdup2(char *s, int len)
  125. {
  126.     char *str;
  128.     str = (char *)malloc(len + 1);
  129.     memcpy(str, s, len);
  130.     str[len] = '';
  131.     return str;
  132. }
  134. Form *FindForm(Form *forms,char *link)
  135. {
  136.     Form *form_link;
  137.     for (form_link = forms; form_link != NULL; form_link = form_link->next)
  138.     {
  139.        if ( form_link->action == link)
  140.    return(form_link);
  141.     };
  142.     return(NULL); /* failed */
  143. }
  145. Field *FindField(Form *form,int type, char *name, int namelen)
  146. {
  147.     Field *field_link;
  148.     for( field_link = form->fields; field_link != NULL ; field_link = field_link->next)
  149.     {
  150.         if ( field_link->type == type )  /* check type then name... assume it's enough */
  151.   if ( type == RADIOBUTTON)
  152.   {
  153.       if( name == field_link->name)
  154.           return(field_link);
  155.   }
  156.   else
  157.       if ( strncasecmp( name, field_link->name, namelen) == 0 )
  158.           return(field_link);
  159.     };
  160.     return(NULL);
  161. }
  164. int FieldCount(Form *form)
  165. {
  166.     int n;
  167.     Field *field;
  169.     n = 0;
  170.     field = form->fields;
  172.     while (field)
  173.     {
  174.         ++n;
  175.         field = field->next;
  176.     }
  178.     return n;
  179. }
  181. void FreeForms(void)
  182. {
  183.     Option *option;
  184.     Form *form;
  185.     Field *fields, *field;
  187.     next_form = NULL;
  188.     next_field = NULL;
  189.     next_option = NULL;
  191.     while (forms != NULL)
  192.     {
  193.         form = forms;
  194.         forms = forms->next;
  195.         fields = form->fields;
  197.         while (fields)
  198.         {
  199.             field = fields;
  200.     /* Free(field->name); --Spif name is only a copy of pointer 13-Oct-95 */
  201.             Free(field->value);
  202.     /* --Spif we must clear image */
  203.     if (field->image != NULL)
  204.     {
  205.         free( field->image->pixels );
  206. free( field->image->url );
  207. free( field->image );
  208.     };
  209.             fields = fields->next;
  210.     
  211.             while (field->options)
  212.             {
  213.                 option = field->options;
  215.                 if (option->label)
  216.                     Free(option->label);
  218.                 field->options = option->next;
  219.                 Free(option);
  220.             }
  222.             Free(field);
  223.         }
  225.         if (form->action)
  226.             Free(form->action);
  228.         Free(form);
  229.     }
  230. }
  232. /* scroll field up/down by delta - this is called
  233.    to adjust y offset of field - not to paint fields */
  234. void ScrollForms(long delta)
  235. {
  236.     Form *form;
  237.     Field *field;
  239.     for (form = forms; form; form = form->next)
  240.     {
  241.         for (field = form->fields; field; field = field->next)
  242.             if (field->baseline >= 0 && field->baseline - delta >= 0)
  243.                 field->baseline -= delta;
  244.     }
  245. }
  247. /*
  248.    Preserves form contents across window resizing / backtracking.
  249.    It is assumed that FreeForms() is called before loading new
  250.    documents or reloading existing ones.
  251. */
  253. void ResizeForm(void)
  254. {
  255.     if (forms != NULL)
  256.     {
  257.         next_form = forms;
  258.         next_field = next_form->fields;
  259.         next_option = next_field->options;
  260.     }
  261. }
  263. /* ParseTable() makes 2 passes thru table data, so we need
  264.    to avoid recreating elements on 2nd pass. This procedure
  265.    should be called before pass == 1 and pass == 2 */
  267. void ProcessTableForm(int pass)
  268. {
  269.     static Form *form;
  270.     static Field *field;
  271.     static Option *option;
  273.     if (pass == 1)
  274.     {
  275.         form = next_form;
  276.         field = next_field;
  277.         option = next_option;
  278.     }
  279.     else  /* pass == 2 */
  280.     {
  281.         next_form = form;
  282.         next_field = field;
  283.         next_option = option;
  284.     }
  285. }
  287. Form *GetForm(int method, char *url, int len)
  288. {
  289.     Form *form, *last;
  291.     /* is form already defined */
  293.     if (next_form)
  294.     {
  295.         form = next_form;
  296.         next_form = form->next;
  297.         next_field = form->fields;
  298.         next_option = next_field->options;
  299.         return form;
  300.     }
  302.     form = (Form *)malloc(sizeof(Form));
  304.     form->next = NULL;
  305.     form->fields = NULL;
  306.     form->action = url; /* strdup2(url, len); --Spif */
  307.     form->alen = len;
  308.     form->method = method;
  309.     next_field = NULL;
  310.     next_option = NULL;
  312.     /* insert at end of list */
  314.     if (forms)
  315.     {
  316.         last = forms;
  318.         while (last->next)
  319.             last = last->next;
  321.         last->next = form;
  322.     }
  323.     else
  324.         forms = form;
  326.     return form;
  327. }
  329. Form *DefaultForm(void)
  330. {
  331.     return GetForm(GET, CurrentDoc->url, strlen(CurrentDoc->url));
  332. }
  334. /* font should be passed in lower 4 bits of flags */
  336. Field *GetField(Form *form, int type, int x, char *name, int nlen,
  337.                char *value, int vlen, int rows, int cols , int flags)
  338. {
  339.     int em, font;
  340.     char *s;
  341.     Field *field, *last;
  343.     if (form == NULL)
  344.         return NULL;
  346.     /* if we are resizing the form or backtracking to it then
  347.        we need to resuse the existing data structures to preserve
  348.        any chances that have been made to the default values */
  349.     
  350.     if ((field=FindField(form, type, name, nlen))== NULL)
  351.     {
  353.         if (next_field)
  354. {
  355.     field = next_field;
  356.     next_field = field->next;
  357.     next_option = field->options;
  358.     goto set_size;
  359. }
  361. field = (Field *)malloc(sizeof(Field));
  362. next_option = NULL;
  364. field->next = NULL;
  365. field->form = form;
  366. field->type = type;
  367. field->name = name;
  368. field->nlen = nlen;
  369. field->value = strndup(value, vlen);
  370. field->bufsize = vlen+1;
  371. field->buflen = vlen;    
  372. field->flags = flags;
  373. field->x = x;
  374. field->x_indent = 0;
  375. field->y_indent = 0;
  376. field->baseline = -1;
  377. field->options = 0;
  379.     /* insert at end of list */
  381. if (form->fields)
  382. {
  383.     last = form->fields;
  385.     while (last->next)
  386.         last = last->next;
  388.     last->next = field;
  389. }
  390. else
  391.     form->fields = field;
  393. if (type == TEXTFIELD) {
  394.     field->text_field = (TextField *)malloc(sizeof(TextField));
  395.     field->text_field->buffer = NULL;
  396.     field->text_field->length = 0;
  397.     field->text_field->used = 0;
  398.     field->text_field->scratch[0] = '';
  399. }
  401.     set_size:
  402. field->x = x;
  403. font = flags & 0x0F;
  405. em = WIDTH(font, "mite", 4)/4;
  407. if (type == RADIOBUTTON || type == CHECKBOX)
  408. {
  409.     field->width = ASCENT(font) + DESCENT(font) - 2;
  410.     field->height = field->width;
  411.     field->above = ASCENT(font) - 1;
  412. }
  413. else  /* TEXTFIELD and OPTIONLIST */
  414. {
  415.     if (type == SUBMITBUTTON)
  416.     {
  417.         if (vlen == 0)
  418. {
  419.     s = " Submit Query ";
  420.     vlen = strlen(s);
  421.     field->value = strdup2(s, vlen);
  422.     field->buflen = vlen;
  423.     field->bufsize = 1 + vlen;
  424. } 
  426. field->width = 8 + WIDTH(font, field->value, field->buflen);
  427.     }
  428.     else if (type == RESETBUTTON)
  429.     {
  430.         if (vlen == 0)
  431. {
  432.     s = " Reset ";
  433.     vlen = strlen(s);
  434.     field->value = strdup2(s, vlen);
  435.     field->buflen = vlen;
  436.     field->bufsize = 1 + vlen;
  437. } 
  439. field->width = 8 + WIDTH(font, field->value, field->buflen);
  440.     }
  441.     else
  442.         field->width = 8 + cols * em;
  444.     field->height = 4 + rows * SPACING(Fonts[font]);
  445.     field->above = ASCENT(font) + 3;
  446. }
  447.     }
  448.     else
  449.     {
  450.       return(field);
  451.     }
  452.     return field;
  453. }
  455. /* howcome 27/7/95: should AddOption return Option ? */
  457. void AddOption(Field *field, int flags, char *label, int len)
  458. {
  459.     int width, font;
  460.     Option *option, *last;
  462.     /* if we are resizing the form or backtracking to it then
  463.        we need to resuse the existing data structures to preserve
  464.        any chances that have been made to the default values */
  466.     if (next_option)
  467.     {
  468.         option = next_option;
  469.         next_option = option->next;
  470.         return /*option*/;
  471.     }
  473.     option = (Option *)malloc(sizeof(Option));
  475.     option->next = NULL;
  476.     option->flags = flags;
  477.     option->label = strdup(label);
  478.     font = flags & 0xF;
  480.     width = 6 + WIDTH(font, label, len) + field->height;
  482.     if (width > field->width)
  483. field->width = width;
  484.     
  485.     /* insert at end of list */
  486.     
  487.     if (field->options)
  488.     {
  489.         last = field->options;
  490. while (last->next)
  491. {
  492.     if (strlen(last->label) == len)
  493. if ( strncmp( last->label, label, len) == 0)
  494. {
  495.     if(option) /* avoid any possibility of memory leak --SPif 18/Oct/95 */
  496.     {
  497. free(option->label);
  498. free(option);
  499.     };
  500.     return /*NULL*/;
  501. }; /* don't add 2 times the same option --Spif 18-Oct-95 */
  502.             last = last->next;
  503. };
  504. if (strlen(last->label) != len)
  505.     last->next = option;
  506. else
  507.     if ( strncmp( last->label, label, len))
  508. last->next = option;
  509.     else
  510. return/* NULL*/;
  511.     }
  512.     else
  513.     {
  514.         option->flags |= CHECKED;
  515.         field->options = option;
  516.     };
  518.     field->y_indent++;
  519. }
  521. Field *CurrentRadioButton(Form *form, char *name, int nlen)
  522. {
  523.     Field *field;
  525.     if (form == NULL)
  526.         return NULL;
  528.     field = form->fields;
  530.     while (field)
  531.     {
  532.         if (strncasecmp(field->name, name, nlen) == 0 && (field->flags & CHECKED))
  533.             return field;
  535.         field = field->next;
  536.     }
  538.     return field;
  539. }
  541. void HideDropDown(GC gc, Field *field)
  542. {
  543.     int width, height, x1, y1;
  545.     height = field->height;
  546.     width = field->width - height + 2;
  547.     x1 = field->frame_indent + field->x - PixelIndent;
  548.     y1 = height + Abs2Win(field->baseline) - ASCENT(font) - 2;
  549.     DisplayHTML(x1, y1, width, 6 + field->y_indent * (height - 4));
  550.     ClipToWindow();
  551. }
  553. /* called when testing mouse down/up (event = BUTTONDOWN or BUTTONUP) */
  554. int ClickedInField(GC gc, int indent, int baseline, Field *field, int x, int y, int event)
  555. {
  556.     int y1;
  557.     Field *field_link;
  559.     if(CurrentDoc->edited_field)   /* can get rid of this (in www.c buttonpress) */
  560.     {
  561. free(CurrentDoc->edited_field->value);
  562. CurrentDoc->edited_field->value = Buffer2Str(CurrentDoc->field_editor);
  563. CurrentDoc->edited_field = NULL;
  564. FreeBuffer(CurrentDoc->field_editor);
  565. CurrentDoc->field_editor = NULL;
  566.     };
  568.     if (field->type == CHECKBOX || field->type == RADIOBUTTON)
  569.         y1 = baseline - ASCENT(font) + 2;
  570.     else if (field->type == OPTIONLIST)
  571.         y1 = baseline - ASCENT(font) - 2;
  572.     else   /* TEXTFIELD */
  573.         y1 = baseline - ASCENT(font) - 2;
  575.     x -= indent; /* fix event bug with form fields *//* howcome: applied 18/11/94 */
  577.     if (field->x <= x && x < field->x + field->width &&
  578.                 y1 <= y && y < y1 + field->height)
  579.     {
  580.         if (event == BUTTONUP)
  581.         {
  582.   TextFieldFocus = FALSE; /* howcome: will be set to true if this is a text field */
  584.             /* remove focus from current field */
  586.             if (focus && focus != field)
  587.             {
  588.                 focus->flags &= ~CHECKED;
  590.                 if (focus->type == OPTIONLIST)
  591.                     HideDropDown(gc, focus);
  592.                 else if (focus->type == TEXTFIELD)
  593.                     PaintField(gc, -1, Abs2Win(focus->baseline), focus);
  595.                 focus = NULL;
  596.             }
  598.             if (field->type == RADIOBUTTON)
  599.             {
  600.         field->flags |= CHECKED;
  601. PaintField(gc, indent, baseline, field);
  602. for( field_link=field->form->fields ; field_link!=NULL; field_link = field_link->next)
  603. {
  604.     if( field_link!= field) /* set the other buttons with the same name ;) */
  605.     {
  606.         if( (field_link->type == RADIOBUTTON) && (strncasecmp(field_link->name,field->name,field->nlen)==0))
  607.     if(field_link->flags & CHECKED)
  608.     {
  609.       field_link->flags ^= CHECKED;
  610.       if (field_link->baseline >= 0)
  611.   PaintField(gc, -1, Abs2Win(field_link->baseline), field_link);
  612.     };
  613.     };
  614. };
  615.     }
  616.             else if (field->type == CHECKBOX) 
  617.             {
  618.         field->flags ^= CHECKED;
  619.         PaintField(gc, indent, baseline, field);
  620.     }
  621.             if (field->type == OPTIONLIST)
  622.             {
  623.                 if (field->flags & CHECKED)
  624.                 {
  625.                     field->flags &= ~CHECKED;
  626.                     HideDropDown(gc, field);
  627.                 }
  628.                 else
  629.                 {
  630.                     field->flags |= CHECKED;
  631.                     PaintDropDown(gc, field, indent);
  632.                     focus = field;
  633.                 }
  634.             }
  635.             else if ((field->type == TEXTFIELD) ||(field->type == PASSWD))
  636.             {
  637.                 field->flags |= CHECKED;
  638.                 PaintField(gc, indent, baseline, field);
  639.                 focus = field;
  641. CurrentDoc->edited_field = field;
  642. CurrentDoc->field_editor = Str2Buffer(field->value);
  643. PaintFieldCursorBuffer(gc, strikeColor, CurrentDoc->field_editor, field);
  645. /* howcome started playing 19/1/95 */
  646. TextFieldFocus = TRUE;
  647. if (OpenURL|Authorize|FindStr) {
  648.     OpenURL = Authorize = FindStr = 0;
  649.     DisplayUrl();
  650. }
  651.             }
  652.         }
  653.         return 1;
  654.     }
  655.     return 0;
  656. }
  658. /* set clip rectangle to intersection with displayRect
  659.    to clip text strings in text fields */
  661. int ClipIntersection(GC gc, int x, int y, unsigned int width, unsigned int height)
  662. {
  663.     int xl, yl, xm, ym;
  664.     XRectangle rect;
  666.     xl = x;
  667.     xm = x + width;
  668.     yl = y;
  669.     ym = y + height;
  671.     if (xl < displayRect.x)
  672.         xl = displayRect.x;
  674.     if (yl < displayRect.y)
  675.         yl = displayRect.y;
  677.     if (xm > displayRect.x + displayRect.width)
  678.         xm = displayRect.x + displayRect.width;
  680.     if (ym > displayRect.y + displayRect.height)
  681.         ym = displayRect.y + displayRect.height;
  683.     if (xm > xl && ym > yl)
  684.     {
  685.         rect.x = xl;
  686.         rect.y = yl;
  687.         rect.width = xm - xl;
  688.         rect.height = ym - yl;
  689.         XSetClipRectangles(display, gc, 0, 0, &rect, 1, Unsorted);
  690.     }
  692.     return 0;
  693. }
  695. int ClickedInDropDown(GC gc, Field *field, int indent, int event, int x, int y)
  696. {
  697.     int font, baseline, bw, bh, dh, x1, y1, n;
  698.     Option *option;
  700.     font = field->flags & 0x0F;
  701.    
  702.     baseline = Abs2Win(field->baseline);
  703.     bw = field->width - field->height + 2;
  704.     bh = 6 + field->y_indent * (field->height - 4);
  705.     dh = field->height;
  706.     x1 = field->frame_indent + field->x - PixelIndent;
  707.     y1 = field->height + baseline - ASCENT(font) - 2;
  708.     n = field->x_indent;
  710.     if (x1 + 2 < x && x < x1 + bw - 2 && y1 + 2 < y && y < y1 + bh)
  711.     {
  712.         if (event == BUTTONDOWN)
  713.             return 1;
  715.         if ( !(field->flags & MULTIPLE) )
  716.         {
  717.             for (option = field->options; option; option = option->next)
  718.         if((option->flags & CHECKED) == CHECKED)
  719.   option->flags ^= CHECKED;
  720. }
  721.         n = ((y - y1) * field->y_indent) / bh;
  722.         field->x_indent = n;
  723.         option = field->options;
  725.         while (n-- > 0){
  726.             option = option->next;
  727.   };
  728.         if (option->flags & CHECKED)
  729.         {
  730.             option->flags ^= CHECKED;
  732.             for (option = field->options; option; option = option->next)
  733.             {
  734.                 if (option->flags & CHECKED)
  735.                     break;
  736.             }
  737.         }
  738.         else
  739.             option->flags |= CHECKED;
  741.         if ( !(field->flags & MULTIPLE) )
  742.     field->flags &= ~CHECKED;
  743.     
  744.         Free(field->value);
  745.         field->value = (option ? strdup(option->label) : "");
  746.         ClipToWindow();
  747.         PaintField(gc, -1, Abs2Win(focus->baseline), field);
  749.         if (field->flags & MULTIPLE)
  750.             PaintDropDown(gc, field, indent);
  751.         else
  752.             HideDropDown(gc, field);
  753.         return 1;
  754.     }
  756.     return 0;
  757. }
  759. void PaintDropDown(GC gc, Field *field, int indent)
  760. {
  761.     int font, baseline, width, height, h, x1, y1, y2, n, i;
  762.     Option *option;
  764.     /* nasty kludge !!!! */
  765.     if (indent < 0)
  766.         indent = field->frame_indent;
  768.     baseline = Abs2Win(field->baseline);
  769.     font = field->flags & 0x0F;
  771.     SetFont(gc, font);
  772.     height = field->height;
  773.     width = field->width - height + 2;
  774.     x1 = indent + field->x - PixelIndent;
  775.     y1 = height + baseline - ASCENT(font) - 2;
  776.     n = field->x_indent;
  777.     h = 6 + field->y_indent * (height - 4);
  778.     y2 = baseline + height;
  779.     option = field->options;
  781.     XSetForeground(display, gc, windowColor);
  782.     XFillRectangle(display, win, gc, x1, y1, width, h);
  783.     DrawOutSet(win, gc, x1, y1, width, h);
  785.     y1 += 2;
  787.     for (option = field->options, i = 0; option; option = option->next)
  788.     {
  789.         if (option->flags & CHECKED)
  790.         {
  791.             XSetForeground(display, gc, statusColor);
  792.             XFillRectangle(display, win, gc, x1+2, y1, width-4, height-2);
  793.         }
  795.         XSetForeground(display, gc, textColor);
  796.         XDrawString(display, win, gc, x1+4, y2, option->label, strlen(option->label));
  797.         y2 += height - 4;
  798.         y1 += height - 4;
  799.         ++i;
  800.     }
  801. }
  803. void PaintTickMark(GC gc, int x, int y, unsigned int w, unsigned int h)
  804. {
  805.     int x1, y1, x2, y2, x3, y3;
  807.     x1 = x;
  808.     x2 = x + w/3;
  809.     x3 = x + w-1;
  810.     y1 = y + h - h/3 - 1;
  811.     y2 = y + h - 1;
  812.     y3 = y;
  814.     XSetForeground(display, gc, textColor);
  815.     XDrawLine(display, win, gc, x1, y1, x2, y2);
  816.     XDrawLine(display, win, gc, x2, y2, x3, y3);
  817. }
  819. void PaintCross(GC gc, int x, int y, unsigned int w, unsigned int h)
  820. {
  821.     XSetForeground(display, gc, strikeColor);
  822.     XDrawLine(display, win, gc, x, y, x+w, y+w);
  823.     XDrawLine(display, win, gc, x, y+w, x+w, y);
  824.     XSetForeground(display, gc, textColor);
  825. }
  827. void PaintField(GC gc, int indent, int baseline, Field *field)
  828. {
  829.     char *s,*pos,*dump;
  830.     int font, active, width, height, x1, y1, y2, r;
  831.     Option *option;
  833.     active = field->flags & CHECKED;
  834.     font = field->flags & 0x0F;
  836.     width = field->width;
  837.     height = field->height;
  839.  /* cache absolute position of baseline */
  840.     field->baseline = Win2Abs(baseline);
  842.     /* kludge for fields in different frames */
  843.     if (indent >= 0)
  844.         field->frame_indent = indent;
  845.     else
  846.         indent = field->frame_indent;
  848.     if (field->type == TEXTFIELD)
  849.     {
  850.         x1 = indent + field->x - PixelIndent - field->x_indent;
  851.         y2 = baseline - ASCENT(font) - 2;
  852.         ClipIntersection(gc, x1, y2, width, height);
  853.         XSetForeground(display, gc, (active ? statusColor : windowColor));
  854.         XFillRectangle(display, win, gc, x1, y2, width, height);
  855.         DrawInSet(win, gc, x1, y2, width, height);
  856.         ClipIntersection(gc, x1+2, y2, width-4, height);
  858.         if (field->buflen > 0)
  859.         {
  860.     dump = (char *)malloc(strlen(field->value)+1);
  861.     strncpy(dump,field->value, field->buflen);
  862.     *(dump+field->buflen)=0;
  863.     pos = dump;
  864.     while(*pos)
  865. if(*pos=='n')
  866.     *pos++=0;
  867. else
  868.     pos++;
  869.     pos = dump;
  870.     while(pos-dump<field->buflen)
  871.     {
  872. y1 = y2 + ASCENT(font) + 2;
  873. SetFont(gc, font);
  874. XSetForeground(display, gc, textColor);
  875. XDrawString(display, win, gc, x1+4, y1, pos, strlen(pos));
  876. y2 += ASCENT(font)+4;
  877. pos += strlen(pos)+1;
  878.     };
  879.     free(dump);
  880.         }
  881.         XSetForeground(display, gc, textColor);
  882.         XSetClipRectangles(display, gc, 0, 0, &displayRect, 1, Unsorted);
  883.     }
  884.     else if (field->type == PASSWD)
  885.     {
  886.         x1 = indent + field->x - PixelIndent - field->x_indent;
  887.         y2 = baseline - ASCENT(font) - 2;
  888.         ClipIntersection(gc, x1, y2, width, height);
  889.         XSetForeground(display, gc, (active ? statusColor : windowColor));
  890.         XFillRectangle(display, win, gc, x1, y2, width, height);
  891.         DrawInSet(win, gc, x1, y2, width, height);
  892.         ClipIntersection(gc, x1+2, y2, width-4, height);
  894.         if (field->buflen > 0)
  895.         {
  896.     int loop_i;
  897.     dump = (char *)malloc(strlen(field->value)+1);
  898.     for(loop_i=0;loop_i<field->buflen;loop_i++)
  899. dump[loop_i] = '*';
  900.     *(dump+field->buflen)=0;
  901.     pos = dump;
  902.     while(*pos)
  903. if(*pos=='n')
  904.     *pos++=0;
  905. else
  906.     pos++;
  907.     pos = dump;
  908.     while(pos-dump<field->buflen)
  909.     {
  910. y1 = y2 + ASCENT(font) + 2;
  911. SetFont(gc, font);
  912. XSetForeground(display, gc, textColor);
  913. XDrawString(display, win, gc, x1+4, y1, pos, strlen(pos));
  914. y2 += ASCENT(font)+4;
  915. pos += strlen(pos)+1;
  916.     };
  917.     free(dump);
  918.         }
  919.         XSetForeground(display, gc, textColor);
  920.         XSetClipRectangles(display, gc, 0, 0, &displayRect, 1, Unsorted);
  921.     }
  922.     else if (field->type == SUBMITBUTTON || field->type == RESETBUTTON)
  923.     {
  924. char *the_string = NULL;
  925. int i, j, k, len, ok;
  927. s = field->value;
  928. if (field->buflen > 0)
  929.         {
  930.     s = field->value;
  931.     the_string = (char *)calloc(strlen(s)+1, sizeof(char));
  932.     len = strlen(s);
  933.     for(i=k=0; i<len; i++,k++)
  934. if(s[i] == '&')
  935. {
  936.     for(ok= FALSE,j=i; !ok && j< len; j++)
  937. ok = ((s[j]==';') || (s[j]==' ')); 
  938.     the_string[k] = entity(s+i+1, &j);
  939.     i += j - 1;
  940. }
  941. else
  942.     the_string[k] = s[i];
  943.     field->width = 8 + WIDTH(font, the_string, strlen(the_string));
  944.     width = field->width;     
  945. };
  946.         x1 = indent + field->x - PixelIndent - field->x_indent;
  947.         y2 = baseline - ASCENT(font) - 2;
  948.         ClipIntersection(gc, x1, y2, width, height);
  949.         XSetForeground(display, gc, windowColor);
  950.         XFillRectangle(display, win, gc, x1, y2, width, height);
  951.         DrawOutSet(win, gc, x1, y2, width, height);
  952.         ClipIntersection(gc, x1+2, y2, width-4, height);
  953.         
  954.         if (field->buflen > 0)
  955.         {
  956.     y1 = y2 + ASCENT(font) + 2;
  957.             SetFont(gc, font);
  958.             XSetForeground(display, gc, textColor);
  959.             XDrawString(display, win, gc, x1+4, y1, the_string, strlen(the_string));
  960.     free(the_string);
  961.         }
  963.         XSetForeground(display, gc, textColor);
  964.         XSetClipRectangles(display, gc, 0, 0, &displayRect, 1, Unsorted);
  965.     }
  966.     else if (field->type == OPTIONLIST)
  967.     {
  968.         x1 = indent + field->x - PixelIndent;
  969.         y2 = baseline - ASCENT(font) - 2;
  970.         XSetForeground(display, gc, windowColor);
  971.         XFillRectangle(display, win, gc, x1, y2, width, height);
  972.         DrawOutSet(win, gc, x1, y2, width, height);
  974.         if (field->flags & MULTIPLE)
  975.         {
  976.             DrawOutSet(win, gc, x1+3+width-height, y2 - 2 + height/3, height-7, 6);
  977.             DrawOutSet(win, gc, x1+3+width-height, y2 - 3 + 2*height/3, height-7, 6);
  978.         }
  979.         else /* single choice menu drawn with one bar */
  980.         {
  981.             DrawOutSet(win, gc, x1+3+width-height, y2 - 3 + height/2, height-7, 6);
  983.             if (*(field->value) == '' && field->options != NULL)
  984.             {
  985.                 field->x_indent = 0;
  986.                 option = field->options;
  987.                 option->flags |= CHECKED;
  988.                 Free(field->value);
  989.                 field->value = strdup(option->label);
  990.             }
  991.         }
  993.         if (field->y_indent > 0 && field->value)
  994.         {
  995.             y1 = y2 + ASCENT(font) + 2;
  996.             SetFont(gc, font);
  997.             XSetForeground(display, gc, textColor);
  998.             XDrawString(display, win, gc, x1+4, y1, field->value, strlen(field->value));
  999.         }
  1001.         XSetForeground(display, gc, textColor);
  1002.     }
  1003.     else if (field->type == CHECKBOX)
  1004.     {
  1005.         x1 = indent + field->x - PixelIndent;
  1006.         y2 = baseline-ASCENT(font) + 2;
  1007.         XSetForeground(display, gc, (active ? statusColor : windowColor));
  1008.         XFillRectangle(display, win, gc, x1, y2, width, width);
  1010.         if (active)
  1011.         {
  1012.             PaintTickMark(gc, x1+3, y2+3, width-6, width-7);
  1013. #if 0
  1014.             XSetForeground(display, gc, windowBottomShadow);
  1015.             XFillRectangle(display, win, gc, x1+3, y2+3, width-6, width-6);
  1016. #endif
  1017.             DrawInSet(win, gc, x1, y2, width, width);
  1018.         }
  1019.         else
  1020.             DrawOutSet(win, gc, x1, y2, width, width);
  1022.         XSetForeground(display, gc, textColor);
  1023.     }
  1024.     else if (field->type == RADIOBUTTON)
  1025.     {
  1026.         x1 = indent + field->x - PixelIndent;
  1027.         y2 = baseline-ASCENT(font)+2;
  1028.         XSetForeground(display, gc, (active ? statusColor : windowColor));
  1029.         XFillArc(display, win, gc, x1, y2, width, width, 0, 360<<6);
  1031.         if (active)
  1032.         {
  1033.             r = width/4;
  1034.             DrawInSetCircle(gc, x1, y2, width, width);
  1035.             XSetForeground(display, gc, windowBottomShadow);
  1036.             width -= r+r;
  1037.             XFillArc(display, win, gc, x1+r, y2+r, width, width, 0, 360<<6);
  1038.         }
  1039.         else
  1040.             DrawOutSetCircle(gc, x1, y2, width, width);
  1042.         XSetForeground(display, gc, textColor);
  1043.     }
  1044. }
  1047. /* use this routine to hide/show cursor by
  1048.    using color = windowShadow/textColor respectively */
  1050. void PaintPopupField(Window popwin,GC gc, int indent, int baseline, Field *field)
  1051. {
  1052.     char *pos,*dump;
  1053.     int font, active, width, height, x1, y1, y2;
  1054.  
  1055.     active = field->flags & CHECKED;
  1056.     font = field->flags & 0x0F;
  1058.     width = field->width;
  1059.     height = field->height;
  1061.     field->baseline = baseline;
  1063.     /* kludge for fields in different frames */
  1064.     if (indent >= 0)
  1065.         field->frame_indent = indent;
  1066.     else
  1067.         indent = field->frame_indent;
  1069.     if (field->type == TEXTFIELD)
  1070.     {
  1071.         x1 = indent + field->x - field->x_indent;
  1072.         y2 = baseline - ASCENT(font) - 2;
  1073. /*        ClipIntersection(gc, x1, y2, width, height); */
  1074.         XSetForeground(display, gc, (active ? statusColor : windowColor));
  1075.         XFillRectangle(display, popwin, gc, x1, y2, width, height);
  1076.         DrawInSet(popwin, gc, x1, y2, width, height);
  1077. /*        ClipIntersection(gc, x1+2, y2, width-4, height);*/
  1079.         if (field->buflen > 0)
  1080.         {
  1081.     dump = (char *)malloc(strlen(field->value)+1);
  1082.     strncpy(dump,field->value, field->buflen);
  1083.     *(dump+field->buflen)=0;
  1084.     pos = dump;
  1085.     while(*pos)
  1086. if(*pos=='n')
  1087.     *pos++=0;
  1088. else
  1089.     pos++;
  1090.     pos = dump;
  1091.     while(pos-dump<field->buflen)
  1092.     {
  1093. y1 = y2 + ASCENT(font) + 2;
  1094. SetFont(gc, font);
  1095. XSetForeground(display, gc, textColor);
  1096. XDrawString(display, popwin, gc, x1+4, y1, pos, strlen(pos));
  1097. y2 += ASCENT(font)+4;
  1098. pos += strlen(pos)+1;
  1099.     };
  1100.     free(dump);
  1101.         }
  1102.         XSetForeground(display, gc, textColor);
  1103. /*  XSetClipRectangles(display, gc, 0, 0, &displayRect, 1, Unsorted);*/
  1104.     }
  1105.     else if (field->type == PASSWD)
  1106.     {
  1107.         x1 = indent + field->x - field->x_indent;
  1108.         y2 = baseline - ASCENT(font) - 2;
  1109. /*     ClipIntersection(gc, x1, y2, width, height);*/
  1110.         XSetForeground(display, gc, (active ? statusColor : windowColor));
  1111.         XFillRectangle(display, popwin, gc, x1, y2, width, height);
  1112.         DrawInSet(popwin, gc, x1, y2, width, height);
  1113. /*       ClipIntersection(gc, x1+2, y2, width-4, height);*/
  1115.         if (field->buflen > 0)
  1116.         {
  1117.     int loop_i;
  1118.     dump = (char *)malloc(strlen(field->value)+1);
  1119.     for(loop_i=0;loop_i<field->buflen;loop_i++)
  1120. dump[loop_i] = '*';
  1121.     *(dump+field->buflen)=0;
  1122.     pos = dump;
  1123.     while(*pos)
  1124. if(*pos=='n')
  1125.     *pos++=0;
  1126. else
  1127.     pos++;
  1128.     pos = dump;
  1129.     while(pos-dump<field->buflen)
  1130.     {
  1131. y1 = y2 + ASCENT(font) + 2;
  1132. SetFont(gc, font);
  1133. XSetForeground(display, gc, textColor);
  1134. XDrawString(display, popwin, gc, x1+4, y1, pos, strlen(pos));
  1135. y2 += ASCENT(font)+4;
  1136. pos += strlen(pos)+1;
  1137.     };
  1138.     free(dump);
  1139.         }
  1140.         XSetForeground(display, gc, textColor);
  1141. /*    XSetClipRectangles(display, gc, 0, 0, &displayRect, 1, Unsorted);*/
  1142.     }
  1143. }
  1145. void PaintCursor(Window win, GC gc,  int indent, int baseline ,Field *field, int pos)
  1146. {
  1147.     int font, active, width, height, x1, y2, r;
  1148.     
  1149.     active = field->flags & CHECKED;
  1150.     font = field->flags & 0x0F;
  1152.     width = field->width;
  1153.     height = field->height;
  1154.     field->baseline = baseline;
  1155.     /* kludge for fields in different frames */
  1156.     if (indent >= 0)
  1157.         field->frame_indent = indent;
  1158.     else
  1159.         indent = field->frame_indent;
  1161.     if (pos > 0)
  1162.         r = WIDTH(font, field->value, pos);
  1163.     else
  1164.         r = 0;
  1166.     x1 = indent + field->x - field->x_indent;
  1167.     y2 = baseline - ASCENT(font) - 2;
  1169.     XSetForeground(display, gc, strikeColor);
  1170.     XFillRectangle(display, win, gc, x1 + ((r)?4:2) + r, y2+2, 1,ASCENT(font)+2);
  1171.     XSetForeground(display, gc, textColor);
  1172. }
  1174. void PaintFieldCursor(GC gc, unsigned long color)
  1175. {
  1176.     int font, width, height, x1, y2, r;
  1178.     font = focus->flags & 0x0F;
  1180.     width = focus->width;
  1181.     height = focus->height;
  1182.     x1 = focus->x - PixelIndent - focus->x_indent;
  1183.     y2 = focus->baseline - ASCENT(font) - 2;
  1185.     if (focus->buflen > 0)
  1186.         r = WIDTH(font, focus->value, cursorpos);
  1187.     else
  1188.         r = 0;
  1190.     XSetForeground(display, gc, color);
  1191.     XFillRectangle(display, win, gc, x1 + 3 + r, y2+2, 1, height-4);
  1192. }
  1194. /*
  1195.    Repair a given area of a field - called by ScrollField()
  1196.    also useful when typing a char into field
  1197. */
  1198. void RepairField(GC gc, int start, int width)
  1199. {
  1200.     int font, height, x1, y1, y2, r;
  1201.     XRectangle rect;
  1203.     font = focus->flags & 0x0F;
  1205.     width = focus->width;
  1206.     height = focus->height;
  1207.     x1 = focus->x - PixelIndent - focus->x_indent;
  1209.     rect.x = start;
  1210.     rect.y = focus->baseline - ASCENT(font);
  1211.     rect.width = width;
  1212.     rect.height = focus->height - 4;
  1213.     XSetClipRectangles(display, gc, 0, 0, &rect, 1, Unsorted);
  1215.     y2 = focus->baseline - ASCENT(font) - 2;
  1216.     XSetForeground(display, gc, statusColor);
  1217.     XFillRectangle(display, win, gc, x1, y2, width, height);
  1219.     if (focus->buflen > 0)
  1220.     {
  1221.         y1 = y2 + ASCENT(font) + 2;
  1222.         SetFont(gc, font);
  1223.         XSetForeground(display, gc, textColor);
  1224.         XDrawString(display, win, gc, x1+4, y1, focus->value, focus->buflen);
  1225.     }
  1227.     if (focus->buflen > 0)
  1228.         r = WIDTH(font, focus->value, cursorpos);
  1229.     else
  1230. r = 0;
  1232.     XSetForeground(display, gc, strikeColor);
  1233.     XFillRectangle(display, win, gc, x1 + 3 + r, y2+2, 1, height-4);
  1235.     rect.x = focus->x + 2;
  1236.     rect.y = focus->baseline - ASCENT(font);
  1237.     rect.width = focus->width - 4;
  1238.     rect.height = focus->height - 4;
  1239.     XSetClipRectangles(display, gc, 0, 0, &rect, 1, Unsorted);
  1240. }
  1242. /*
  1243.    Text field lies in rectangle box, scroll it horizontally
  1244.    by delta pixels and repair exposed area. When scrolling to left
  1245.    restrict scroll area to right of "start"
  1247.    delta is greater than zero for right scrolls
  1248.    and less than zero for left scrolls
  1250.    Useful for backspace, del char, and cursor motion
  1251.    at extreme limits of field
  1252. */
  1254. void ScrollField(GC gc, int toleft, int start, int delta)
  1255. {
  1256.     XRectangle rect;
  1257.     int width;
  1259.     rect.x  = focus->x + 2;
  1260.     rect.y = focus->baseline - ASCENT(font);
  1261.     rect.width = focus->width - 4;
  1262.     rect.height = focus->height - 4;
  1263.     XSetClipRectangles(display, gc, 0, 0, &rect, 1, Unsorted);
  1265.     if (delta < 0)  /* scroll left: delta < 0 */
  1266.     {
  1267.         if (start <= rect.x)
  1268.         {
  1269.             XCopyArea(display, win, win, gc,
  1270.                     rect.x - delta, rect.y,
  1271.                     rect.width + delta, rect.y,
  1272.                     rect.x, rect.y);
  1274.             RepairField(gc, rect.x + rect.width + delta, -delta);
  1275.         }
  1276.         else if (start < rect.x + rect.width /* width */) /* 12-Mar-96 herman@htbrug.hobby.nl */
  1277.         {
  1278.             width = rect.width + rect.x - start + delta;
  1280.             XCopyArea(display, win, win, gc,
  1281.                     start - delta, rect.y,
  1282.                     width, rect.y,
  1283.                     rect.x, rect.y);
  1285.             RepairField(gc, start + width, -delta);
  1286.         }
  1287.     }
  1288.     else  /* scroll right: delta is > 0 */
  1289.     {
  1290.         if (delta < rect.width)
  1291.         {
  1292.             XCopyArea(display, win, win, gc,
  1293.                     rect.x, rect.y,
  1294.                     rect.width - delta, rect.y,
  1295.                     rect.x + delta, rect.y);
  1297.             RepairField(gc, rect.x, delta);
  1298.         }
  1299.     }
  1300. }
  1303. char *WWWEncode(char *raw)
  1304. {
  1305.     int i,rlen;
  1306.     char *encoded,*j;
  1307.     
  1308.     rlen = strlen(raw);
  1309.     encoded=(char *)malloc(3*rlen+1); /* max size = size*3 */
  1310.     j=encoded;
  1311.     for(i=0;i<rlen;i++)
  1312.     {
  1313. if( *(raw+i) ==' ')
  1314.     *j++ = '+';       
  1315. else if ((*(raw+i) == '-')||(*(raw+i) == '_'))
  1316.     *j++=*(raw+i);
  1317. else if ((*(raw+i) < '0' ) || ((*(raw+i)<'A')&&(*(raw+i)>'9'))){
  1318.     *j++ = '%';
  1319.     sprintf(j,"%X",*(raw+i));
  1320.     j+=(*(raw+i)<16)? 1 :2;
  1321. } else if ((*(raw+i) > 'z') || ((*(raw+i)<'a')&&(*(raw+i)>'Z'))){
  1322.     *j++ = '%';
  1323.     sprintf(j,"%X",*(raw+i));
  1324.     j+=2;
  1325. } else 
  1326.     *j++=*(raw+i);
  1327.     };
  1328.     *j=0;
  1329.     j = (char *)malloc(strlen(encoded)+1);
  1330.     strcpy(j, encoded); /* we copy the string again to save the extra space allocated */
  1331.     free(encoded);
  1332.     return (j);
  1333. }
  1336. void SubmitForm(Form *form, int method, char *action, int alen, int type,
  1337.  char *name, int nlen, char *value, int vlen, Image *image,int dx, int dy, char *bufpos)
  1338. {
  1339.     char *query,*encoded,*encode_buffer;
  1340.     EditorBuffer *buffer;
  1341.     char itoabuff[32];
  1342.     Field *field,*field_link;
  1343.     Option *option;
  1344.     int first,size;
  1346.     buffer = CreateBuffer();
  1348.     first = (method == GET);
  1350.     if (image != NULL)
  1351.     {
  1352. if(first)
  1353.     AppendChar(buffer,'?');
  1354. AppendnChar(buffer, name, nlen);
  1355. AppendString(buffer, ".x=");
  1356. sprintf(itoabuff,"%d&", dx);
  1357. AppendString(buffer, itoabuff);
  1358. AppendnChar(buffer, name, nlen);
  1359. AppendString(buffer,".y=");
  1360. sprintf(itoabuff,"%d",dy);
  1361. AppendString(buffer,itoabuff);
  1362. field = FindField(form,type,name,nlen);
  1363. first = 0;
  1364.     }
  1365.     else
  1366.     {
  1367. if(nlen)
  1368.     if(vlen)
  1369.     {
  1370. if(first)
  1371.     AppendChar(buffer,'?');
  1372. AppendnChar(buffer,name,nlen);
  1373. AppendChar(buffer,'=');
  1374. encode_buffer = (char *)calloc( vlen+1, sizeof(char));
  1375. strncpy(encode_buffer,value,vlen);
  1376. *(encode_buffer+vlen)=0;
  1377. encoded = WWWEncode(encode_buffer);
  1378. AppendString(buffer,encoded); /* thanks to Marc Salomon <marc@ckm.ucsf.edu> */
  1379. free(encode_buffer);
  1380. free(encoded);
  1381. field = FindField(form,type,name,nlen);
  1382. first = 0;
  1383.     }
  1384.     else
  1385.     {
  1386. if(first)
  1387.     AppendChar(buffer,'?');
  1388. AppendnChar(buffer,name,nlen);
  1389. AppendString(buffer,"=Submit+Query");
  1390. field = FindField(form,type,name,nlen);
  1391. first = 0;
  1392.     }
  1393. else
  1394. {
  1395.     first = (method == GET) ? 1 : 2;
  1396.     field = FindField(form,type,bufpos,7);
  1397. }
  1398.     };
  1399.     for( field_link=form->fields ; field_link!=NULL; field_link = field_link->next)
  1400.     {
  1401. if( field_link!= field)
  1402. {
  1403.     switch (field_link->type)
  1404.     {
  1405.     case SUBMITBUTTON:
  1406.     case RESETBUTTON:
  1407. break;
  1408.     case RADIOBUTTON:
  1409. if(!(field_link->flags & CHECKED))
  1410.     break;
  1411.     case HIDDEN:
  1412.     case TEXTFIELD:
  1413. if(first)
  1414. {
  1415.     if(first == 1)
  1416. AppendChar(buffer,'?');
  1417.     first=0;
  1418. }
  1419. else
  1420.     AppendChar(buffer,'&');
  1422. encode_buffer = (char *) calloc( field_link->nlen+1, sizeof(char));
  1423. strncpy(encode_buffer, field_link->name, field_link->nlen);
  1424. *(encode_buffer+field_link->nlen)=0;
  1425. encoded = WWWEncode(encode_buffer);
  1426. AppendString(buffer, encoded);
  1427. free(encoded);
  1428. free(encode_buffer);
  1429. AppendChar(buffer, '=');
  1430. encode_buffer = (char *) calloc( field_link->buflen+1, sizeof(char));
  1431. strncpy(encode_buffer,field_link->value,field_link->buflen);
  1432. *(encode_buffer+field_link->buflen)=0;
  1433. encoded = WWWEncode(encode_buffer);
  1434. AppendString(buffer, encoded);
  1435. free(encoded);
  1436. free(encode_buffer);
  1437. break;
  1438.     case CHECKBOX:
  1439. if(field_link->flags & CHECKED)
  1440. {
  1441.     if(first)
  1442.     {
  1443. if(first == 1)
  1444.     AppendChar(buffer,'?');
  1445. first = 0;
  1446.     }
  1447.     else
  1448. AppendChar(buffer,'&');
  1449.     encode_buffer = (char *) calloc( field_link->nlen+1, sizeof(char));
  1450.     strncpy(encode_buffer, field_link->name, field_link->nlen);
  1451.     *(encode_buffer+field_link->nlen)=0;
  1452.     encoded = WWWEncode(encode_buffer);
  1453.     AppendString(buffer, encoded);
  1454.     free(encoded);
  1455.     free(encode_buffer);
  1456.     AppendString(buffer, "=on");
  1457. };
  1458. break; 
  1459.     case OPTIONLIST:
  1460. if(field_link->flags & MULTIPLE)
  1461. {
  1462.     for (option = field_link->options; option; option = option->next)
  1463.     {
  1464. if((option->flags & CHECKED) == CHECKED)
  1465. {
  1466.     if(first)
  1467.     {
  1468. if(first == 1)
  1469.     AppendChar(buffer,'?');
  1470. first = 0;
  1471.     }
  1472.     else
  1473. AppendChar(buffer,'&');
  1474.     
  1475.     encode_buffer = (char *) calloc( field_link->nlen+1, sizeof(char));
  1476.     strncpy(encode_buffer, field_link->name, field_link->nlen);
  1477.     *(encode_buffer+field_link->nlen)=0;
  1478.     encoded = WWWEncode(encode_buffer);
  1479.     AppendString(buffer, encoded);
  1480.     free(encoded);
  1481.     free(encode_buffer);
  1482.     AppendChar(buffer, '=');
  1483.     size = strlen(option->label);
  1484.     if(size)
  1485. if(field_link->value[size-1]==' ')
  1486.     field_link->value[size-1]=0;  /* "eat" the last blank */
  1487.     encode_buffer = (char *) calloc( strlen(option->label)+1, sizeof(char));
  1488.     strcpy(encode_buffer,option->label);
  1489.     encoded = WWWEncode(encode_buffer);
  1490.     AppendString(buffer, encoded);
  1491.     free(encoded);
  1492.     free(encode_buffer);
  1493. };
  1494.     }
  1495. }
  1496. else
  1497. {
  1498.     if(first)
  1499.     {
  1500. if(first == 1)
  1501.     AppendChar(buffer,'?');
  1502. first = 0;
  1503.     }
  1504.     else
  1505. AppendChar(buffer,'&');
  1506.     
  1507.     encode_buffer = (char *) calloc( field_link->nlen+1, sizeof(char));
  1508.     strncpy(encode_buffer, field_link->name, field_link->nlen);
  1509.     *(encode_buffer+field_link->nlen)=0;
  1510.     encoded = WWWEncode(encode_buffer);
  1511.     AppendString(buffer, encoded);
  1512.     free(encoded);
  1513.     free(encode_buffer);
  1514.     AppendChar(buffer, '=');
  1515.     size = strlen(field_link->value);
  1516.     if(size)
  1517. if(field_link->value[size-1]==' ')
  1518.     field_link->value[size-1]=0;  /* "eat" the last blank */
  1519.     encode_buffer = (char *) calloc( strlen(field_link->value)+1, sizeof(char));
  1520.     strcpy(encode_buffer,field_link->value);
  1521.     encoded = WWWEncode(encode_buffer);
  1522.     AppendString(buffer, encoded);
  1523.     free(encoded);
  1524.     free(encode_buffer);
  1525. };
  1526. break;
  1527.     };
  1528. };
  1529.     }
  1530.     switch(method)
  1531.     {
  1532.     case GET:
  1533. if(action)
  1534.     InsertnChar(buffer,0,action,alen);
  1535. else
  1536.     InsertString(buffer,0,CurrentDoc->href);
  1537. query = Buffer2Str(buffer);
  1538. /* printf("fetching |%s|n",query); */
  1539. OpenDoc(query);
  1540. break;
  1541.     case POST:
  1542. encoded = Buffer2Str(buffer);
  1543. query = (char *) calloc(alen+1, sizeof(char));
  1544. strncpy(query, action, alen);
  1545. *(query+alen)=0;
  1546. PostDoc(query, encoded); 
  1547. /* printf("posting [%s][%s]n",query,encoded); */
  1548. break;
  1549.     };
  1550. }
  1552. void PaintFieldCursorBuffer(GC gc, unsigned long color, EditorBuffer *buffer, Field *field)
  1553. {
  1554.     int font, width, height, x1, y2, r;
  1555.     int numline;
  1556.     int numcol;
  1558.     font = field->flags & 0x0F;
  1559.     numline = LineNumber(buffer);
  1560.     width = field->width;
  1561.     height = field->height;
  1562.     x1 = field->x - PixelIndent - field->x_indent ;
  1563.     y2 = Abs2Win(field->baseline) + (numline-1)*(ASCENT(font)+4);
  1564.     ClipIntersection(gc, x1+2, Abs2Win(field->baseline) - ASCENT(font) - 4, width-4, height);
  1565.     numcol = ColNumber(buffer);
  1566.     if (buffer->size > 0)
  1567.         r = WIDTH(font, field->value + buffer->pos - numcol, numcol);
  1568.     else
  1569.         r = 0;
  1570.     
  1571.     XSetForeground(display, gc, color);
  1572.     XFillRectangle(display, win, gc, x1 + 7 + r, y2+4, 1,ASCENT(font)+4);
  1573.     XSetForeground(display, gc, textColor);
  1574.     XSetClipRectangles(display, gc, 0, 0, &displayRect, 1, Unsorted);
  1575. }
  1577. #if 0
  1578. void PaintFieldEditor(GC gc, int indent, int baseline, Field *field) /* to display editor --Spif 28-Nov-95 */
  1579. {
  1580.     char *s,*pos,*dump;
  1581.     int font, active, width, height, x1, y1, y2, r;
  1582.     Option *option;
  1583.     
  1584.     active = field->flags & CHECKED;
  1585.     font = field->flags & 0x0F;
  1586.     
  1587.     width = field->width;
  1588.     height = field->height;
  1589.     
  1590.     /* cache absolute position of baseline */
  1591.     field->baseline = Win2Abs(baseline);
  1593.     /* kludge for fields in different frames */
  1594.     if (indent >= 0)
  1595.         field->frame_indent = indent;
  1596.     else
  1597.         indent = field->frame_indent;
  1599.     if (field->type == TEXTFIELD)
  1600.     {
  1601.         x1 = indent + field->x - PixelIndent - field->x_indent;
  1602.         y2 = baseline - ASCENT(font) - 2;
  1603.         ClipIntersection(gc, x1, y2, width, height);
  1604.         XSetForeground(display, gc, (active ? statusColor : windowColor));
  1605.         XFillRectangle(display, win, gc, x1, y2, width, height);
  1606.         DrawInSet(win, gc, x1, y2, width, height);
  1607.         ClipIntersection(gc, x1+2, y2, width-4, height);
  1609.         if (field->buflen > 0)
  1610.         {
  1611.     dump = (char *)malloc(strlen(field->value)+1);
  1612.     strcpy(dump,field->value);
  1613.     pos = dump;
  1614.     while(*pos)
  1615. if(*pos=='n')
  1616.     *pos++=0;
  1617. else
  1618.     pos++;
  1619.     pos = dump;
  1620.     while(pos-dump<field->buflen)
  1621.     {
  1622. printf("[%s]n",pos);
  1623. y1 = y2 + ASCENT(font) + 2;
  1624. SetFont(gc, font);
  1625. XSetForeground(display, gc, textColor);
  1626. XDrawString(display, win, gc, x1+4, y1, pos, strlen(pos));
  1627. y2 += ASCENT(font)+4;
  1628. pos += strlen(pos)+1;
  1629.     };
  1630.     free(dump);
  1631.         }
  1633.         if (active)
  1634.         {
  1635.             if (field->buflen > 0)
  1636.                 r = WIDTH(font, field->value, cursorpos);
  1637.             else
  1638.                 r = 0;
  1640.             XSetForeground(display, gc, strikeColor);
  1641.             XFillRectangle(display, win, gc, x1 + 3 + r, y2+2, 1, SPACING(Fonts[font]));
  1642.         }
  1644.         XSetForeground(display, gc, textColor);
  1645.         XSetClipRectangles(display, gc, 0, 0, &displayRect, 1, Unsorted);
  1646.     }
  1647. }
  1648. #endif