home *** CD-ROM | disk | FTP | other *** search
/ Power-Programmierung / CD2.mdf / c / tcpp / examples / tcalc / tcommand.c < prev    next >
Encoding:
C/C++ Source or Header  |  1990-06-10  |  18.7 KB  |  834 lines
  1. /* Turbo C - (C) Copyright 1987,1988,1990 by Borland International */
  2.  
  3. #include <string.h>
  4. #include <mem.h>
  5. #include <stdio.h>
  6. #include <math.h>
  7. #include <io.h>
  8. #include <fcntl.h>
  9. #include <conio.h>
  10. #include "tcalc.h"
  11.  
  12. char *name = MSGNAME;
  13.  
  14. void moverowup(void)
  15. /* Bewegt den Cursor eine Zeile nach oben */
  16. {
  17.  displaycell(curcol, currow, NOHIGHLIGHT, NOUPDATE);
  18.  if (currow > toprow)
  19.   currow--;
  20.  else if (toprow != 0)
  21.  {
  22.   scroll(DOWN, 1, LEFTMARGIN + 1, 3, 80, SCREENROWS + 2, WHITE);
  23.   displayrow(--toprow, NOUPDATE);
  24.   currow--;
  25.   setbottomrow();
  26.  }
  27. } /* moverowup */
  28.  
  29. void moverowdown(void)
  30. /* Bewegt den Cursor eine Zeile nach unten */
  31. {
  32.  displaycell(curcol, currow, NOHIGHLIGHT, NOUPDATE);
  33.  if (currow < bottomrow)
  34.   currow++;
  35.  else if (bottomrow < (MAXROWS - 1))
  36.  {
  37.   scroll(UP, 1, LEFTMARGIN + 1, 3, 80, SCREENROWS + 2, WHITE);
  38.   toprow++;
  39.   currow++;
  40.   setbottomrow();
  41.   displayrow(bottomrow, NOUPDATE);
  42.  }
  43. } /* moverowdown */
  44.  
  45. void movecolleft(void)
  46. /* Bewegt den Cursor eine Spalte nach links */
  47. {
  48.  int col, oldleftcol;
  49.  unsigned char oldcolstart[SCREENCOLS];
  50.  
  51.  oldleftcol = leftcol;
  52.  movmem(colstart, oldcolstart, sizeof(colstart));
  53.  displaycell(curcol, currow, NOHIGHLIGHT, NOUPDATE);
  54.  if (curcol > leftcol)
  55.   curcol--;
  56.  else if (leftcol != 0)
  57.  {
  58.   curcol--;
  59.   leftcol--;
  60.   setrightcol();
  61.   setleftcol();
  62.   if (oldleftcol <= rightcol)
  63.    scroll(RIGHT, colstart[oldleftcol - leftcol] - LEFTMARGIN, LEFTMARGIN + 1,
  64.           3, 80, SCREENROWS + 2, WHITE);
  65.   clearlastcol();
  66.   for (col = leftcol; col <= oldleftcol - 1; col++)
  67.    displaycol(col, NOUPDATE);
  68.  }
  69. } /* movecolleft */
  70.  
  71. void movecolright(void)
  72. /* Bewegt den Cursor eine Spalte nach rechts */
  73. {
  74.  int col, oldleftcol, oldrightcol;
  75.  unsigned char oldcolstart[SCREENCOLS];
  76.  
  77.  movmem(colstart, oldcolstart, sizeof(colstart));
  78.  oldleftcol = leftcol;
  79.  oldrightcol = rightcol;
  80.  displaycell(curcol, currow, NOHIGHLIGHT, NOUPDATE);
  81.  if (curcol < rightcol)
  82.   curcol++;
  83.  else if (rightcol < (MAXCOLS - 1))
  84.  {
  85.   curcol++;
  86.   rightcol++;
  87.   setleftcol();
  88.   setrightcol();
  89.   if (oldrightcol >= leftcol)
  90.    scroll(LEFT, oldcolstart[leftcol - oldleftcol] - LEFTMARGIN,
  91.           LEFTMARGIN + 1, 3, 80, SCREENROWS + 2, WHITE);
  92.   clearlastcol();
  93.   for (col = oldrightcol + 1; col <= rightcol; col++)
  94.    displaycol(col, NOUPDATE);
  95.  }
  96. } /* movecolright */
  97.  
  98. void recalc(void)
  99. /* Rechnet alle Zahlen im Rechenblatt neu durch */
  100. {
  101.  int col, row, dummy;
  102.  
  103.  for (col = 0; col <= lastcol; col++)
  104.  {
  105.   for (row = 0; row <= lastrow; row++)
  106.   {
  107.    if ((cell[col][row] != NULL) && (cell[col][row]->attrib == FORMULA))
  108.     cell[col][row]->v.f.fvalue = parse(cell[col][row]->v.f.formula, &dummy);
  109.   }
  110.  }
  111.  displayscreen(UPDATE);
  112. } /* recalc */
  113.  
  114. void changeautocalc(int newmode)
  115. /* Ändert den aktuellen AutoCalc-Modus und gibt ihn auf dem Bildschirm aus */
  116. {
  117.  char s[15];
  118.  
  119.  if (!autocalc && newmode)
  120.   recalc();
  121.  autocalc = newmode;
  122.  if (autocalc)
  123.   strcpy(s, MSGAUTOCALC);
  124.  else
  125.   s[0] = 0;
  126.  writef(73, 1, MSGAUTOCALCCOLOR, strlen(MSGAUTOCALC), s);
  127. } /* autocalc */
  128.  
  129. void changeformdisplay(int newmode)
  130. /* Ändert den aktuellen Formelanzeigemodus und gibt ihn auf dem Bildschirm aus */
  131. {
  132.  char s[15];
  133.  
  134.  formdisplay = newmode;
  135.  if (formdisplay)
  136.   strcpy(s, MSGFORMDISPLAY);
  137.  else
  138.   s[0] = 0;
  139.  writef(65, 1, MSGFORMDISPLAYCOLOR, strlen(MSGFORMDISPLAY), s);
  140. } /* autocalc */
  141.  
  142. void editcell(CELLPTR ecell)
  143. /* Editiert eine ausgewählte Zelle */
  144. {
  145.  char s[MAXINPUT + 1];
  146.  
  147.  if (ecell == NULL)
  148.   return;
  149.  switch(ecell->attrib)
  150.  {
  151.   case TEXT :
  152.    strcpy(s, ecell->v.text);
  153.    break;
  154.   case VALUE :
  155.    if (ecell->v.value == HUGE_VAL)
  156.     strcpy(s, "0");
  157.    else
  158.     sprintf(s, "%.*f", MAXPLACES, ecell->v.value);
  159.    break;
  160.   case FORMULA :
  161.    strcpy(s, ecell->v.f.formula);
  162.    break;
  163.  } /* switch */
  164.  if (!editstring(s, "", MAXINPUT) || (s[0] == 0))
  165.   return;
  166.  act(s);
  167.  changed = TRUE;
  168. } /* editcell */
  169.  
  170. void clearsheet(void)
  171. /* Löscht das aktuelle Rechenblatt */
  172. {
  173.  int col, row;
  174.  
  175.  for (row = 0; row <= lastrow; row++)
  176.  {
  177.   for (col = 0; col <= lastcol; col++)
  178.    deletecell(col, row, NOUPDATE);
  179.  }
  180.  initvars();
  181.  setrightcol();
  182.  setbottomrow();
  183.  displayscreen(NOUPDATE);
  184.  printfreemem();
  185.  changed = FALSE;
  186. } /* clearsheet */
  187.  
  188. struct CELLREC rec;
  189.  
  190. void loadsheet(char *filename)
  191. /* Lädt ein neues Rechenblatt */
  192. {
  193.  int size, allocated, reallastcol = 0, reallastrow = 0, file;
  194.  char check[81];
  195.  
  196.  if (filename[0] == 0)
  197.  {
  198.   writeprompt(MSGFILENAME);
  199.   if (!editstring(filename, "", MAXINPUT))
  200.    return;
  201.  }
  202.  if (access(filename, 0))
  203.  {
  204.   errormsg(MSGNOEXIST);
  205.   return;
  206.  }
  207.  if ((file = open(filename, O_RDWR | O_BINARY)) == -1)
  208.  {
  209.   errormsg(MSGNOOPEN);
  210.   return;
  211.  }
  212.  read(file, check, strlen(name) + 1);
  213.  if (strcmp(check, name) != 0)
  214.  {
  215.   errormsg(MSGNOTURBOCALC);
  216.   close(file);
  217.   return;
  218.  }
  219.  writef(1, 25, PROMPTCOLOR, 79, MSGLOADING);
  220.  gotoxy(strlen(MSGLOADING) + 1, 25);
  221.  clearsheet();
  222.  read(file, (char *)&size, 1);
  223.  read(file, (char *)&lastcol, 2);
  224.  read(file, (char *)&lastrow, 2);
  225.  read(file, (char *)&size, 2);
  226.  read(file, colwidth, sizeof(colwidth));
  227.  do
  228.  {
  229.   if (read(file, (char *)&curcol, 2) <= 0)
  230.    break;
  231.   read(file, (char *)&currow, 2);
  232.   read(file, &format[curcol][currow], 1);
  233.   read(file, (char *)&size, 2);
  234.   read(file, (char *)&rec, size);
  235.   switch (rec.attrib)
  236.   {
  237.    case TEXT :
  238.     if ((allocated = alloctext(curcol, currow, rec.v.text)) == TRUE)
  239.      setoflags(curcol, currow, NOUPDATE);
  240.     break;
  241.    case VALUE :
  242.     allocated = allocvalue(curcol, currow, rec.v.value);
  243.     break;
  244.    case FORMULA :
  245.     allocated = allocformula(curcol, currow, rec.v.f.formula, rec.v.f.fvalue);
  246.     break;
  247.   } /* switch */
  248.   if (!allocated)
  249.   {
  250.    errormsg(MSGFILELOMEM);
  251.    lastrow = reallastrow;
  252.    lastcol = reallastcol;
  253.    format[curcol][currow] = DEFAULTFORMAT;
  254.    break;
  255.   }
  256.   else
  257.   {
  258.    if (curcol > reallastcol)
  259.     reallastcol = curcol;
  260.    if (currow > reallastrow)
  261.     reallastrow = currow;
  262.   }
  263.  }
  264.  while (TRUE);
  265.  writef(1, 25, WHITE, strlen(MSGLOADING), "");
  266.  gotoxy(1, 25);
  267.  printfreemem();
  268.  close(file);
  269.  curcol = currow = 0;
  270.  setrightcol();
  271.  displayscreen(NOUPDATE);
  272.  changed = FALSE;
  273. } /* loadsheet */
  274.  
  275. void savesheet(void)
  276. /* Speichert das akuelle Rechenblatt */
  277. {
  278.  char filename[MAXINPUT+1], eof = 26;
  279.  int size, col, row, overwrite, file;
  280.  CELLPTR cellptr;
  281.  
  282.  filename[0] = 0;
  283.  writeprompt(MSGFILENAME);
  284.  if (!editstring(filename, "", MAXINPUT))
  285.   return;
  286.  if (!access(filename, 0))
  287.  {
  288.   if (!getyesno(&overwrite, MSGOVERWRITE) || (overwrite == 'N'))
  289.    return;
  290.  }
  291.  if ((file = open(filename, O_RDWR | O_CREAT | O_TRUNC | O_BINARY,
  292.   S_IREAD | S_IWRITE)) == -1)
  293.  {
  294.   errormsg(MSGNOOPEN);
  295.   return;
  296.  }
  297.  writef(1, 25, PROMPTCOLOR, 79, MSGSAVING);
  298.  gotoxy(strlen(MSGSAVING) + 1, 25);
  299.  write(file, name, strlen(name) + 1);
  300.  write(file, &eof, 1);
  301.  write(file, (char *)&lastcol, 2);
  302.  write(file, (char *)&lastrow, 2);
  303.  size = MAXCOLS;
  304.  write(file, (char *)&size, 2);
  305.  write(file, colwidth, sizeof(colwidth));
  306.  for (row = 0; row <= lastrow; row++)
  307.  {
  308.   for (col = lastcol; col >= 0; col--)
  309.   {
  310.    if (cell[col][row] != NULL)
  311.    {
  312.     cellptr = cell[col][row];
  313.     switch(cellptr->attrib)
  314.     {
  315.      case TEXT :
  316.       size = strlen(cellptr->v.text) + 2;
  317.       break;
  318.      case VALUE :
  319.       size = sizeof(double) + 1;
  320.       break;
  321.      case FORMULA :
  322.       size = strlen(cellptr->v.f.formula) + 2 + sizeof(double);
  323.       break;
  324.     } /* switch */
  325.     write(file, (char *)&col, 2);
  326.     write(file, (char *)&row, 2);
  327.     write(file, (char *)&format[col][row], 1);
  328.     write(file, (char *)&size, 2);
  329.     write(file, (char *)cellptr, size);
  330.    }
  331.   }
  332.  }
  333.  close(file);
  334.  writef(1, 25, WHITE, strlen(MSGSAVING), "");
  335.  gotoxy(1, 25);
  336.  changed = FALSE;
  337. } /* savesheet */
  338.  
  339. int pagerows(int row, int toppage, int border)
  340. /* Liefert die Anzahl der Zeilen, die gedruckt werden */
  341. {
  342.  int rows;
  343.  
  344.  rows = toppage ? 66 - TOPMARGIN : 66;
  345.  if (border)
  346.   rows--;
  347.  if (row + rows - 1 > lastrow)
  348.   return(lastrow - row + 1);
  349.  else
  350.   return(rows);
  351. } /* pagerows */
  352.  
  353. int pagecols(int col, int border, int columns)
  354. /* Liefert die Anzahl der Spalten, die gedruckt werden,
  355.    beginnend bei Spalte col
  356. */
  357. {
  358.  int len = ((col == 0) && (border)) ? columns - LEFTMARGIN : columns;
  359.  int firstcol = col;
  360.  
  361.  while ((len > 0) && (col <= lastcol))
  362.   len -= colwidth[col++];
  363.  if (len < 0)
  364.   col--;
  365.  return(col - firstcol);
  366. } /* pagecols */
  367.  
  368. void printsheet(void)
  369. /* Druckt das Rechenblatt in eine Datei oder auf den Drucker */
  370. {
  371.  char filename[MAXINPUT + 1], s[133], colstr[MAXCOLWIDTH + 1];
  372.  FILE *file;
  373.  int columns, counter1, counter2, counter3, col = 0, row, border, toppage,
  374.   lcol, lrow, dummy, printed, oldlastcol;
  375.  
  376.  filename[0] = 0;
  377.  writeprompt(MSGPRINT);
  378.  if (!editstring(filename, "", MAXINPUT))
  379.   return;
  380.  if (filename[0] == 0)
  381.   strcpy(filename, "PRN");
  382.  if ((file = fopen(filename, "wt")) == NULL)
  383.  {
  384.   errormsg(MSGNOOPEN);
  385.   return;
  386.  }
  387.  oldlastcol = lastcol;
  388.  for (counter1 = 0; counter1 <= lastrow; counter1++)
  389.  {
  390.   for (counter2 = lastcol; counter2 < MAXCOLS; counter2++)
  391.   {
  392.    if (format[counter2][counter1] >= OVERWRITE)
  393.     lastcol = counter2;
  394.   }
  395.  }
  396.  if (!getyesno(&columns, MSGCOLUMNS))
  397.   return;
  398.  columns = (columns == 'Y') ? 131 : 79;
  399.  if (!getyesno(&border, MSGBORDER))
  400.   return;
  401.  border = (border == 'Y');
  402.  while (col <= lastcol)
  403.  {
  404.   row = 0;
  405.   toppage = TRUE;
  406.   lcol = pagecols(col, border, columns) + col;
  407.   while (row <= lastrow)
  408.   {
  409.    lrow = pagerows(row, toppage, border) + row;
  410.    printed = 0;
  411.    if (toppage)
  412.    {
  413.     for (counter1 = 0; counter1 < TOPMARGIN; counter1++)
  414.     {
  415.      fprintf(file, "\n");
  416.      printed++;
  417.     }
  418.    }
  419.    for (counter1 = row; counter1 < lrow; counter1++)
  420.    {
  421.     if ((border) && (counter1 == row) && (toppage))
  422.     {
  423.      if ((col == 0) && (border))
  424.       sprintf(s, "%*s", LEFTMARGIN, "");
  425.      else
  426.       s[0] = 0;
  427.      for (counter3 = col; counter3 < lcol; counter3++)
  428.      {
  429.       centercolstring(counter3, colstr);
  430.       strcat(s, colstr);
  431.      }
  432.      fprintf(file, "%s\n", s);
  433.      printed++;
  434.     }
  435.     if ((col == 0) && (border))
  436.      sprintf(s, "%-*d", LEFTMARGIN, counter1 + 1);
  437.     else
  438.      s[0] = 0;
  439.     for (counter2 = col; counter2 < lcol; counter2++)
  440.      strcat(s, cellstring(counter2, counter1, &dummy, FORMAT));
  441.     fprintf(file, "%s\n", s);
  442.     printed++;
  443.    }
  444.    row = lrow;
  445.    toppage = FALSE;
  446.    if (printed < 66)
  447.     fprintf(file, "%c", FORMFEED);
  448.   }
  449.   col = lcol;
  450.  }
  451.  fclose(file);
  452.  lastcol = oldlastcol;
  453. } /* printsheet */
  454.  
  455. void setcolwidth(int col)
  456. /* Setzt die neue Spaltenbreite für eine gewählte Spalte */
  457. {
  458.  int width, row;
  459.  
  460.  writeprompt(MSGCOLWIDTH);
  461.  if (!getint(&width, MINCOLWIDTH, MAXCOLWIDTH))
  462.   return;
  463.  colwidth[col] = width;
  464.  setrightcol();
  465.  if (rightcol < col)
  466.  {
  467.   rightcol = col;
  468.   setleftcol();
  469.   setrightcol();
  470.  }
  471.  for (row = 0; row <= lastrow; row++)
  472.  {
  473.   if ((cell[col][row] != NULL) && (cell[col][row]->attrib == TEXT))
  474.    clearoflags(col + 1, row, NOUPDATE);
  475.   else
  476.    clearoflags(col, row, NOUPDATE);
  477.   updateoflags(col, row, NOUPDATE);
  478.  }
  479.  displayscreen(NOUPDATE);
  480.  changed = TRUE;
  481. } /* setcolwidth */
  482.  
  483. void gotocell()
  484. /* Bewegt den Cursor in eine gewählte Zelle */
  485. {
  486.  writeprompt(MSGGOTO);
  487.  if (!getcell(&curcol, &currow))
  488.   return;
  489.  leftcol = curcol;
  490.  toprow = currow;
  491.  setbottomrow();
  492.  setrightcol();
  493.  setleftcol();
  494.  displayscreen(NOUPDATE);
  495. } /* gotocell */
  496.  
  497. void formatcells(void)
  498. /* Fordert den Benutzer auf, ein gewähltes Format
  499.    oder einen Zellbereich anzugeben
  500. */
  501. {
  502.  int col, row, col1, col2, row1, row2, temp, newformat = 0;
  503.  
  504.  writeprompt(MSGCELL1);
  505.  if (!getcell(&col1, &row1))
  506.   return;
  507.  writeprompt(MSGCELL2);
  508.  if (!getcell(&col2, &row2))
  509.   return;
  510.  if ((col1 != col2) && (row1 != row2))
  511.   errormsg(MSGDIFFCOLROW);
  512.  else
  513.  {
  514.   if (col1 > col2)
  515.    swap(&col1, &col2);
  516.   if (row1 > row2)
  517.    swap(&row1, &row2);
  518.   if (!getyesno(&temp, MSGRIGHTJUST))
  519.    return;
  520.   newformat += (temp == 'Y') * RJUSTIFY;
  521.   if (!getyesno(&temp, MSGDOLLAR))
  522.    return;
  523.   newformat += (temp == 'Y') * DOLLAR;
  524.   if (!getyesno(&temp, MSGCOMMAS))
  525.    return;
  526.   newformat += (temp == 'Y') * COMMAS;
  527.   if (newformat & DOLLAR)
  528.    newformat += 2;
  529.   else
  530.   {
  531.    writeprompt(MSGPLACES);
  532.    if (!getint(&temp, 0, MAXPLACES))
  533.     return;
  534.    newformat += temp;
  535.   }
  536.   for (col = col1; col <= col2; col++)
  537.   {
  538.    for (row = row1; row <= row2; row++)
  539.    {
  540.     format[col][row] = (format[col][row] & OVERWRITE) | newformat;
  541.     if ((col >= leftcol) && (col <= rightcol) &&
  542.      (row >= toprow) && (row <= bottomrow))
  543.      displaycell(col, row, NOHIGHLIGHT, NOUPDATE);
  544.    }
  545.   }
  546.  }
  547.  changed = TRUE;
  548. } /* formatcells */
  549.  
  550. void deletecol(int col)
  551. /* Löscht eine Spalte */
  552. {
  553.  int counter, row;
  554.  
  555.  for (counter = 0; counter <= lastrow; counter++)
  556.   deletecell(col, counter, NOUPDATE);
  557.  printfreemem();
  558.  if (col != MAXCOLS - 1)
  559.  {
  560.   movmem(&cell[col + 1][0], &cell[col][0], MAXROWS * sizeof(CELLPTR) *
  561.    (MAXCOLS - col - 1));
  562.   movmem(&format[col + 1][0], &format[col][0], MAXROWS * (MAXCOLS - col - 1));
  563.   movmem(&colwidth[col + 1], &colwidth[col], MAXCOLS - col - 1);
  564.  }
  565.  setmem(&cell[MAXCOLS - 1][0], MAXROWS * sizeof(CELLPTR), 0);
  566.  setmem(&format[MAXCOLS - 1][0], MAXROWS, DEFAULTFORMAT);
  567.  colwidth[MAXCOLS - 1] = DEFAULTWIDTH;
  568.  if ((lastcol >= col) && (lastcol > 0))
  569.   lastcol--;
  570.  setrightcol();
  571.  if (curcol > rightcol)
  572.  {
  573.   rightcol++;
  574.   setleftcol();
  575.  }
  576.  clearlastcol();
  577.  for (counter = 0; counter <= lastcol; counter++)
  578.  {
  579.   for (row = 0; row <= lastrow; row++)
  580.   {
  581.    if ((cell[counter][row] != NULL) &&
  582.     (cell[counter][row]->attrib == FORMULA))
  583.     fixformula(counter, row, COLDEL, col);
  584.    updateoflags(col, row, NOUPDATE);
  585.   }
  586.  }
  587.  while (col <= rightcol)
  588.   displaycol(col++, NOUPDATE);
  589.  changed = TRUE;
  590.  recalc();
  591. } /* deletecol */
  592.  
  593. void insertcol(int col)
  594. /* Fügt eine Spalte ein */
  595. {
  596.  int counter, row;
  597.  
  598.  if (lastcol == MAXCOLS - 1)
  599.  {
  600.   for (counter = 0; counter <= lastrow; counter++)
  601.    deletecell(lastcol, counter, NOUPDATE);
  602.   printfreemem();
  603.  }
  604.  if (col != MAXCOLS - 1)
  605.  {
  606.   movmem(&cell[col][0], &cell[col + 1][0], MAXROWS * sizeof(CELLPTR) *
  607.    (MAXCOLS - col - 1));
  608.   movmem(&format[col][0], &format[col + 1][0], MAXROWS * (MAXCOLS - col - 1));
  609.   movmem(&colwidth[col], &colwidth[col + 1], MAXCOLS - col - 1);
  610.  }
  611.  setmem(&cell[col][0], MAXROWS * sizeof(CELLPTR), 0);
  612.  setmem(&format[col][0], MAXROWS, DEFAULTFORMAT);
  613.  colwidth[col] = DEFAULTWIDTH;
  614.  lastcol = MAXCOLS - 1;
  615.  setlastcol();
  616.  setrightcol();
  617.  if (curcol > rightcol)
  618.  {
  619.   rightcol++;
  620.   setleftcol();
  621.  }
  622.  for (counter = 0; counter <= lastcol; counter++)
  623.  {
  624.   for (row = 0; row <= lastrow; row++)
  625.   {
  626.    if ((cell[counter][row] != NULL) &&
  627.     (cell[counter][row]->attrib == FORMULA))
  628.     fixformula(counter, row, COLADD, col);
  629.    updateoflags(col, row, NOUPDATE);
  630.   }
  631.  }
  632.  while (col <= rightcol)
  633.   displaycol(col++, NOUPDATE);
  634.  changed = TRUE;
  635.  recalc();
  636. } /* insertcol */
  637.  
  638. void deleterow(int row)
  639. /* Löscht eine Zeile */
  640. {
  641.  int counter, rowc;
  642.  
  643.  for (counter = 0; counter <= lastcol; counter++)
  644.   deletecell(counter, row, NOUPDATE);
  645.  printfreemem();
  646.  if (row != MAXROWS - 1)
  647.  {
  648.   for (counter = 0; counter < MAXCOLS; counter++)
  649.   {
  650.    movmem(&cell[counter][row + 1], &cell[counter][row],
  651.     sizeof(CELLPTR) * (MAXROWS - row - 1));
  652.    movmem(&format[counter][row + 1], &format[counter][row], MAXROWS - row - 1);
  653.   }
  654.  }
  655.  else
  656.  {
  657.   for (counter = 0; counter <= lastcol; counter++)
  658.   {
  659.    cell[counter][MAXROWS - 1] = NULL;
  660.    format[counter][MAXROWS - 1] = DEFAULTFORMAT;
  661.   }
  662.  }
  663.  if ((lastrow >= row) && (lastrow > 0))
  664.   lastrow--;
  665.  for (counter = 0; counter <= lastcol; counter++)
  666.  {
  667.   for (rowc = 0; rowc <= lastrow; rowc++)
  668.   {
  669.    if ((cell[counter][rowc] != NULL) &&
  670.     (cell[counter][rowc]->attrib == FORMULA))
  671.     fixformula(counter, rowc, ROWDEL, row);
  672.   }
  673.  }
  674.  while (row <= bottomrow)
  675.   displayrow(row++, NOUPDATE);
  676.  changed = TRUE;
  677.  recalc();
  678. } /* deleterow */
  679.  
  680. void insertrow(int row)
  681. /* Fügt eine Zeile ein */
  682. {
  683.  int counter, rowc;
  684.  
  685.  if (lastrow == MAXROWS - 1)
  686.  {
  687.   for (counter = 0; counter <= lastcol; counter++)
  688.    deletecell(counter, lastrow, NOUPDATE);
  689.   printfreemem();
  690.  }
  691.  if (row != MAXROWS - 1)
  692.  {
  693.   for (counter = 0; counter < MAXCOLS; counter++)
  694.   {
  695.    movmem(&cell[counter][row], &cell[counter][row + 1],
  696.     sizeof(CELLPTR) * (MAXROWS - row - 1));
  697.    movmem(&format[counter][row], &format[counter][row + 1], MAXROWS - row - 1);
  698.   }
  699.  }
  700.  for (counter = 0; counter < MAXCOLS; counter++)
  701.  {
  702.   cell[counter][row] = NULL;
  703.   format[counter][row] = DEFAULTFORMAT;
  704.  }
  705.  lastrow = MAXROWS - 1;
  706.  setlastrow();
  707.  for (counter = 0; counter <= lastcol; counter++)
  708.  {
  709.   for (rowc = 0; rowc <= lastrow; rowc++)
  710.   {
  711.    if ((cell[counter][rowc] != NULL) &&
  712.     (cell[counter][rowc]->attrib == FORMULA))
  713.     fixformula(counter, rowc, ROWADD, row);
  714.   }
  715.  }
  716.  while (row <= bottomrow)
  717.   displayrow(row++, NOUPDATE);
  718.  changed = TRUE;
  719.  recalc();
  720. } /* insertrow */
  721.  
  722. void smenu(void)
  723. /* Führt die Befehle im Rechenblatt-Menü aus */
  724. {
  725.  char filename[MAXINPUT + 1];
  726.  
  727.  filename[0] = 0;
  728.  switch(getcommand(SMENU, SCOMMAND))
  729.  {
  730.   case 0 :
  731.    checkforsave();
  732.    loadsheet(filename);
  733.    break;
  734.   case 1 :
  735.    savesheet();
  736.    break;
  737.   case 2 :
  738.    printsheet();
  739.    break;
  740.   case 3 :
  741.    checkforsave();
  742.    clearsheet();
  743.    break;
  744.  } /* switch */
  745. } /* smenu */
  746.  
  747. void cmenu(void)
  748. /* Führt die Befehle im Spalte-Menü aus */
  749. {
  750.  switch(getcommand(CMENU, CCOMMAND))
  751.  {
  752.   case 0 :
  753.    insertcol(curcol);
  754.    break;
  755.   case 1 :
  756.    deletecol(curcol);
  757.    break;
  758.   case 2 :
  759.    setcolwidth(curcol);
  760.    break;
  761.  } /* switch */
  762. } /* cmenu */
  763.  
  764. void rmenu(void)
  765. /* Führt die Befehle im Zeile-Menü aus */
  766. {
  767.  switch(getcommand(RMENU, RCOMMAND))
  768.  {
  769.   case 0 :
  770.    insertrow(currow);
  771.    break;
  772.   case 1 :
  773.    deleterow(currow);
  774.    break;
  775.  } /* switch */
  776. } /* rmenu */
  777.  
  778. void umenu(void)
  779. /* Führt die Befehle im Diverses-Menu aus */
  780. {
  781.  switch(getcommand(UMENU, UCOMMAND))
  782.  {
  783.   case 0 :
  784.    recalc();
  785.    break;
  786.   case 1 :
  787.    changeformdisplay(!formdisplay);
  788.    displayscreen(UPDATE);
  789.    break;
  790.  } /* switch */
  791. } /* umenu */
  792.  
  793. void mainmenu(void)
  794. /* Führt die Befehle im Hauptmenü aus */
  795. {
  796.  switch(getcommand(MENU, COMMAND))
  797.  {
  798.   case 0 :
  799.    smenu();
  800.    break;
  801.   case 1 :
  802.    formatcells();
  803.    break;
  804.   case 2 :
  805.    deletecell(curcol, currow, UPDATE);
  806.    printfreemem();
  807.    if (autocalc)
  808.     recalc();
  809.    break;
  810.   case 3 :
  811.    gotocell();
  812.    break;
  813.   case 4 :
  814.    cmenu();
  815.    break;
  816.   case 5 :
  817.    rmenu();
  818.    break;
  819.   case 6 :
  820.    editcell(curcell);
  821.    break;
  822.   case 7 :
  823.    umenu();
  824.    break;
  825.   case 8 :
  826.    changeautocalc(!autocalc);
  827.    break;
  828.   case 9 :
  829.    checkforsave();
  830.    stop = TRUE;
  831.    break;
  832.  } /* switch */
  833. } /* mainmenu */
  834.