/********************************************************************
* lindner
* 3.7
* 1994/07/03 23:10:57
* /home/arcwelder/GopherSrc/CVS/gopher+/gopher/form.c,v
* Exp
*
* Paul Lindner, University of Minnesota CIS.
*
* Copyright 1991, 92, 93, 94 by the Regents of the University of Minnesota
* see the file "Copyright" in the distribution for conditions of use.
*********************************************************************
* MODULE: form.c
* Form definition and management functions
*********************************************************************
* Revision History:
* form.c,v
* Revision 3.7  1994/07/03  23:10:57  lindner
* fix forms..
*
* Revision 3.6  1994/05/19  14:07:24  lindner
* use fast malloc on VMS VAXC
*
* Revision 3.5  1994/04/01  02:24:56  lindner
* Fix return types
*
* Revision 3.4  1994/03/08  15:55:05  lindner
* gcc -Wall fixes
*
* Revision 3.3  1994/03/04  23:39:50  lindner
* Fix for log entries
*
* Revision 3.2  1994/03/04  23:36:32  lindner
* bug fixes.
*
* Revision 3.1  1994/02/20  16:15:44  lindner
* New form definition and management functions
*
*
*********************************************************************/

#include "form.h"

#include "String.h"
#include "GSgopherobj.h"
#include "BLblock.h"
#include "Malloc.h"
#include "CURcurses.h"
#include "gopher.h"

/** Make a new item... **/

ITEM *
ITEMnew()
{
    ITEM *temp;

    temp = (ITEM*) malloc(sizeof(ITEM));

    temp->type     = ITEM_UNINIT;
    temp->label    = STRnew();
    temp->response = STRnew();

    temp->chooseitem = -1;
    temp->choices  = STAnew(3);

    return(temp);
}


/*
* Clear out a specific item
*/

void
ITEMinit(item)
 ITEM *item;
{
    item->type = ITEM_UNINIT;

    STRinit(item->label);
    STRinit(item->response);
    STAinit(item->choices);
    item->chooseitem=0;
}

/*
* Copy an item
*/

ITEM*
ITEMcpy(dest, orig)
 ITEM *dest, *orig;
{
    dest->type  = orig->type;
    STRset(dest->label, STRget(orig->label));
    STRset(dest->response, STRget(orig->response));

    dest->chooseitem = orig->chooseitem;
    STAcpy(dest->choices, orig->choices);

    return(dest);
}

/*
* Nuke a defined ITEM
*/

void
ITEMdestroy(item)
 ITEM *item;
{
    STRdestroy(item->label);
    STRdestroy(item->response);

    STAdestroy(item->choices);
    free(item);
}

/*
* Add an item to the list of choices..
*/

void
ITEMpushChoice(item, choice)
 ITEM *item;
 char *choice;
{
    String *str;

    str = STRnew();

    STRset(str, choice);
    STApush(item->choices, str);

    STRdestroy(str);
}



/*************************************************************************
* Form definition routines..  Pretty swanky..
*/

FORM*
FORMfromASK(gs)
 GopherObj *gs;
{
    int Asknum;
    Blockobj *bl;
    char askline[256];
    char *defaultval;
    int i;
    char ** responses = NULL;
    ITEM *item;
    FORM *form;

    GSgetginfo(gs, TRUE);

    bl = GSfindBlock(gs, "ASK");

    if (bl == NULL)
         return(NULL);

    form = FORMnew(BLgetNumLines(bl));

    for (Asknum=0; Asknum <BLgetNumLines(bl); Asknum++) {
         char *askprompt, *cp;

         strcpy(askline, BLgetLine(bl, Asknum));

         /*** find the type of question ***/
         askprompt = strchr(askline, ':');

         if (askprompt == NULL) {
              /* Empty line crashes CURRequest unless do this*/
              FORMaddLabel(form, "");
              continue;
         }
         *(askprompt+1) = '\0';
         askprompt+=2;

         /*** Zap the tabs, and load it up.. ***/
         cp = strchr(askprompt, '\t');
         if (cp != NULL) {
              defaultval = cp+1;
              *cp = '\0';
         } else
              defaultval = NULL;


         if (strncasecmp(askline, "Note:", 5) == 0)
              FORMaddLabel(form, askprompt);

         else if (strncasecmp(askline, "Choose:", 7) == 0) {
              int cnum = 0;
              char **choices;

              choices = (char**) malloc(sizeof(char*)*100);

              /*** add list of choices to struct **/
              while ((cp = strchr(defaultval, '\t')) != NULL) {
                   *cp = '\0';
                   choices[cnum++] = defaultval;
                   defaultval = cp+1;
              }
              if (defaultval != NULL)
                   choices[cnum++] = strdup(defaultval);

              choices[cnum++] = NULL;

              FORMaddChoice(form, askprompt, choices, 0);
         }

         else if (strncasecmp(askline, "Select:", 7) == 0) {
              int chooseitem = 0;

              cp = strrchr(askprompt, ':');
              if (cp != NULL) {
                   *cp = '\0';
                   cp++;
                   if (*cp == '1')
                        chooseitem = 1;
              }

              FORMaddSelect(form, askprompt, chooseitem);
         }
         else if (strncasecmp(askline, "AskP:", 5)==0)
              FORMaddPasswd(form, askprompt, defaultval);
         else if (strncasecmp(askline, "AskL:", 5)==0)
              FORMaddLong(form, askprompt, defaultval);
         else if (strncasecmp(askline, "Choosef:", 8) == 0)
              FORMaddFilechoice(form, askprompt, defaultval);
         else
              FORMaddPrompt(form, askprompt, defaultval);
    }


}

