home *** CD-ROM | disk | FTP | other *** search
/ QBasic & Borland Pascal & C / Delphi5.iso / C / Samples / CSAPE32.ARJ / SOURCE / CSSRC / SLEDOPEN.C < prev    next >
Encoding:
C/C++ Source or Header  |  1990-11-01  |  7.1 KB  |  301 lines
  1. /*
  2.     sledopen.c
  3.  
  4.     % sled_ReallyOpen, sled_remapper
  5.  
  6.     C-scape 3.2
  7.     Copyright (c) 1988-1990, by Oakland Group, Inc.
  8.     ALL RIGHTS RESERVED.
  9.  
  10.     Revision History:
  11.     -----------------
  12.      7/22/89 jdc    removed from sledwin.c
  13.      7/29/89 jmd    added casts for blank
  14.      8/04/89 gam    changed #include <sledwin.h> to sled.h
  15.      8/05/89 gam    added protection/marking of rows and columns
  16.      8/13/89 jmd    revamped open/init mechanism
  17.      8/24/89 gam    @fp[] in menu_Printf now works in sleds
  18.      8/26/89 jmd    made torf an int
  19.  
  20.     11/29/89 jmd    added casts for DG
  21.      2/24/90 jdc    removed sled_GetHeight
  22.      3/28/90 jmd    ansi-fied
  23.      5/01/90 jdc    added field removal for resize smaller
  24.      5/30/90 jdc    changed the order in which sled_ReallyOpen adds fields
  25.      6/08/90 jmd    turned class into wclass for C++
  26.      6/12/90 jdc    preened
  27.      6/15/90 jdc    added FieldCount check for sled_Init
  28.      6/22/90 jdc    added reopen check for sled_Init
  29.                     put sledwin_Close in here
  30.      7/11/90 jdc    fixed max_varsize == 0 and sa == NULL bugs
  31.      11/31/90 ted    added oak_notused call in sled_Init().
  32. */
  33.  
  34. #include "sed.h"
  35. #include "sldwinod.h"
  36. #include "sadecl.h"
  37. #include "sled.h"
  38. #include "sledprot.h"
  39.  
  40. sed_type sled_ReallyOpen(menu_type menu, int hgt, spc_fptr spec_func, class_fptr wclass)
  41. /*
  42.     Create fields for the sled from the one line menu.
  43.     Open a sed and initialize it.
  44. */
  45. {
  46.     sed_type sed;
  47.     int i, row, fld, fldone;
  48.  
  49.     /* find the first (and only) row */
  50.     for (row = 0; (fldone = menu_GetGRow(menu, row)) <= 0; row++) {
  51.         ;
  52.     }
  53.  
  54.     /* the fldno returned from menu_GetGRow is the real fldno plus 1 */
  55.     fld = --fldone;
  56.  
  57.     /* create hgt rows from the one row */
  58.     for (i = 1; i < hgt; i++, fld = fldone) {
  59.  
  60.         do {
  61.             if (menu_CopyField(menu, row + i, menu_GetFieldCol(menu, fld), menu, fld) < 0) {
  62.                 return(NULL);
  63.             }
  64.         } while ((fld = menu_GetFieldRight(menu, fld)) >= 0);
  65.     }
  66.  
  67.     /* open the sed */
  68.     if ((sed = sed_ReallyOpen(menu, wclass)) == NULL)  {
  69.         return(NULL);
  70.     }
  71.  
  72.     sled_Init(sed, hgt, spec_func);
  73.  
  74.     return(sed);
  75. }
  76.  
  77. boolean sled_Init(sed_type sed, int hgt, spc_fptr spec_func)
  78. /*
  79.     Initialize a sled.
  80. */
  81. {
  82.     int      i, col, fld, varsize, max_varsize = 0;
  83.     xarray      xa;
  84.     VOID     *var;
  85.     char    *blank;
  86.     sarray_type sa;
  87.     iarray     ca;
  88.     menu_type menu;
  89.     int         torf;
  90.  
  91.     oak_notused(hgt);
  92.  
  93.     menu = sed_GetMenu(sed);
  94.  
  95.     /* close before reallocating */
  96.     if (sled_GetXa(sed) != NULL) {
  97.         sledwin_Close(sed);
  98.     }
  99.  
  100.     /* The column arrays are an xarray of sarrays */
  101.     if ((xa = xa_Open(1)) == NULL) {
  102.         goto QUIT_1;
  103.     }
  104.     sled_SetXa(sed, xa);
  105.  
  106.     /* make iarray for column protection and initialize it. */
  107.     if ((ca = ia_Open(1)) == NULL) {
  108.         goto QUIT_2;
  109.     }
  110.     /* set the col protect/mark flags */
  111.     sled_setcflags(sed, ca);
  112.  
  113.     if (sed_GetFieldCount(sed) <= 0) {
  114.  
  115.         sled_SetOffset(sed, 0);
  116.         sled_SetColSize(sed, 0);
  117.         sled_SetWidth(sed, 0);
  118.         sled_SetBlank(sed, NULL);
  119.  
  120.         return(TRUE);
  121.     }
  122.  
  123.     /* find the first (and only) row */
  124.     fld = sed_GetGridField(sed, 0, 0);
  125.     col = 0;
  126.  
  127.     /* create hgt rows from the one row */
  128.     do {
  129.         /* create the Column Arrays (sarrays) checking for NULL varsize */
  130.         if ((varsize = menu_GetVarSize(menu, fld)) == 0) {
  131.             sa = NULL;
  132.         }
  133.         else if ((sa = sa_Open(varsize, SLED_BSIZE, SLED_ASIZE)) == NULL) {
  134.             goto QUIT_3;
  135.         }
  136.         /* Put the sarray into the xarray */
  137.         xa_Put(xa, col, (VOID *)sa);
  138.  
  139.         /* find the largest variable to allocate blank field var */
  140.         max_varsize = (max_varsize < varsize) ? varsize : max_varsize;
  141.  
  142.         /* Set column protection flag */
  143.         torf = (int) sed_IsProtectedField(sed, fld);
  144.         ia_Put(ca, col, torf);
  145.  
  146.         /* Next column, please */
  147.         col++;
  148.  
  149.     } while ((fld = menu_GetFieldRight(menu, fld)) >= 0);
  150.  
  151.     sled_SetOffset(sed, 0);
  152.     sled_SetColSize(sed, 1);
  153.     sled_SetWidth(sed, col);
  154.  
  155.     /* allocate the blank field memory */
  156.     if (max_varsize <= 0) {
  157.         blank = NULL;
  158.     }
  159.     else if ((blank = (char *) ocalloc(CSA_SLEDBLANK, max_varsize, sizeof(byte))) == NULL) {
  160.         goto QUIT_3;
  161.     }
  162.     sled_SetBlank(sed, (VOID *) blank);
  163.  
  164.     if (spec_func != FNULL) {
  165.         sed_SetSpecial(sed, spec_func);
  166.     }
  167.  
  168.     /* make sarray for mark/protect */
  169.     if ((sa = sa_Open(sizeof(int), SLED_BSIZE, SLED_ASIZE)) == NULL) {
  170.         goto QUIT_3;
  171.     }
  172.     xa_Put(xa, col, (VOID *)sa);
  173.  
  174.     /* Initialize the first row mark/protect flag */
  175.     sa_Blank(sa, 0L, 1, FALSE);
  176.  
  177.     /* create one empty row */
  178.     for (i = 0; i < col; i++) {
  179.         var = sa_Put((sarray_type)xa_Get(xa, i), 0L, sled_GetBlank(sed));
  180.         sed_SetVar(sed, i, var);
  181.     }
  182.  
  183.     sled_remapper(sed, 0);
  184.  
  185.     return(TRUE);
  186.  
  187.     /* These statements clean up if not enough memory for everything */
  188. QUIT_3:
  189.     for ( i = 0; i <= col; i++ ) {
  190.         if ((sa = (sarray_type)xa_Get(xa, i)) != NULL) {
  191.             sa_Close(sa);
  192.         }
  193.     }
  194.  
  195.     ia_Close(ca);
  196.     sled_setcflags(sed, NULL);
  197.  
  198. QUIT_2:
  199.     xa_Close(xa);
  200.     sled_SetXa(sed, NULL);
  201.  
  202. QUIT_1:
  203.     return(FALSE);
  204. }
  205.  
  206. boolean sled_remapper(sed_type sed, int offset)
  207. {
  208.     boolean      protect, marked;
  209.     int       bot, fld, row, col, i, hgt;
  210.     menu_type menu;
  211.  
  212.     menu = sed_GetMenu(sed);
  213.  
  214.     hgt = menu_GetFieldRow(menu, menu_GetFieldCount(menu) -1) - menu_GetFieldRow(menu, 0) + 1;
  215.  
  216.     if (offset < 0) {
  217.         if (sled_GetOffset(sed) == 0) {
  218.             return(FALSE);
  219.         }
  220.         offset = (sled_GetOffset(sed) < -offset) ? -sled_GetOffset(sed) : offset;
  221.     }
  222.     else if (offset > 0) {
  223.         if ((bot = sled_GetColSize(sed) - (hgt + sled_GetOffset(sed))) <= 0) {
  224.             return(FALSE);
  225.         }
  226.         offset = (bot < offset) ? bot : offset;
  227.     }
  228.     sled_SetOffset(sed, sled_GetOffset(sed) + offset);
  229.  
  230.     for (i = 0, row = sled_GetOffset(sed); i < menu_GetRowCount(menu); i++) {
  231.         if ((fld = menu_GetGRow(menu, i) - 1) < 0) {
  232.             continue;
  233.         }
  234.         protect = sled_IsProtectedRow(sed, row);
  235.         marked  = sled_IsMarkedRow(sed, row);
  236.         /* loop each row */
  237.         col = 0;
  238.         do {
  239.             /* loop each col */
  240.             if (row < sled_GetColSize(sed)) {
  241.                 /* row exists */
  242.                 menu_SetVar(menu, fld, sa_Get((sarray_type)xa_Get(sled_GetXa(sed), col), (long)row));
  243.                 menu_ProtectField(menu, fld, protect | sled_IsProtectedCol(sed, col));
  244.                 if (marked | sled_IsMarkedCol(sed, col)) {
  245.                     menu_MarkField(menu, fld, sled_GetRegAttr(sed), sled_GetSelAttr(sed));
  246.                 }
  247.                 else {
  248.                     field_SetMarked(sed_GetField(sed, fld), FALSE);
  249.                 }
  250.             }
  251.             else {
  252.                 /* row doesn't exist */
  253.                 menu_SetVar(menu, fld, sled_GetBlank(sed));
  254.                 menu_ProtectField(menu, fld, TRUE);
  255.             }
  256.             col++;
  257.  
  258.         } while ((fld = menu_GetFieldRight(menu, fld)) >= 0);
  259.         row++;
  260.     }
  261.  
  262.      /* Send Scroll message to the border */
  263.     sed_SendBorderMsg(sed, BDM_SCROLL, NULL, NULL);
  264.  
  265.     return(TRUE);
  266. }
  267.  
  268. void sledwin_Close(sed_type sed)
  269. {
  270.     sarray_type          sa;
  271.     int i;
  272.  
  273.     if (sed_GetFieldCount(sed) <= 0) return;
  274.  
  275.     /* close the blank field */
  276.     if (sled_GetBlank(sed) != NULL) {
  277.         ofree(CSA_SLEDBLANK, sled_GetBlank(sed));
  278.         sled_SetBlank(sed, NULL);
  279.     }
  280.  
  281.     /* close the column marking/protection array */
  282.     if (sled_getcflags(sed) != NULL) {
  283.         ia_Close(sled_getcflags(sed));
  284.         sled_getcflags(sed) = NULL;
  285.     }
  286.  
  287.     /* close the xarray of column arrays */
  288.     if (sled_GetXa(sed) != NULL) {
  289.  
  290.         /* close the column arrays */
  291.         for (i = 0; i < sled_GetWidth(sed); i++) {
  292.             if ((sa = (sarray_type)xa_Get(sled_GetXa(sed), i)) != NULL) {
  293.                 sa_Close(sa);
  294.             }
  295.         }
  296.  
  297.         xa_Close(sled_GetXa(sed));
  298.         sled_SetXa(sed, NULL);
  299.     }
  300. }
  301.