home *** CD-ROM | disk | FTP | other *** search
/ Crawly Crypt Collection 1 / crawlyvol1.bin / apps / spread / viscalc / cmds.c next >
C/C++ Source or Header  |  1985-11-17  |  8KB  |  444 lines
  1. /*    SC    A Spreadsheet Calculator
  2.  *        Main driver
  3.  *
  4.  *        original by James Gosling, September 1982
  5.  *        modifications by Mark Weiser and Bruce Israel,
  6.  *            University of Maryland
  7.  *
  8.  *              More mods Robert Bond, 12/86
  9.  *        Major mods to run on VMS and AMIGA, 1/17/87
  10.  *
  11.  */
  12.  
  13. #include "sc.h"
  14.  
  15. extern char *malloc();
  16.  
  17. duprow()
  18. {
  19.     if (currow >= MAXROWS - 1 || maxrow >= MAXROWS - 1) {
  20.     error ("The table can't be any bigger");
  21.     return;
  22.     }
  23.     modflg++;
  24.     currow++;
  25.     openrow (currow);
  26.     for (curcol = 0; curcol <= maxcol; curcol++) {
  27.     register struct ent *p = tbl[currow - 1][curcol];
  28.     if (p) {
  29.         register struct ent *n;
  30.         n = lookat (currow, curcol);
  31.         n -> v = p -> v;
  32.         n -> flags = p -> flags;
  33.         n -> expr = copye (p -> expr, 1, 0);
  34.         n -> label = 0;
  35.         if (p -> label) {
  36.         n -> label = (char *)
  37.                  malloc (strlen (p -> label) + 1);
  38.         strcpy (n -> label, p -> label);
  39.         }
  40.     }
  41.     }
  42.     for (curcol = 0; curcol <= maxcol; curcol++) {
  43.     register struct ent *p = tbl[currow][curcol];
  44.     if (p && (p -> flags & is_valid) && !p -> expr)
  45.         break;
  46.     }
  47.     if (curcol > maxcol)
  48.     curcol = 0;
  49. }
  50.  
  51. dupcol() 
  52. {
  53.     if (curcol >= MAXCOLS - 1 || maxcol >= MAXCOLS - 1) {
  54.     error ("The table can't be any wider");
  55.     return;
  56.     }
  57.     modflg++;
  58.     curcol++;
  59.     opencol (curcol);
  60.     for (currow = 0; currow <= maxrow; currow++) {
  61.     register struct ent *p = tbl[currow][curcol - 1];
  62.     if (p) {
  63.         register struct ent *n;
  64.         n = lookat (currow, curcol);
  65.         n -> v = p -> v;
  66.         n -> flags = p -> flags;
  67.         n -> expr = copye (p -> expr, 0, 1);
  68.         n -> label = 0;
  69.         if (p -> label) {
  70.         n -> label = (char *)
  71.                  malloc (strlen (p -> label) + 1);
  72.         strcpy (n -> label, p -> label);
  73.         }
  74.     }
  75.     }
  76.     for (currow = 0; currow <= maxrow; currow++) {
  77.     register struct ent *p = tbl[currow][curcol];
  78.     if (p && (p -> flags & is_valid) && !p -> expr)
  79.         break;
  80.     }
  81.     if (currow > maxrow)
  82.     currow = 0;
  83. }
  84.  
  85. insertrow(arg)
  86. {
  87.     while (--arg>=0) openrow (currow);
  88. }
  89.  
  90. deleterow(arg)
  91. {
  92.     flush_saved();
  93.     erase_area(currow, 0, currow + arg - 1, maxcol);
  94.     currow += arg;
  95.     while (--arg>=0) closerow (--currow);
  96.     sync_refs();
  97. }
  98.  
  99. insertcol(arg)
  100. {
  101.     while (--arg>=0) opencol(curcol);
  102. }
  103.  
  104. deletecol(arg)
  105. {
  106.     flush_saved();
  107.     erase_area(0, curcol, maxrow, curcol + arg - 1);
  108.     curcol += arg;
  109.     while (--arg>=0) closecol (--curcol);
  110.     sync_refs();
  111. }
  112.  
  113. valueizerow(arg)
  114. {
  115.     valueize_area(currow, 0, currow + arg - 1, maxcol);
  116. }
  117.  
  118. valueizecol(arg)
  119. {
  120.     valueize_area(0, curcol, maxrow, curcol + arg - 1);
  121. }
  122.  
  123. erase_area(sr, sc, er, ec)
  124. int sr, sc, er, ec;
  125. {
  126.     register int r, c;
  127.     register struct ent **p;
  128.  
  129.     if (sr > er) {
  130.     r = sr; sr = er; er= r;    
  131.     }
  132.  
  133.     if (sc > ec) {
  134.     c = sc; sc = ec; ec= c;    
  135.     }
  136.  
  137.     if (sr < 0)
  138.     sr = 0; 
  139.     if (sc < 0)
  140.     sc = 0;
  141.     if (er >= MAXROWS)
  142.     er = MAXROWS-1;
  143.     if (ec >= MAXCOLS)
  144.     ec = MAXCOLS-1;
  145.  
  146.     for (r = sr; r <= er; r++) {
  147.     for (c = sc; c <= ec; c++) {
  148.         p = &tbl[r][c];
  149.         if (*p) {
  150.         free_ent(*p);
  151.         *p = 0;
  152.         }
  153.     }
  154.     }
  155.  
  156. }
  157.  
  158. valueize_area(sr, sc, er, ec)
  159. int sr, sc, er, ec;
  160. {
  161.     register int r, c;
  162.     register struct ent *p;
  163.  
  164.     if (sr > er) {
  165.     r = sr; sr = er; er= r;    
  166.     }
  167.  
  168.     if (sc > ec) {
  169.     c = sc; sc = ec; ec= c;    
  170.     }
  171.  
  172.     if (sr < 0)
  173.     sr = 0; 
  174.     if (sc < 0)
  175.     sc = 0;
  176.     if (er >= MAXROWS)
  177.     er = MAXROWS-1;
  178.     if (ec >= MAXCOLS)
  179.     ec = MAXCOLS-1;
  180.  
  181.     for (r = sr; r <= er; r++) {
  182.     for (c = sc; c <= ec; c++) {
  183.         p = tbl[r][c];
  184.         if (p && p->expr) {
  185.         efree(p->expr);
  186.         p->expr = 0;
  187.         }
  188.     }
  189.     }
  190.  
  191. }
  192.  
  193. pullcells(to_insert)
  194. {
  195.     register struct ent *p, *n;
  196.     register int deltar, deltac;
  197.     int minrow, mincol;
  198.     int maxrow, maxcol;
  199.     int numrows, numcols;
  200.  
  201.     if (!to_fix)
  202.     return;
  203.  
  204.     switch (to_insert) {
  205.     case 'm':
  206.     case 'r':
  207.     case 'c':
  208.     break;
  209.     default:
  210.     return;
  211.     }
  212.  
  213.     minrow = MAXROWS; 
  214.     mincol = MAXCOLS;
  215.     maxrow = 0;
  216.     maxcol = 0;
  217.  
  218.     for (p = to_fix; p; p = p->next) {
  219.     if (p->row < minrow)
  220.         minrow = p->row;
  221.     if (p->row > maxrow)
  222.         maxrow = p->row;
  223.     if (p->col < mincol)
  224.         mincol = p->col;
  225.     if (p->col > maxcol)
  226.         maxcol = p->col;
  227.     }
  228.  
  229.     numrows = maxrow - minrow + 1;
  230.     numcols = maxcol - mincol + 1;
  231.     deltar = currow - minrow;
  232.     deltac = curcol - mincol;
  233.  
  234.     if (to_insert == 'r') {
  235.     insertrow(numrows);
  236.     deltac = 0;
  237.     } else if (to_insert == 'c') {
  238.     insertcol(numcols);
  239.     deltar = 0;
  240.     }
  241.  
  242.     FullUpdate++;
  243.     modflg++;
  244.  
  245.     for (p = to_fix; p; p = p->next) {
  246.     n = lookat (p->row + deltar, p->col + deltac);
  247.     clearent(n);
  248.     n -> flags = p -> flags & ~is_deleted;
  249.     n -> v = p -> v;
  250.     n -> expr = copye(p->expr, deltar, deltac);
  251.     n -> label = 0;
  252.     if (p -> label) {
  253.         n -> label = (char *)
  254.              malloc(strlen(p->label)+1);
  255.         strcpy (n -> label, p -> label);
  256.     }
  257.     }
  258. }
  259.  
  260. showcol_op()
  261. {
  262.     register int i,j;
  263.     for (i=0; i<MAXCOLS; i++)
  264.     if (hidden_col[i]) 
  265.         break;
  266.     for(j=i; j<MAXCOLS; j++)
  267.     if (!hidden_col[j])
  268.         break;
  269.     j--;
  270.     if (i<MAXCOLS) {
  271.     sprintf(line,"show %s:", coltoa(i));
  272.     sprintf(line + strlen(line),"%s",coltoa(j));
  273.     linelim = strlen (line);
  274.     }
  275. }
  276.  
  277. showrow_op()
  278. {
  279.     register int i,j;
  280.     for (i=0; i<MAXROWS; i++)
  281.     if (hidden_row[i]) 
  282.         break;
  283.     for(j=i; j<MAXROWS; j++)
  284.     if (!hidden_row[j]) {
  285.         break;
  286.     }
  287.     j--;
  288.     if (i<MAXROWS) {
  289.     sprintf(line,"show %d:%d", i, j);
  290.         linelim = strlen (line);
  291.     }
  292. }
  293.  
  294. get_qual()
  295. {
  296.     register int c;
  297.  
  298.     c = nmgetch();
  299.     switch (c) {
  300.     case 'c':
  301.     case 'j':
  302.     case 'k':
  303.     case ctl(p):
  304.     case ctl(n):
  305.     return('c');
  306.     break;
  307.     case 'r':
  308.     case 'l':
  309.     case 'h':
  310.     case ctl(f):
  311.     case ctl(b):
  312.     return('r');
  313.     break;
  314.     default:
  315.     return(c);
  316.         break;
  317.     }
  318. }
  319.  
  320. openrow (rs) {
  321.     register    r;
  322.     register struct ent **p;
  323.     register    c;
  324.     register    i;
  325.  
  326.     if (rs > maxrow) maxrow = rs;
  327.     if (maxrow >= MAXROWS - 1 || rs > MAXROWS - 1) {
  328.     error ("The table can't be any longer");
  329.     return;
  330.     }
  331.     for (i = maxrow+1; i > rs; i--) {
  332.     hidden_row[i] = hidden_row[i-1];
  333.     }
  334.     for (r = ++maxrow; r > rs; r--)
  335.     for (c = maxcol + 1, p = &tbl[r][0]; --c >= 0; p++)
  336.         if (p[0] = p[-MAXCOLS])
  337.         p[0] -> row++;
  338.     p = &tbl[rs][0];
  339.     for (c = maxcol + 1; --c >= 0;)
  340.     *p++ = 0;
  341.     FullUpdate++;
  342.     modflg++;
  343. }
  344.  
  345. closerow (r)
  346. register r; {
  347.     register struct ent **p;
  348.     register c;
  349.     register int i;
  350.  
  351.     if (r > maxrow) return;
  352.  
  353.     p = &tbl[r][0];
  354.     for (c=maxcol+1; --c>=0; ) {
  355.     if (*p)
  356.         free_ent(*p);
  357.     *p++ = 0;
  358.     }
  359.  
  360.     for (i = r; i < MAXROWS - 1; i++) {
  361.     hidden_row[i] = hidden_row[i+1];
  362.     }
  363.  
  364.     while (r<maxrow) {
  365.     for (c = maxcol+1, p = &tbl[r][0]; --c>=0; p++)
  366.         if (p[0] = p[MAXCOLS])
  367.         p[0]->row--;
  368.     r++;
  369.     }
  370.  
  371.     p = &tbl[maxrow][0];
  372.     for (c=maxcol+1; --c>=0; ) *p++ = 0;
  373.     maxrow--;
  374.     FullUpdate++;
  375.     modflg++;
  376. }
  377.  
  378. opencol (cs) {
  379.     register r;
  380.     register struct ent **p;
  381.     register c;
  382.     register lim = maxcol-cs+1;
  383.     int i;
  384.  
  385.     if (cs > maxcol) maxcol = cs;
  386.     if (maxcol >= MAXCOLS - 1 || cs > MAXCOLS - 1) {
  387.     error ("The table can't be any wider");
  388.     return;
  389.     }
  390.     for (i = maxcol+1; i > cs; i--) {
  391.     fwidth[i] = fwidth[i-1];
  392.     precision[i] = precision[i-1];
  393.     hidden_col[i] = hidden_col[i-1];
  394.     }
  395.     /* fwidth[cs] = DEFWIDTH;
  396.     precision[i] =  DEFPREC;  */
  397.  
  398.     for (r=0; r<=maxrow; r++) {
  399.     p = &tbl[r][maxcol+1];
  400.     for (c=lim; --c>=0; p--)
  401.         if (p[0] = p[-1])
  402.         p[0]->col++;
  403.     p[0] = 0;
  404.     }
  405.     maxcol++;
  406.     FullUpdate++;
  407.     modflg++;
  408. }
  409.  
  410. closecol (cs) {
  411.     register r;
  412.     register struct ent **p;
  413.     register struct ent *q;
  414.     register c;
  415.     register lim = maxcol-cs;
  416.     int i;
  417.  
  418.     if (lim < 0) return;
  419.  
  420.     for (r=0; r<=maxrow; r++)
  421.     if (q = tbl[r][cs]) {
  422.         free_ent(q);
  423.     }
  424.  
  425.     for (r=0; r<=maxrow; r++) {
  426.     p = &tbl[r][cs];
  427.     for (c=lim; --c>=0; p++)
  428.         if (p[0] = p[1])
  429.         p[0]->col--;
  430.     p[0] = 0;
  431.     }
  432.  
  433.     for (i = cs; i < MAXCOLS - 1; i++) {
  434.     fwidth[i] = fwidth[i+1];
  435.     precision[i] = precision[i+1];
  436.     hidden_col[i] = hidden_col[i+1];
  437.     }
  438.  
  439.     maxcol--;
  440.     FullUpdate++;
  441.     modflg++;
  442. }
  443.  
  444.