char**
FORMgetAskdata(gs, form, Asknum)
 GopherObj *gs;
 FORM *form;
 int  Asknum;
{
    char **responses;
    int i;
    ITEM *item;


    if (!CURform(CursesScreen, GSgetTitle(gs), form)) {
         int respnum = 0;

         responses = (char**) malloc(sizeof(char*)*(1+Asknum));

         for (i=0; i <Asknum; i++) {
              item = FORMgetEntry(form, i);

              switch (ITEMgetType(item)) {
              case ITEM_LONG:
                   responses[respnum++] = strdup("1");
                   responses[respnum++] = strdup(ITEMgetResponse(item));
                   break;

              case ITEM_SELECT:
                   if (ITEMgetChoice(item) == 0)
                        responses[respnum++] = strdup("0");
                   else
                        responses[respnum++] = strdup("1");

                   break;

              case ITEM_CHOICE:
                   responses[respnum++] = strdup(ITEMgetChoiceNum(item, ITEMgetChoice(item)));
                   break;
              case ITEM_PROMPT:
              case ITEM_PASSWD:
                   responses[respnum++] = strdup(ITEMgetResponse(item));
              }
         }
         responses[respnum++] = NULL;
    }
    /*** Free memory ***/
    FORMdestroy(form);

    return(responses);
}


boolean
FORMaddLabel(form, label)
 FORM *form;
 char *label;
{
    ITEM *item;

    item = ITEMnew();

    ITEMsetType(item, ITEM_LABEL);
    ITEMsetLabel(item, label);

    FORMpush(form, item);

    ITEMdestroy(item);

    return(TRUE);
}


boolean
FORMaddPrompt(form, prompt, defval)
 FORM *form;
 char *prompt;
 char *defval;
{
    ITEM *item;

    item = ITEMnew();
    ITEMsetType(item, ITEM_PROMPT);
    if (prompt != NULL)
         ITEMsetLabel(item, prompt);
    else
         ITEMsetLabel(item, "");

    if (defval != NULL)
         ITEMsetResponse(item, defval);
    else
         ITEMsetResponse(item, "");

    FORMpush(form, item);

    ITEMdestroy(item);

    return(TRUE);
}

boolean
FORMaddPasswd(form, prompt, defval)
 FORM *form;
 char *prompt;
 char *defval;
{
    FORMaddPrompt(form, prompt, defval);
    ITEMsetType(FORMgetEntry(form, FORMgetTop(form)-1), ITEM_PASSWD);

    return(TRUE);
}

boolean
FORMaddFilechoice(form, prompt, defval)
 FORM *form;
 char *prompt;
 char *defval;
{
    FORMaddPrompt(form, prompt, defval);
    ITEMsetType(FORMgetEntry(form, FORMgetTop(form)-1), ITEM_FILENAME);

    return(TRUE);
}


boolean
FORMaddLong(form, prompt, defval)
 FORM *form;
 char *prompt;
 char *defval;
{
    FORMaddPrompt(form, prompt, defval);
    ITEMsetType(FORMgetEntry(form, FORMgetTop(form)-1), ITEM_LONG);

    return(TRUE);
}

/*
* add a multiple choice item..
*/

