home *** CD-ROM | disk | FTP | other *** search
/ QBasic & Borland Pascal & C / Delphi5.iso / C / Samples / CSAPE32.ARJ / SOURCE / CSSRC / SDGO.C < prev    next >
Encoding:
C/C++ Source or Header  |  1990-10-19  |  6.6 KB  |  276 lines
  1. /*
  2.     sdgo.c
  3.  
  4.     % sed_ReallyGo    (activation and field function handling)
  5.  
  6.     Contains sed_ReallyGo() and
  7.     routines for calling the field functions.
  8.     If function address is NULL then perform the default action.
  9.  
  10.     default actions:
  11.  
  12.     fenter(sed) { }
  13.     fkey(sed) {    sed_ToggleExit(sed); }
  14.     fexit(sed) { return(TRUE); }
  15.     senter(sed, fieldno) { }
  16.     sexit(sed, fieldno)    { }
  17.  
  18.     C-scape 3.2
  19.     Copyright (c) 1986, 1987, by Oakland Group, Inc.
  20.     ALL RIGHTS RESERVED.
  21.  
  22.     Revision History:
  23.     -----------------
  24.     11/08/86 jmd    written
  25.     11/09/86 jmd    tested and placed into sdgo.c file
  26.     11/10/86 jmd    added protected mode
  27.      1/22/87 jmd    moved senter funcs to sed_Repaint()
  28.      3/28/87 jmd    added cursor control and active mode.
  29.      9/23/87 jmd    removed field_funcs cast.
  30.     11/18/87 jmd     changed names of some low-level funcs
  31.     11/19/87 jmd     changed menu_GetFieldFuncs to menu_GetFuncs
  32.      4/05/88 jmd     added sed_DoSpecial()
  33.      4/08/88 jmd     changed sed->fieldcount to sed_GetFieldCount()
  34.      6/30/88 jmd     removed cursor save
  35.      7/07/88 jmd     added sed_DoMsg()
  36.      9/14/88 jmd     changed cursor handling
  37.     10/02/88 jmd     added win_MakeCurrent
  38.     10/19/88 jmd     added test for bad fieldno
  39.     11/19/88 jmd     changed to sed_ReallyGo, removed sed_DoMsg
  40.     12/10/88 jmd     added mousecode reset
  41.  
  42.      3/24/89 jmd    added sed_ macros
  43.      4/06/89 jmd    changed true to otrue
  44.      4/26/89 jmd    added Aux support
  45.      8/23/89 jmd    Added cache flag support
  46.  
  47.     11/10/89 jmd    now resets fieldpos when needed
  48.     12/10/89 jmd    added SED_GO aux messages
  49.      3/14/90 jmd    added additional Cache/Flush calls
  50.      3/17/90 jmd    added PREFEXIT message
  51.      3/28/90 jmd    ansi-fied
  52.  
  53.      7/19/90 jmd    added test for NULL sed in sed_DoAux
  54.      7/29/90 jmd    removed sed_DoAux
  55.      8/04/90 jmd    removed SED_GO aux message, now handled by win_Go
  56.     10/18/90 jmd    added SED_POSTFENTER message (under protest)
  57. */
  58.  
  59. #include "sed.h"
  60.  
  61. int sed_ReallyGo(sed_type sed)
  62. /*
  63.     This is the REAL sed Go function.  It is called from the 
  64.     sed window class.  It activates the sed and controls the
  65.     field functions.  It is attached to the sed as a wingo_func.
  66.     It returns the value of the sed's baton.
  67. */
  68. {
  69.     register int     i;
  70.     register int    first_fld;
  71.  
  72.     cs_Assert(sed_Ok(sed), CS_SD_GO_SED, 0);
  73.  
  74.     if (sed_GetFieldCount(sed) == 0) {
  75.         /* empty sed */
  76.         return(sed_GetBaton(sed));
  77.     }
  78.     else if (sed_GetFieldNo(sed) < 0) {
  79.         /* If someone deleted all the fields and then put some back... */
  80.         /* or if we added fields after creating the sed */
  81.         sed_SetFieldNo(sed, 0);
  82.  
  83.         /* reset the current field pointer */
  84.         sed_SetCurrField(sed, menu_GetField(sed_GetMenu(sed), sed_GetFieldNo(sed)));
  85.  
  86.         /* reset the current field position */
  87.         sed_SetRecordPos(sed, menu_GetFirstFieldPos(sed_GetMenu(sed), sed_GetFieldNo(sed)));
  88.     }
  89.  
  90.     /*    Find the first unprotected field (starting with current field) */
  91.     for (first_fld = sed_GetFieldNo(sed); first_fld < sed_GetFieldCount(sed); first_fld++) {
  92.         if (!menu_IsProtected(sed_GetMenu(sed), first_fld)) {
  93.             break;
  94.         }
  95.     }
  96.  
  97.     if (first_fld >= sed_GetFieldCount(sed)) {
  98.         /* no unprotected fields found */
  99.         return(sed_GetBaton(sed));
  100.     }
  101.  
  102.      /* Reset exit_toggle. */
  103.     sed_SetExit(sed, FALSE);
  104.  
  105.     /* Set active mode */
  106.     sed_SetActive(sed, TRUE);
  107.  
  108.     /* Save the cursor type */
  109.     sed_SetCtype(sed, sed_GetCursorType(sed));
  110.  
  111.     disp_Cache();
  112.  
  113.     /* make sure field is visible */
  114.     sd_scroll_adjust(sed, first_fld);
  115.  
  116.     /* highlight active field */
  117.     sd_goto_field(sed, first_fld);
  118.  
  119.     /* call fentry function */
  120.     sed_DoFieldFenter(sed, sed_GetFieldNo(sed));
  121.  
  122.     disp_Flush();
  123.  
  124.     /* Main loop. */
  125.     while(!(sed_GetExit(sed))) {
  126.  
  127.         /* call fkey funcs until exit_toggle */
  128.         while (!(sed_GetExit(sed))) {
  129.             sed_SetCache(sed, FALSE);
  130.  
  131.             sed_DoFieldFkey(sed, sed_GetFieldNo(sed));
  132.  
  133.             /* do we need to flush? */
  134.             if (sed_IsCache(sed)) {
  135.                 disp_Flush();
  136.             }
  137.         }
  138.  
  139.         /* don't leave unless fexit function and Aux function return TRUE */
  140.         if (!sed_DoFieldFexit(sed, sed_GetFieldNo(sed)) ||
  141.                !sed_DoAux(sed, SED_PRESEXIT, NULL, NULL)) {
  142.  
  143.             sed_SetExit(sed, FALSE);
  144.             sed_SetNextWin(sed, NULL);        /* reset next win */
  145.         }
  146.     }
  147.  
  148.     /* reset the border prompt */
  149.     sed_BorderPrompt(sed, NULL);
  150.  
  151.     /* Call sexit functions. */
  152.     for (i = 0; i < sed_GetFieldCount(sed); i++) {
  153.         sed_DoFieldSexit(sed,i);
  154.     }
  155.  
  156.     /* Send message to Aux function */
  157.     sed_DoAux(sed, SED_POSTSEXIT, NULL, NULL);
  158.  
  159.     /* Reset active mode */
  160.     sed_SetActive(sed, FALSE);
  161.  
  162.     /* Unhighlight active field */
  163.     sd_goto_field(sed, sed_GetFieldNo(sed));
  164.  
  165.     /* Restore the cursor type */
  166.     sed_SetCursorType(sed, sed_GetCtype(sed));
  167.  
  168.     return(sed_GetBaton(sed));
  169. }
  170.  
  171. /*** field function routines **************************************************/
  172.  
  173.  
  174. void sed_DoFieldFenter(sed_type sed, int fld)
  175. {
  176.     fenter_fptr func;
  177.  
  178.     sed_DoAux(sed, SED_PREFENTER, NULL, NULL);
  179.  
  180.     if ((func = (menu_GetFuncs(sed_GetMenu(sed), fld))->fentry) != FNULL) {
  181.         disp_Cache();
  182.         (*func)(sed);
  183.         disp_Flush();
  184.     }
  185.  
  186.     sed_DoAux(sed, SED_POSTFENTER, NULL, NULL);
  187. }
  188.  
  189. void sed_DoFieldFkey(sed_type sed, int fld)
  190. {
  191.     fkey_fptr func;
  192.  
  193.     if ((func = (menu_GetFuncs(sed_GetMenu(sed), fld))->fkey) != FNULL) {
  194.         (*func)(sed);
  195.     }
  196.     else {
  197.         sed_SetExit(sed, TRUE);
  198.     }
  199. }
  200.  
  201. boolean sed_DoFieldFexit(sed_type sed, int fld)
  202. /*
  203.     Calls the field's fexit function, sends PREFEXIT and POSTFEXIT 
  204.     aux messages.
  205. */
  206. {
  207.     fexit_fptr func;
  208.  
  209.     if (!sed_DoAux(sed, SED_PREFEXIT, NULL, NULL)) {
  210.         return(FALSE);
  211.     }
  212.  
  213.     if ((func = (menu_GetFuncs(sed_GetMenu(sed), fld))->fexit) != FNULL
  214.         && (*func)(sed) == FALSE) {
  215.  
  216.         return(FALSE);
  217.     }
  218.  
  219.     return(sed_DoAux(sed, SED_POSTFEXIT, NULL, NULL));
  220. }
  221.  
  222. void sed_DoFieldSenter(sed_type sed, int fld)
  223. {
  224.     senter_fptr func;
  225.  
  226.     if ((func = (menu_GetFuncs(sed_GetMenu(sed), fld))->sentry) != FNULL) {
  227.         (*func)(sed, fld);
  228.     }
  229. }
  230.  
  231. void sed_DoFieldSexit(sed_type sed, int fld)
  232. {
  233.     sexit_fptr func;
  234.  
  235.     if ((func = (menu_GetFuncs(sed_GetMenu(sed), fld))->sexit) != FNULL) {
  236.         (*func)(sed, fld);
  237.     }
  238. }
  239.  
  240. boolean sed_DoSpecial(sed_type sed, int key)
  241. /*
  242.     Call the sed's special function.
  243.     Returns FALSE if there is no special function
  244.     else it returns the special function's return value.
  245. */
  246. {
  247.     if (sed_GetSpecial(sed) == FNULL) {
  248.         return(FALSE);
  249.     }
  250.  
  251.     return((*(sed_GetSpecial(sed)))(sed, key));
  252. }
  253.  
  254. boolean sd_exitfield(sed_type sed)
  255. /*
  256.     Exits the current field.
  257.     If sed is active, calls FieldFexit and resets cursor type
  258.     else does nothing.
  259.     Returns FALSE if fexit fails
  260. */
  261. {
  262.     if (sed_IsActive(sed)) {
  263.         if (sed_DoFieldFexit(sed, sed_GetFieldNo(sed))) {
  264.             /* Restore the cursor type */
  265.             sed_SetCursorType(sed, sed_GetCtype(sed));
  266.             return(TRUE);
  267.         }
  268.         else {
  269.             return(FALSE);
  270.         }
  271.     }
  272.  
  273.     return(TRUE);
  274. }
  275.  
  276.