home *** CD-ROM | disk | FTP | other *** search
/ QBasic & Borland Pascal & C / Delphi5.iso / C / Samples / CSAPE32.ARJ / SOURCE / CSSRC / SLEDWIN.C < prev    next >
C/C++ Source or Header  |  1990-10-31  |  11KB  |  425 lines
  1. /*
  2.     sledwin.c
  3.  
  4.     % sledwin_Class: The sled window class
  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.      2/07/89 jmd    initialized sleddata to avoid warning
  13.      3/24/89 jmd    added sed_ macros
  14.      3/29/89 jmd    converted seds to 'pure' objects
  15.      4/11/89 jmd    fixed field blanking (this fixes graphics mode bug)
  16.                     fixed GoHome in ScrollReq
  17.      4/19/89 jdc    changed sled_Open() to sled_ReallyOpen()
  18.      4/28/89 jdc    removed protection from sled_remapper()
  19.      5/23/89 jdc    put protection back (bob grid movement requires it)
  20.                     added failure checks to sled_ReallyOpen()
  21.                     added support for varsize == 0
  22.      7/22/89 jdc    moved sled_ReallyOpen and sled_remapper to sledopen.c
  23.      8/04/89 gam    changed #include <sledwin.h> to sled.h
  24.      8/05/89 gam    added protection/marking for rows and columns
  25.      8/06/89 gam    added sled_getrowflags function for Microsoft
  26.      8/10/89 gam    added remapper check to sled_SetColVar().
  27.      8/21/89 jdc    broke out close code into sledwin_Close (LNF)
  28.      8/23/89 jmd    added tests for menu == NULL
  29.      9/12/89 gam    added scroll message to sled_remapper
  30.  
  31.     10/17/89 gam    fixed scrolldown bug after a sed_SetHeight
  32.  
  33.     11/08/89 jdc    added PAINTREQ message and removed remapper from
  34.                     sled_SetColVar
  35.     11/08/89 jmd    removed DoRaw Macro
  36.     11/21/89 gam    added check for win_IsEmployed before calling RepaintFields
  37.      2/14/90 jdc    messed with load code
  38.      2/23/90 jdc    fixed resize code
  39.      3/14/90 jmd    made sled_SetColVar a boolean
  40.      3/28/90 jmd    ansi-fied
  41.      4/13/90 jmd    added case for WINM_SHADOW
  42.      4/19/90 jdc    preened
  43.      4/27/90 jdc    preened
  44.      5/01/90 jdc    added field removal for resize smaller
  45.      5/02/90 jdc    readded lost information
  46.      5/08/90 jdc    preened
  47.      5/30/90 jdc    added better error checking in SetColVar
  48.      6/12/90 jdc    tweeked so column arrays always grow evenly
  49.                     fixed row protection
  50.      6/13/90 jdc    fixed scrolling with protection
  51.      6/15/90 jdc    added FieldCount check for sledwin_Close
  52.      6/22/90 jdc    moved sledwin_Close to sledopen.c
  53.      7/11/90 pmcm    added varsize 0 check to sled_SetColVar so we don't
  54.                     give sa_Blank NULL sarray's
  55.      7/18/90 pmcm    added bounds check of col arg to sled_SetColVar so
  56.                     we don't violate the protect column data
  57.      7/25/90 jdc    added fexit call in Remap
  58.                     Remap now returns SED_STUCK, SED_INVALID, or SED_MOVED
  59.                     put GoHome and Fenter call from spc_Sled in Remap
  60.      8/08/90 jdc    fixed resize larger field adding order
  61.      8/27/90 jdc    now suppresses resizing smaller than one field row
  62.     10/04/90 jmd    added cast to sa_Get for C++
  63. */
  64.  
  65. #include "sed.h"
  66. #include "sldwinod.h"
  67. #include "sadecl.h"
  68. #include "sled.h"
  69. #include "sledprot.h"
  70. #include "sfile.h"            /* load save capability always linked in! */
  71.  
  72. int sledwin_Class(VOID *objdata, int msg, VOID *indata, VOID *outdata)
  73. /*
  74.     Dispatch function for sed windows.
  75. */
  76. {
  77.     sledwin_od         *sledwd;
  78.     inposdata_struct *ipd;
  79.     ofont_type           font;
  80.     sed_type          sed;
  81.     int                  row, col, fld, i, dif, hgt, ret = TRUE;
  82.     menu_type          menu;
  83.  
  84.     sledwd = (sledwin_od *) objdata;
  85.  
  86.     switch (msg) {
  87.  
  88.     case WINM_PAINTREQ:
  89.         sled_remapper(sledod_GetSelf(sledwd), 0);
  90.         return(sedwin_Class(&(sledwd->sedwd), msg, indata, outdata));
  91.  
  92.     case OBJM_LOAD:
  93.     {
  94.     /* !! no direct inheritance from sedwin_Class */
  95.         sed_type sed;
  96.         sfile_type sfile;
  97.  
  98.         sed = sledod_GetSelf(sledwd);
  99.         sfile = (sfile_type)indata;
  100.  
  101.         if (!win_Class(&(sledwd->sedwd.wd), msg, indata, outdata)
  102.         ||  !sed_Init(sed, sf_loadmenu(sfile))) {
  103.  
  104.             sed_Close(sed);
  105.             return(FALSE);
  106.         }
  107.         if (!sled_Init(sed, 1, FNULL) || !sed_load(sfile, sed)) {
  108.  
  109.             sledwin_Close(sed);
  110.             sed_Close(sed);
  111.             return(FALSE);
  112.         }
  113.         break;
  114.     }
  115.     case OBJM_GETDATASIZE:
  116.         ((ogds_struct *) outdata)->odsize = sizeof(sledwin_od);
  117.         ((ogds_struct *) outdata)->xdsize = sizeof(sled_xd);
  118.         ((ogds_struct *) outdata)->id = ID_SLEDWIN;
  119.         break;
  120.  
  121.     case OBJM_WHO:
  122.         /* Identify ourselves */
  123.         if (*((int *) indata) == ID_SLEDWIN) {
  124.             return(TRUE);
  125.         }
  126.         return(sedwin_Class(&(sledwd->sedwd), msg, indata, outdata));
  127.  
  128.     case WINM_SETSIZE:
  129.         sed = sledod_GetSelf(sledwd);
  130.  
  131.         /* remember old size */
  132.         hgt = sed_GetHeight(sed);
  133.         col = sed_GetWidth(sed);
  134.  
  135.         /* only continue if menu exists */
  136.         if ((menu = sed_GetMenu(sed)) == NULL) {
  137.             sedwin_Class(&(sledwd->sedwd), msg, indata, outdata);
  138.             break;
  139.         }
  140.  
  141.         if (((opoint *)indata)->y / ofont_GetHeight(win_GetFont(sed))
  142.             < menu_GetFieldRow(sed_GetMenu(sed), 0) + 1) {
  143.  
  144.             /* don't shrink less than one field row */
  145.             ((opoint *)indata)->y = 
  146.                 (menu_GetFieldRow(sed_GetMenu(sed), 0) + 1)
  147.                 * ofont_GetHeight(win_GetFont(sed));
  148.         }
  149.  
  150.         /* resize sed */
  151.         sedwin_Class(&(sledwd->sedwd), msg, indata, outdata);
  152.  
  153.         if (sed_GetWidth(sed) > col
  154.             && (dif = sed_GetWidth(sed) + sed_GetXoffset(sed)
  155.             - menu_GetFieldLastCol(menu, sed_GetFieldNo(sed)) - 1) > 0) {
  156.  
  157.             sed_ScrollLeft(sed, (dif > sed_GetXoffset(sed)) 
  158.                 ? sed_GetXoffset(sed) : dif);
  159.         }
  160.  
  161.         if (sed_GetHeight(sed) < hgt) {
  162.  
  163.             /* smaller */
  164.  
  165.             if ((row = hgt - sed_GetHeight(sed)) 
  166.                 >= menu_GetFieldCount(menu) / sled_GetWidth(sed)) {
  167.  
  168.                 row = menu_GetFieldCount(menu) / sled_GetWidth(sed) - 1;
  169.             }
  170.  
  171.             /* reposition highlight, UpField takes care of protection */
  172.             i = sed_GetHeight(sed) - menu_GetFieldRow(sed_GetMenu(sed), 0);
  173.             do {
  174.                 i--;
  175.                 if (i < 0 || (fld = sed_GetGridField(sed, i, sled_GetCol(sed))) < 0) {
  176.                     fld = -1;
  177.                     break;
  178.                 }
  179.                 else if (sed_GetFieldNo(sed) <= fld) {
  180.  
  181.                     fld = sed_GetFieldNo(sed);
  182.                     break;
  183.                 }
  184.             } while (sed_IsProtectedField(sed, fld));
  185.  
  186.             if (fld == -1) {
  187.                 sled_Remap(sed, -1);
  188.             }
  189.             else {
  190.                 sed_GotoField(sed, fld);
  191.             }
  192.  
  193.             if (row > 0) {
  194.                 sed_DeleteRows(sed, sed_GetHeight(sed), row);
  195.             }
  196.  
  197.             break;
  198.         }
  199.         /* larger */
  200.  
  201.         col = 0;
  202.         dif = sed_GetHeight(sed) - hgt;
  203.         sed_DoSexits(sed);
  204.  
  205.         /* add fields */
  206.         for (i = hgt; i < sed_GetHeight(sed); i++) {
  207.             for (fld = 0; fld >= 0; fld = menu_GetFieldRight(menu, fld)) {
  208.                 ret = menu_CopyField(menu, i, menu_GetFieldCol(menu, fld), menu, fld);
  209.             }
  210.         }
  211.  
  212.         /* adjust the sled offset if possible */
  213.         if (sled_GetOffset(sed) + sed_GetHeight(sed) - 1 > sled_GetColSize(sed)
  214.         && (col = sled_GetOffset(sed)) > 0) {
  215.  
  216.             col = (col < dif) ? col : dif;
  217.         }
  218.     
  219.         sled_remapper(sed, -col);
  220.         sed_DoSenters(sed);
  221.         if (win_IsEmployed(sed)) sed_Update(sed);
  222.  
  223.         /* adjust field for remapping */
  224.         if (col != 0) {
  225.             sed_GotoGridField(sed, sed_GetGridRow(sed, sed_GetFieldNo(sed)) + col, 
  226.                 sed_GetGridCol(sed, sed_GetFieldNo(sed)));
  227.         }
  228.         break;
  229.  
  230.     case WINM_SCROLLREQ:
  231.         /* A request to scroll the sled */
  232.         sed = sledod_GetSelf(sledwd);
  233.         row = ((opoint *)indata)->y / win_GetFontHeight(sed);
  234.         col = ((opoint *)indata)->x / win_GetFontWidth(sed);
  235.  
  236.         if (col < 0) {
  237.             sed_ScrollLeft(sed, -col);
  238.         }
  239.         else if (col > 0) {
  240.             sed_ScrollRight(sed, col);
  241.         }
  242.         if (row != 0 && sled_Remap(sed, row)) {
  243.             /* the field should appear to be newly entered */
  244.             sed_GoHome(sed);
  245.             sed_DoFieldFenter(sed, sed_GetFieldNo(sed));
  246.         }
  247.         break;
  248.  
  249.     case WINM_GETINPOS:
  250.         /* get the menu size relative to the sed
  251.            so that borders can compute scroll lights
  252.         */
  253.         ipd = (inposdata_struct *)outdata;
  254.         font = win_GetFont(ipd->win);
  255.  
  256.         sed = sledod_GetSelf(sledwd);
  257.  
  258.         if (sed_GetMenu(sed) != NULL) {
  259.             /* Xoffset same as seds */
  260.             ipd->inbox.xmin = - (sed_GetXoffset(sed) * ofont_GetWidth(font));
  261.             ipd->inbox.xmax = ipd->inbox.xmin +
  262.                             (sed_GetMenuVWidth(sed) * ofont_GetWidth(font));
  263.  
  264.             /* but not Yoffset */
  265.             ipd->inbox.ymin = - ((sed_GetYoffset(sed) + sled_GetOffset(sed)) * ofont_GetHeight(font));
  266.             ipd->inbox.ymax = ipd->inbox.ymin + 
  267.                 (sled_GetColSize(sed) + menu_GetFieldRow(sed_GetMenu(sed), 0)) 
  268.                 * ofont_GetHeight(font);
  269.         }
  270.         break;
  271.  
  272.     case WINM_SHADOW:
  273.     case WINM_PAINT:
  274.         /* Set field blanking flag to prevent painting of
  275.            fields past the current last row of the sled
  276.         */    
  277.         sed = sledod_GetSelf(sledwd);
  278.  
  279.         sledwd->sedwd.blank = sled_GetColSize(sed) - sled_GetOffset(sed) 
  280.                             + field_GetRow(sed_GetField(sed, 0));
  281.  
  282.         /* pass message up to sed superclass */
  283.         sedwin_Class(&(sledwd->sedwd), msg, indata, outdata);
  284.  
  285.         /* reset blanking flag */
  286.         sledwd->sedwd.blank = -1;
  287.         break;
  288.  
  289.     case OBJM_CLOSE:
  290.         sledwin_Close(sledod_GetSelf(sledwd));
  291.  
  292.         /* No Break; fall through to default */
  293.  
  294.     default:
  295.         return(sedwin_Class(&(sledwd->sedwd), msg, indata, outdata));
  296.     }
  297.     return(ret);
  298. }
  299.  
  300. /* Auxillary Functions */
  301.  
  302. int sled_Remap(sed_type sed, int offset)
  303. /*
  304. */
  305. {
  306.     boolean ret = TRUE;
  307.     int    row, oldoffset, i;
  308.  
  309.     oldoffset = offset;
  310.     row = sled_GetRow(sed);
  311.  
  312.     if (offset < 0) {
  313.  
  314.         /* can't go to row < 0 */
  315.         if (row == 0) return(SED_STUCK);
  316.         if ((i = row + offset) < 0) i = 0;
  317.  
  318.         /* adjust for row protection */
  319.         for ( ; sled_IsProtectedRow(sed, i); i--) {
  320.  
  321.             if (i == 0) return(SED_STUCK);
  322.         }
  323.         offset = i - row;
  324.     }
  325.     else if (offset > 0) {
  326.  
  327.         /* can't go to row >= sled_GetColSize(sed) */
  328.         if (row == sled_GetColSize(sed) - 1) return(SED_STUCK);
  329.         if ((i = row + offset) >= sled_GetColSize(sed)) {
  330.             i = sled_GetColSize(sed) - 1;
  331.         }
  332.  
  333.         /* adjust for row protection */
  334.         for ( ; sled_IsProtectedRow(sed, i); i++) {
  335.  
  336.             if (i >= sled_GetColSize(sed) - 1) return(SED_STUCK);
  337.         }
  338.         offset = i - row;
  339.     }
  340.  
  341.     if (!sd_exitfield(sed)) return(SED_INVALID);
  342.  
  343.     sed_DoSexits(sed);
  344.  
  345.     if (offset != 0 && (ret = sled_remapper(sed, offset)) == TRUE) {
  346.  
  347.         /* Move out of Protected Row in the original direction */
  348.         if (sled_IsProtectedRow(sed, sled_GetRow(sed))) {
  349.             if (oldoffset < 0) {
  350.                 sed_UpField(sed);
  351.             }
  352.             else {
  353.                 sed_DownField(sed);
  354.             }
  355.         }
  356.         if (win_IsEmployed(sed)) {
  357.             sed_RepaintFields(sed);
  358.         }
  359.         else {
  360.             sed_DoSenters(sed);
  361.         }
  362.     }
  363.  
  364.     /* the field should appear to be newly entered */
  365.     sed_GoHome(sed);
  366.     sed_DoFieldFenter(sed, sed_GetFieldNo(sed));
  367.  
  368.     return((ret == TRUE) ? SED_MOVED : SED_STUCK);
  369. }
  370.  
  371. VOID *sled_GetColVar(sed_type sed, int col, int row)
  372. /*
  373. */
  374. {
  375.     return(sa_Get((sarray_type) xa_Get(sled_GetXa(sed), col), (long)row));
  376. }
  377.  
  378. boolean sled_SetColVar(sed_type sed, int col, int row, VOID *data)
  379. /*
  380. */
  381. {
  382.     int i, len;
  383.     sarray_type sa;
  384.  
  385.     if (col >= sled_GetWidth(sed)) {
  386.         return(FALSE);
  387.     }
  388.  
  389.     if ((len = row - sled_GetColSize(sed) + 1) > 0) {
  390.  
  391.         for (i = 0; i < sled_GetWidth(sed); i++) {
  392.             if (sed_GetVarSize(sed, sed_GetGridField(sed, 0, i) ) != 0) {
  393.  
  394.                 sa = (sarray_type) xa_Get(sled_GetXa(sed), i);
  395.  
  396.                 if (sa_Blank(sa, (long) sled_GetColSize(sed), len, FALSE) == NULL) {
  397.                     return(FALSE);
  398.                 }
  399.             }
  400.         }
  401.         sled_SetColSize(sed, row + 1);
  402.         sed_SendBorderMsg(sed, BDM_SCROLL, NULL, NULL);
  403.     }
  404.     sa = (sarray_type) xa_Get(sled_GetXa(sed), col);
  405.  
  406.     return(sa_Put(sa, (long)row, data) != NULL);
  407. }
  408.  
  409.  
  410. int sled_getrowspecial(sed_type sed, int row)
  411. {
  412.     int    *temp;
  413.  
  414.     temp = (int *)sa_Get((sarray_type) xa_Get(sled_GetXa(sed), sled_GetWidth(sed)), (long)(row));
  415.  
  416.     if (temp == NULL) {
  417.         return(0);
  418.     }
  419.     else {
  420.         return(*temp);
  421.     }
  422. }
  423.  
  424.  
  425.