boolean
FORMaddChoice(form, prompt, choices, defval)
 FORM *form;
 char *prompt;
 char **choices;
 int defval;
{
    ITEM *item;
    int i=0;

    FORMaddPrompt(form, prompt, "");
    item = FORMgetEntry(form, FORMgetTop(form)-1);

    ITEMsetChoice(item, defval);
    ITEMsetType(item, ITEM_CHOICE);

    while (choices[i] != NULL) {
         ITEMpushChoice(item, choices[i]);
         i++;
    }

    return(TRUE);
}


boolean
FORMaddSelect(form, prompt, defval)
 FORM *form;
 char *prompt;
 int defval;
{
    ITEM *item;

    FORMaddPrompt(form, prompt, "");
    item = FORMgetEntry(form, FORMgetTop(form)-1);

    ITEMsetChoice(item, defval);

    ITEMpushChoice(item, "No");
    ITEMpushChoice(item, "Yes");
    ITEMsetType(item, ITEM_SELECT);

    return(TRUE);
}



/*
* Display a form and allow a user to fill it out.
*/

int
CURform(cur,Wintitle,form)
 CursesObj *cur;
 char      *Wintitle;
 FORM      *form;
{
    WINDOW *tempwin;
    int  i,j;
    int  totalprompts;
    int  numprompts=0;
    int  maxpromptwidth =0;
    int  currentfield = 0;
    int  maxlength = COLS-7;
    char TrimmedTitle[128];
    ITEM *item;
    int  ch;
    int  numforms = 1;
    int  currentform = 0;
    int  pagesize = LINES-8;
    int  thisformdone = FALSE;


    /** Find the number of prompts... and the max width***/
    for (totalprompts = 0; totalprompts < FORMgetTop(form); totalprompts++) {
         item = FORMgetEntry(form, totalprompts);

         /*** Skip non editable prompts ***/
         if (item != NULL && ITEMgetType(item) != ITEM_LABEL) {
              if (strlen(ITEMgetPrompt(item)) > maxpromptwidth)
                   maxpromptwidth = strlen(ITEMgetPrompt(item));
         }

         if (totalprompts != 0  && (totalprompts % pagesize) == 0)
              numforms ++;
    }

    if (numforms > 1)
         numprompts = pagesize;
    else
         numprompts = totalprompts;

    if (numprompts == 0) {
         return(-1);
    }

    maxlength -= (maxpromptwidth+1);
    tempwin = newwin(6 + numprompts, COLS-2, (LINES-(6+numprompts))/2,1);
    CURwenter(cur,tempwin);

    while (currentform < numforms) {
         if (currentform == (numforms-1)) {
              numprompts = totalprompts - (pagesize * currentform);
         } else {
              numprompts = pagesize ;
         }
         wstandend(tempwin);
         CURbox(cur,tempwin, 6+numprompts, COLS-2);

         currentfield = 0;

         /*** Add the window title, centered ***/
         if (Wintitle != NULL) {
              /** Trim window title to fit in the window **/
              if (strlen(Wintitle) > COLS-2) {
                   strncpy(TrimmedTitle, Wintitle, COLS-2);
                   TrimmedTitle[COLS-5] = '.';
                   TrimmedTitle[COLS-4] = '.';
                   TrimmedTitle[COLS-3] = '.';
                   TrimmedTitle[COLS-2] = '\0';
              }
              else
                   strcpy(TrimmedTitle, Wintitle);

              /** Put the title, bold **/
              wmove(tempwin, 0,(COLS -2  - strlen(TrimmedTitle))/2);
              wstandout(tempwin);
              waddstr(tempwin, TrimmedTitle);
              wstandend(tempwin);
         }

         /** Add the prompts and typing area **/
         for (i=0; i <numprompts; i++) {

              item = FORMgetEntry(form, i + currentform*pagesize);

              wmove(tempwin, 2+i, 2);
              waddstr(tempwin, ITEMgetPrompt(item));

              switch (ITEMgetType(item)) {

              case ITEM_LABEL:
                   break;

              case ITEM_SELECT:
              case ITEM_CHOICE:
                   /** Add the default **/
                   wmove(tempwin, 2+i, maxpromptwidth +4);
                   waddstr(tempwin, ITEMgetChoiceNum(item, ITEMgetChoice(item)));

                   break;
              default:

                   /** Add the black space for the stowage, **/
                   /** and the stowage, if it exists        **/
                   wmove(tempwin, 2+i, maxpromptwidth +4);
                   wstandout(tempwin);

                   if (ITEMgetType(item) == ITEM_PASSWD) {
                        int numchars = strlen(ITEMgetResponse(item));

                        for (j=0; j<numchars; j++)
                             waddch(tempwin, '*');
                   } else
                        waddstr(tempwin, ITEMgetResponse(item));

                   for (j=strlen(ITEMgetResponse(item))+maxpromptwidth+4;
                        j< COLS-6; j++) {
                        waddch(tempwin, ' ');
                   }
                   wstandend(tempwin);
              }
         }

         /** Add the labels, centered **/
         wmove(tempwin, 3 + numprompts, (COLS-63)/2);
         CURbutton(cur, tempwin, "Switch Fields: TAB", FALSE);

         CURbutton(cur, tempwin, "Cancel: ^G", FALSE);
         waddch(tempwin, ' ');
         CURbutton(cur, tempwin, "Erase: ^U", FALSE);
         waddch(tempwin, ' ');
         CURbutton(cur, tempwin, "Accept: Enter", FALSE);

         touchwin(tempwin);
         wrefresh(tempwin);

         thisformdone = FALSE;

         while (!thisformdone) {
              boolean hidden;
              int     oldchoice;

              item = FORMgetEntry(form, currentfield + currentform*pagesize);

              if (ITEMgetType(item) == ITEM_PASSWD)
                   hidden = TRUE;
              else
                   hidden = FALSE;

              wmove(tempwin, 2+currentfield, maxpromptwidth +4);

              wrefresh(tempwin);

              if (ITEMgetType(item) == ITEM_CHOICE ||
                  ITEMgetType(item) == ITEM_SELECT) {
                   int choice = ITEMgetChoice(item);
                   int done = FALSE;

                   wmove(tempwin, 4+numprompts, (COLS-22)/2);
                   CURbutton(cur, tempwin, "Cycle Values: SPACE", FALSE);
                   wmove(tempwin, 2+currentfield, maxpromptwidth +
                         strlen(ITEMgetChoiceNum(item, choice)) +4);

                   wrefresh(tempwin);


                   while (!done) {
                        ch = CURgetch(cur);
                        oldchoice = choice;
                        if (ch == ' ')
                             choice ++;
                        else
                             done = TRUE;

                        if (choice == ITEMgetNumChoices(item))
                             choice = 0;

                        /*** Erase old choice.. ***/
                        wmove(tempwin, 2+currentfield, maxpromptwidth + 4);

                        for (i=strlen(ITEMgetChoiceNum(item, oldchoice)); i>0; i--)
                             waddch(tempwin, ' ');

                        wmove(tempwin, 2+currentfield, maxpromptwidth + 4);

                        waddstr(tempwin, ITEMgetChoiceNum(item,choice));
                        ITEMsetChoice(item, choice);
                        wrefresh(tempwin);
                   }
                   wmove(tempwin, 4+numprompts, (COLS-22)/2);
                   waddstr(tempwin, "                       ");

              } else if (ITEMgetType(item) == ITEM_LABEL)
                   ch = '\t';
              else {
                   char tmpbuffer[256];
                   tmpbuffer[0] = '\0';

                   if (ITEMgetResponse(item) != NULL)
                        strcpy(tmpbuffer, ITEMgetResponse(item));

                   ch = CURwgetstr(cur,tempwin,ITEMgetResponse(item),
                                   maxlength, hidden);

                   ITEMsetResponse(item, tmpbuffer);
              }

              switch (ch) {

              case '\t':
              case KEY_DOWN:
                   /*** Move to another field ***/
                   do {
                        currentfield = (currentfield +1) % numprompts;
                   } while (currentfield == numprompts ||
                            ITEMgetType(FORMgetEntry(form, currentfield +
                                                     currentform * pagesize))
                            == ITEM_LABEL);
                   break;

              case KEY_UP:
                   do {
                        currentfield--;
                        if (currentfield <0)
                             currentfield = numprompts-1;
                   } while (ITEMgetType(FORMgetEntry(form, currentfield +
                                                     currentform * pagesize))
                             == ITEM_LABEL);

                   break;

              case '\007':
              case -1:
                   /*** Cancel ***/
                   delwin(tempwin);
                   return(-1);

              case '\n':
                   currentform++;
                   if (currentform == numforms) {
                        delwin(tempwin);
                        return(0);
                   } else {
                        wclear(tempwin);
                        thisformdone = TRUE;
                   }
                   break;
              }

         }

    }

}

You are viewing proxied material from bitreich.org. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.