home *** CD-ROM | disk | FTP | other *** search
/ Mega Top 1 / os2_top1.zip / os2_top1 / APPS / EDITORS / EHP12 / AUS_3.C < prev    next >
C/C++ Source or Header  |  1993-11-16  |  65KB  |  1,531 lines
  1. /****************************************************************/
  2. /*                                                              */
  3. /*      MODUL:  aus_3.c                                         */
  4. /*                                                              */
  5. /*      FUNKTIONEN:                                             */
  6. /*              - do_control (Kontrollzeichen in Text einfg.)   */
  7. /*              - hndl_insert (Insert-Teil von do_inschar)      */
  8. /*              - hndl_overwrite (Overwrite-Teil von do_inschar)*/
  9. /*              - do_inschar (Zeichen in Text einfuegen)        */
  10. /*              - do_tog_tkm (Tabkomprimierungsmodus togglen)   */
  11. /*              - do_tog_bak (Backupfileerzeugungsmodus togglen)*/
  12. /*              - do_tog_ai (Autoindentmodus togglen)           */
  13. /*              - do_movewin (Fensterbewegung kontrollieren)    */
  14. /*              - do_toggle_size (Fenster auf gespeicherte Gr.) */
  15. /*              - do_sizewin (Fenstergroessenanpassung kontr.)  */
  16. /*              - do_swnext (Zum "Nachfolger" des akt. Fensters)*/
  17. /*              - do_swprev (Zum Vorgaenger des akt. Fensters)  */
  18. /*              - do_swnum (Window absolut anspringen)          */
  19. /*              - do_repeat (Funktion mehrmals ausfuehren)      */
  20. /*              - do_blstart (Blockanfang setzen)               */
  21. /*              - do_blnormend (Blockende (normal) setzen)      */
  22. /*              - do_blrechtend (Blockende (Rechteck) setzen)   */
  23. /*              - do_blunmark (Blockmarkierung loeschen)        */
  24. /*              - do_blweg (Block loeschen)                     */
  25. /*              - do_blcopy (Block kopieren)                    */
  26. /*              - do_blmove (Block verschieben)                 */
  27. /*              - do_blcut (Block in PASTE-Puffer kopieren)     */
  28. /*              - do_blpaste (PASTE-Puffer in Text einfuegen)   */
  29. /*              - do_blindent (Block einruecken)                */
  30. /*              - do_blread (Block einlesen)                    */
  31. /*              - do_blwrite (Block schreiben)                  */
  32. /*              - do_goblend (Zum Blockende gehen)              */
  33. /*              - do_goblanf (Zum Blockanfang gehen)            */
  34. /*              - do_bltofil (Block an Filter uebergeben)       */
  35. /*              - do_toghbl (Blockhervorhebungsmodus togglen)   */
  36. /*              - do_shelltog (Shellflag invertieren)           */
  37. /*              - do_setmarker (Marker setzen)                  */
  38. /*              - do_jumpmarker (Marker anspringen)             */
  39. /*              - do_lastpos (Letzte Position anspringen)       */
  40. /*              - do_swname (Window gemaess Name suchen)        */
  41. /*              - do_newname (Datei unter neuem Namen speichern)*/
  42. /*              - do_macro (Macro definieren/ausfuehren)        */
  43. /*              - do_restline (geloeschte Zeile wiederherstelen)*/
  44. /*              - auswertung (Tastendruck auswerten)            */
  45. /****************************************************************/
  46.  
  47. #include "defs.h"
  48. #include "keys.h"
  49.  
  50. void do_inschar();
  51.  
  52. extern char backupflag,highblockflag,clear_buff,bufflag;
  53. extern int schreib_file(),to_shell(),save_all();
  54. extern short int letter,lastcode,aktcode,mc_index,taste();
  55. extern int save_delline(),rest_delline();
  56. extern int tst_overlap();
  57. extern char bufflag,*loadfile,regexflag;
  58. extern bzeil_typ *save_normal(),*save_rechteck();
  59. extern block_typ global_block,*dup_block();
  60. extern puff_typ macro[],puff_feld[];
  61. extern int ks_index;
  62. extern short int *keystack,*e_keystack,newwgetch();
  63. extern WINDOW *status;
  64. extern marker_typ marker[];
  65. extern char *on_off[], /* Hilfstexte */
  66.                /* fuer Togglen der globalen Flags */
  67.         helpflag;  /* Flag: Hilfstexte anzeigen       */
  68.  
  69. extern void do_refresh(), do_bol(),do_eol(),do_halfup(),do_halfdn(),do_delete(),
  70.         do_backspace(),do_home(),do_nothome(),do_insovr(),do_textbeginn(),
  71.         do_eot(),do_del_word(),do_wleft(),do_wright(),do_right(),do_left(),
  72.         do_up(),do_down(),do_pgup(),do_pgdn(),do_newline(),do_delline(),
  73.         ueberschreiben(),do_schreib_file(),quit(),do_help(),laden(),
  74.         do_win_zu(),do_goto(),do_ende(),do_find(),do_replace(),
  75.         do_underline(),do_z_hoch(),do_z_runter(),do_z_oben(),
  76.         do_z_mitte(),do_z_unten(),do_deleol(),do_repfr(),do_repfr(),
  77.         do_join(),do_open(),do_tab(),do_settab(),do_hopen(),
  78.         do_backtab(),do_endemit(),quitmit(),do_find(), do_repfr(),
  79.         do_replace(),do_matchpar(),do_middle();
  80.  
  81.  
  82. /*****************************************************************************
  83. *
  84. *  Funktion       Kontrollzeichen in Text (do_control)
  85. *  --------
  86. *
  87. *  Beschreibung : Es wird ein Zeichen mit getch() eingelesen und ueber die
  88. *                 Funktion do_inschar in den Text plaziert.
  89. *
  90. *****************************************************************************/
  91.  
  92. void do_control()
  93. {
  94.   /* *** interne Daten, Initialisierung *** */
  95.  
  96.   if(letter = newwgetch(akt_winp->winp)) /* Ein Zeichen lesen. Nur wenn es */
  97.     do_inschar();                   /* nicht '\0' ist, wird es eingefuegt. */
  98. }
  99.  
  100.  
  101. /*****************************************************************************
  102. *
  103. *  Funktion       Insert-Teil von do_inschar behandeln (hndl_insert)
  104. *  --------
  105. *
  106. *  Paramater    : restn     :
  107. *                   Typ         : int *
  108. *                   Wertebereich: Pointer auf Integer
  109. *                   Bedeutung   : Anzahl der Zeichen, die noch einge-
  110. *                                 fuegt werden muessen
  111. *
  112. *  Ergebnis     :
  113. *                   Typ         : int
  114. *                   Wertebereich: TRUE, FALSE
  115. *                   Bedeutung   : TRUE: hat geklappt
  116. *                                 FALSE: hat nicht geklappt
  117. *
  118. *  Beschreibung : Es wird versucht, Platz fuer die einzufuegenden Zeichen
  119. *                 zu schaffen. Gelingt es nicht, ein einziges Zeichen ein-
  120. *                 zufuegen, wird eine neue Zeile eingefuegt. Je nachdem ob
  121. *                 die aktuelle Zeile am Ende aufgespalten wurde oder nicht
  122. *                 wird mit dem Einfuegen in der aktuellen oder der neuen
  123. *                 Zeile fortgefahren.
  124. *
  125. *****************************************************************************/
  126.  
  127. int hndl_insert(restn)
  128. int *restn;
  129. {
  130.   /* *** interne Daten *** */
  131.   int hilf;
  132.  
  133.   /* Anzahl eingefuegter Zeichen merken und von restn abziehen */
  134.   *restn -= (hilf = insert (*restn));
  135.   if (!hilf)        /* wenn keine Zeichen eingefuegt werden konnten   */
  136.   {
  137.     if (!new_line())     /* neue Zeile einfuegen */
  138.     {
  139.       print_err(T_SIZE_ERRTEXT); /* klappte das nicht, Meldung aus- */
  140.       return(FALSE);             /* geben und Funktion beenden      */
  141.     }
  142.     if (akt_winp->autoindflag)   /* Eventuell aufgespaltene Zeile   */
  143.       indent_line();             /* korrekt einruecken              */
  144.     if (akt_winp->alinep->text)  /* neue Zeile nicht leer?  */
  145.     {
  146.       up();                 /* in alte Zeile, da dort noch Platz */
  147.       eol();                        /* ans Ende */
  148.       if(insert(1))         /* wirklich noch Platz (kann nur  */
  149.       {
  150.     sw_ohne_refresh(W_AKT);
  151.     (*restn)--;         /* Fehler ergeben bei unterstr.Zchn.) ? */
  152.       }                     /* wenn nicht, schlaegt enter_char */
  153.     }                       /* fehl und do_newline wird aufgerufen */
  154.     else                    /* Wenn neue Zeile doch leer, testen ob */
  155.     {                       /* sich Cursor aus Fenster bewegt hat. */
  156.       if(akt_winp->ws_col > akt_winp->screencol) /* gegebenenfalls */
  157.     akt_winp->ws_col = akt_winp->screencol;  /* anpassen */
  158.       (*restn)--;           /* Neue Zeile ist leer, also kann ein */
  159.       sw_ohne_refresh(W_AKT);    /* Zeichen eingefuegt werden. */
  160.     } /* Fensterinhalt muss aber wegen eingefuegter Zeile neu */
  161.   }   /* angezeigt werden.                                    */
  162.   return(TRUE);
  163. }
  164.  
  165. /*****************************************************************************
  166. *
  167. *  Funktion       Overwrite-Teil von do_inschar behandeln (hndl_overwrite)
  168. *  --------
  169. *
  170. *  Paramater    : restn     :
  171. *                   Typ         : int *
  172. *                   Wertebereich: Pointer auf Integer
  173. *                   Bedeutung   : Anzahl der Zeichen, die noch einge-
  174. *                                 setzt werden muessen
  175. *
  176. *  Ergebnis     :
  177. *                   Typ         : int
  178. *                   Wertebereich: TRUE, FALSE
  179. *                   Bedeutung   : TRUE: hat geklappt
  180. *                                 FALSE: hat nicht geklappt
  181. *
  182. *  Beschreibung : Es wird getestet, ob Platz fuer die zu schreibenden Zeichen
  183. *                 vorhanden ist. Steht man am Zeilenende, wird versucht, in
  184. *                 die naechste Zeile zu gehen. Ist das nicht moeglich, wird
  185. *                 falls die maxlimale Zeilenanzahl noch nicht erreicht ist,
  186. *                 eine Zeile angehaengt. In der Zeile geht man an den Anfang.
  187. *                 Unterscheidet sich eines der zu ueberschreibenden Zeichen
  188. *                 von dem dazugehörigen einzusetzenden Zeichen in der Laenge
  189. *                 (eins unterstrichen, das andere nicht), dann werden alle
  190. *                 zu überschreibenden Zeichen gelöscht und für die neuen
  191. *                 Zeichen mit insert() Platz geschaffen.
  192. *
  193. *****************************************************************************/
  194.  
  195. int hndl_overwrite(restn)
  196. int *restn;
  197. {
  198.   /* *** interne Daten und Initialisierung *** */
  199.   char swflag = FALSE; /* Flag, ob Fenster neu zu zeichnen ist */
  200.   char u_diff=FALSE;   /* Flag: Einzutragendes Zeichen und zu überschrei- */
  201.                /* bendes Zeichen unterschiedlichen Unterstrcih-Mode */
  202.   int  anz_del=0,      /* Anzahl löschbarer Zeichen */
  203.        old_sc,         /* Zwischenspeicher Screencol */
  204.        old_tc;         /* Zwischenspeicher Textcol */
  205.  
  206.   if(akt_winp->screencol == MAXLENGTH) /* Steht man hinter Zeilenende? */
  207.   {
  208.     if(!down())      /* Eine Zeile runter. Klappt das nicht, dann */
  209.     {                /* testen, ob neue Zeile angehaengt werden kann */
  210.       if(akt_winp->maxline >= MAX_ANZ_LINES-1)
  211.       {
  212.     print_err(T_SIZE_ERRTEXT); /* wenn nein, Meldung ausgeben und raus */
  213.     return(FALSE);
  214.       }
  215.       koppel_line(); /* neue Zeile anhaengen. */
  216.       swflag = TRUE; /* Fensterinhalt ist neu zu zeichnen */
  217.     }
  218.     else
  219.       bol();           /* An den Anfang der Zeile springen */
  220.     if(akt_winp->ws_col)    /* Wenn erste Spalte nicht sichtbar, */
  221.     {                       /* dann sichtbar machen */
  222.       akt_winp->ws_col = 0;
  223.       swflag = TRUE;        /* Fensterinhalt muss neu gezeichnet werden */
  224.     }
  225.     if(swflag)
  226.       sw_ohne_refresh(W_AKT);
  227.   }
  228.  
  229.   fill_buff(); /* Zeile falls noch nicht drin, in Puffer kopieren */
  230.   old_tc = akt_winp->textcol;   /* Textcol und Screencol merken */
  231.   old_sc = akt_winp->screencol;
  232.   do
  233.   {
  234.     if(akt_winp->underflag ^ ul_char()) /* falls Zeichen verschiedene */
  235.                     /* Laengen haben */
  236.       u_diff = TRUE;  /* Merken, daß 2 Zeichen unterschiedlich waren */
  237.     anz_del++;        /* Anzahl zu löschender Zeichen inkrementieren */
  238.   } while (--(*restn) && right()); /* Solange wiederholen, bis alle */
  239.                /* Zeichen geprüft oder Zeilenende erreicht */
  240.   akt_winp->textcol = old_tc;    /* Textcol und Screencol restaurieren */
  241.   akt_winp->screencol = old_sc;
  242.  
  243.   if(u_diff)  /* Hatten 2 Zeichen unterschiedliche Länge ? */
  244.   {
  245.     mdelete(anz_del);       /* Zu überschreibende Zeichen loeschen */
  246.     insert(anz_del);        /* platz fuer neue Zeichen schaffen */
  247.   }
  248.   return(TRUE);
  249. }
  250.  
  251. /*****************************************************************************
  252. *
  253. *  Funktion       Zeichen in Text einfuegen (do_inschar)
  254. *  --------
  255. *
  256. *  Beschreibung : Entsprechend dem insflag wird das in letter stehende Zeichen
  257. *                 in den Text eingefuegt oder ueber den Text geschrieben.
  258. *
  259. *****************************************************************************/
  260.  
  261. void do_inschar()
  262. {
  263.   /* *** interne Daten und Initialisierung *** */
  264.   short    int input [INS_BUFF_LEN]; /* lokaler Eingabepuffer */
  265.   int          restn; /* Anzahl noch einzufuegender Zeichen   */
  266.   register int n=0,   /* Index in lokalen Eingabepuffer       */
  267.            nmax,  /* Anzahl eingelesener Zeichen          */
  268.            hilf;  /* Zum Einlesen einer Tastenkombination */
  269.  
  270.   nodelay (akt_winp->winp,TRUE); /* Tastatur soll -1 liefern, wenn keine */
  271.   do                             /* Taste gedrueckt wurde                */
  272.     input [n++] = letter;        /* Zeichen in Eingabepuffer uebernehmen */
  273.   while (n<INS_BUFF_LEN && (hilf=taste(akt_winp->winp)) == mc_index+1);
  274.   /* Wenn Puffer noch nicht voll, Tastenkombination lesen. Wenn es ein */
  275.   /* Zeichen ist, Aktion wiederholen.                                  */
  276.  
  277.   nodelay (akt_winp->winp,FALSE); /* Fkt. taste soll auf Taste warten */
  278.   lastcode = hilf; /* Letzte gelesene Tastenkombination merken */
  279.   nmax = restn = n; /* Variablen anhand des "Pufferfuellstandes" initial. */
  280.   do
  281.   {
  282.     if (akt_winp->insflag)      /* Nur im Insert-Mode einfuegen */
  283.     {
  284.       if(!hndl_insert(&restn))  /* Einfuegung durchfuehren */
  285.     return;
  286.     }
  287.     else                          /* Sonst Ueberschreiben durchfuehren */
  288.       if(!hndl_overwrite(&restn)) /* Klappte Einfuegen oder Ueberschreiben */
  289.     return;                   /* nicht, dann Funktion verlassen */
  290.     while (enter_char((char) input [nmax-n]) /* Zeichen in Zeile einsetzen */
  291.     && --n>restn); /* Index in input anpassen */
  292.   } while (restn); /* Falls noch Zeichen einzufuegen sind, Aktion wiederholen */
  293.   setz_cursor(W_AKT);   /* Cursor an richtige Position setzen */
  294. }
  295.  
  296. /*****************************************************************************
  297. *
  298. *  Funktion       Tab-Komprimierungs-modus toggeln (do_tog_tkm)
  299. *  --------
  300. *
  301. *  Beschreibung : Der Status des Tab-Komprimierungs-modus wird invertiert.
  302. *                 Außerdem wird der Text als geändert markiert, damit er
  303. *                 abgespeichert wird. Das ist erforderlich, da sonst die
  304. *                 Datei evtl. das alte Format beibehält.
  305. *
  306. *****************************************************************************/
  307.  
  308. void do_tog_tkm()
  309. {
  310.   akt_winp->tabflag ^= TRUE;   /* Tabflagstatus togglen */
  311.   akt_winp->changeflag = TRUE; /* Text soll auf jeden Fall gespeichert werden */
  312.   setz_cursor(W_AKT);          /* Cursor wieder an richtige Position */
  313. }
  314.  
  315. /*****************************************************************************
  316. *
  317. *  Funktion       Backup-Funktion toggeln (do_tog_bak)
  318. *  --------
  319. *
  320. *  Beschreibung : Erzeugung eines .bak-Files wird aktiviert bzw. deaktiviert.
  321. *
  322. *****************************************************************************/
  323.  
  324. void do_tog_bak()
  325. {
  326.   print_stat(PROMPT_BACKUP);   /* Meldung ueber aktuellen Status */
  327.   print_stat(on_off[backupflag ^= TRUE]);  /* in der Statuszeile ausgeben    */
  328.   sleep(2);                                /* Warten, damit User Status lesen kann */
  329.   clear_stat();                            /* Statuszeile wieder loeschen */
  330.   setz_cursor(W_AKT);                           /* Cursor wieder an richtige Stelle */
  331. }
  332.  
  333. /*****************************************************************************
  334. *
  335. *  Funktion       Autoindent-modus toggeln (do_tog_ai)
  336. *  --------
  337. *
  338. *  Beschreibung : Der Status des Autoindent-modus wird invertiert.
  339. *
  340. *****************************************************************************/
  341.  
  342. void do_tog_ai()
  343. {
  344.   akt_winp->autoindflag ^= TRUE;  /* Autoindentflag togglen */
  345.   setz_cursor(W_AKT);                  /* Cursor wieder an richtige Position setzen */
  346. }
  347.  
  348. /*****************************************************************************
  349. *
  350. *  Funktion       Patternmatching-Flag toggeln (do_togregex)
  351. *  --------
  352. *
  353. *  Beschreibung : Der Status des Patternmatching-Modus wird invertiert.
  354. *
  355. *****************************************************************************/
  356.  
  357. void do_togregex()
  358. {
  359.   print_stat(PROMPT_REGEX);    /* Meldung ueber aktuellen Status */
  360.   print_stat(on_off[regexflag ^= TRUE]);   /* in der Statuszeile ausgeben    */
  361.   sleep(2);                                /* Warten, damit User Status lesen kann */
  362.   clear_stat();                            /* Statuszeile wieder loeschen */
  363.   setz_cursor(W_AKT);                      /* Cursor wieder an richtige Stelle */
  364. }
  365.  
  366. /*****************************************************************************
  367. *
  368. *  Funktion       Fensterbewegung kontrollieren (do_movewin)
  369. *  --------
  370. *
  371. *  Beschreibung : Es werden die Ecken des Fensters angezeigt. Anschliessend
  372. *                 wird eine Nutzereingabe ausgewertet, aus der die Bewe-
  373. *                 gunsrichtung entnommen wird. Beendet der Benutzer die
  374. *                 Bewegung, so wird do_refresh() aufgerufen, um das Fenster
  375. *                 an der neuen Position zu zeigen.
  376. *
  377. *****************************************************************************/
  378.  
  379. void do_movewin()
  380. {
  381.   /* *** interne Daten und Initialisierung *** */
  382.   register short int c,  /* Zum Einlesen einer Taste */
  383.              d;  /* Zum Einlesen einer '\0'.. Sequenz */
  384.   int step = SW_STEP,    /* Schrittweite beim Verschieben */
  385.       i;                 /* Zaehler fuer Verschieben mit step != 1 */
  386.  
  387.   werase (akt_winp->winp);  /* Fensterinhalt auf Bildschirm loeschen */
  388.   wrefresh(akt_winp->winp); /* damit kein Fehler beim Verschieben passiert */
  389.   cpwins2stdscr(); /* Alle Fenster ausser akt. nach stdscr kopieren */
  390.   do
  391.   {
  392.     mvprintw(LINES-1,0,PROMPT_WINMOVE,step);
  393.     eckenhw();                 /* Ecken des Fensters markieren         */
  394.     c = newwgetch(stdscr);     /* Ein Zeichen von Tastatur / Macro lesen */
  395.     eckenhw();                 /* Ecken vor Verschieben loeschen       */
  396.     if(c == 's')               /* Bei 's' Schrittweite anpassen */
  397.       step = step == SW_STEP ? 1 : SW_STEP; /* war's 1, dann SW_STEP und umgekehrt */
  398.     else                       /* Sonst <step> mal in angegebene Richtung */
  399. #ifdef OS2  /* Bei OS/2 kein zweites Zeichen lesen! */
  400.     {
  401.       d = c;
  402. #else
  403.       if(c==(short int) '\0')              /* "Escape"-Kombination ? */
  404.       {
  405.     d = newwgetch(stdscr); /* Dann nächstes Zeichen lesen */
  406. #endif
  407.     for(i=0;i<step;i++)      /* verschieben */
  408.       switch (d)
  409.       {
  410.         case KEY_RIGHT : win_right(1); break;
  411.         case KEY_LEFT  : win_left(1);  break;
  412.         case KEY_UP    : win_up(1);    break;
  413.         case KEY_DOWN  : win_down(1);  break;
  414.       }
  415.       } /* Achtung!!! Diese Klammer gehört zum else für OS2, zu if sonst */
  416.   } while (c != END_KEY);      /* Solange wiederholen, bis beendende Taste */
  417.   erase();refresh();           /* gedrueckt wurde (RETURN) */
  418.   mvwin (akt_winp->winp,akt_winp->y,akt_winp->x); /* Fenster verschieben */
  419.   do_refresh();                   /* Alle Fenster neu zeichnen              */
  420. }
  421.  
  422. /*****************************************************************************
  423. *
  424. *  Funktion       Fenster auf gespeicherte Groesse bringen (do_toggle_size)
  425. *  --------
  426. *
  427. *  Beschreibung : Die in der Windowstruktur gespeicherten alten Groessen
  428. *                 und Fensterposition werden mit den aktuellen vertauscht.
  429. *                 Die Cursorposition wird eventuell angepasst. Danach wird
  430. *                 ein do_refresh() ausgefuehrt.
  431. *
  432. *****************************************************************************/
  433.  
  434. void do_toggle_size()
  435. {
  436.   toggle_size();   /* Alte Fensterkoordinaten mit neuen besetzen und umgekehrt */
  437.   do_refresh();    /* Alle Fenster neu zeichnen */
  438. }
  439.  
  440. /*****************************************************************************
  441. *
  442. *  Funktion       Fenstergroessenanpassung kontrollieren (do_sizewin)
  443. *  --------
  444. *
  445. *  Beschreibung : Die Ecken des Fensters werden angezeigt. Dann wird eine
  446. *                 Nutzereingabe ausgewertet, aus der die Bewegungs-
  447. *                 richtung der rechten unteren Fensterecke entnommen wird.
  448. *                 Wird die Groessenanpassung beendet, werden alle Fenster
  449. *                 refresht (do_refresh()).
  450. *
  451. *****************************************************************************/
  452.  
  453. void do_sizewin()
  454. {
  455.   /* *** interne Daten *** */
  456.   register short int c, /* Zum Einlesen einer Taste */
  457.              d; /* Zum Einlesen einer '\0'.. Sequenz */
  458.   int step = SW_STEP,   /* Schrittweite beim Groessenveraendern */
  459.       i;                /* Zahler beim Veraendern mit step != 1 */
  460.  
  461.   werase (akt_winp->winp);  /* Fensterinhalt auf Bildschirm loeschen,     */
  462.   wrefresh(akt_winp->winp); /* damit keine Fehler beim Anpassen auftreten */
  463.   cpwins2stdscr(); /* Alle Fenster ausser akt. nach stdscr kopieren */
  464.   do
  465.   {
  466.     mvprintw(LINES-1,0,PROMPT_WINSIZE,step);
  467.     eckenhw();              /* Fenstereckpunkte merkieren */
  468.     c = newwgetch(stdscr);  /* Zeichen von Tastatur / Macro einlesen */
  469.     eckenhw();              /* Fenstereckpunkte vor Verschieben loeschen */
  470.     if(c == 's')            /* Bei 's' Schrittweite aendern : */
  471.       step = step == SW_STEP ? 1 : SW_STEP; /* war step 1, dann SW_STEP und */
  472.     else                                    /* umgekehrt                    */
  473. #ifdef OS2  /* Bei OS/2 kein zweites Zeichen lesen! */
  474.       d = c;
  475. #else
  476.       if(c==(short int) '\0')              /* "Escape"-Kombination ? */
  477.       {
  478.     d = newwgetch(stdscr); /* Dann nächstes Zeichen lesen */
  479. #endif
  480.     for(i=0;i<step;i++)   /* <step> mal in angegebene Richtung vergroessern */
  481.       switch (d)
  482.       {
  483.         case KEY_RIGHT : size_right(1); break;
  484.         case KEY_LEFT  : size_left(1);  break;
  485.         case KEY_UP    : size_up(1);    break;
  486.         case KEY_DOWN  : size_down(1);  break;
  487.       }
  488. #ifndef OS2
  489.       }
  490. #endif
  491.   } while (c != END_KEY);   /* Solange wiederholen, bis beendende Taste */
  492.   erase();                  /* gedrueckt wurde (RETURN) */
  493.   refresh();                /* Fensterinhalt loeschen */
  494.   delwin(akt_winp->winp);   /* Fenster mit Curses loeschen und neu anlegen */
  495.   akt_winp->winp=newwin(akt_winp->dy+2,akt_winp->dx+2,akt_winp->y,akt_winp->x);
  496.   init_win();               /* Fensterattribute setzen (raw etc.) */
  497.  
  498.   /* Falls Cursor jetzt ausserhalb des Fensters steht, Cursorposition anpassen */
  499.   if (akt_winp->ws_line+akt_winp->dy <= akt_winp->textline)
  500.     gotox(akt_winp->ws_line+akt_winp->dy-1);
  501.   if (akt_winp->ws_col+akt_winp->dx <= akt_winp->screencol)
  502.     akt_winp->screencol = akt_winp->ws_col+akt_winp->dx-1;
  503.   do_refresh();  /* Alle Fenster neu zeichnen */
  504. }
  505.  
  506. /*****************************************************************************
  507. *
  508. *  Funktion       Zum Nachfolger des aktuellen Fensters (do_swnext)
  509. *  --------
  510. *
  511. *  Beschreibung : Das Fenster, das hinter dem Dummyelement steht, wird
  512. *                 hinter dem aktuellen Fenster eingefuegt. Das Element hinter
  513. *                 dem aktuellen Fenster wird dann zum aktuellen Fenster.
  514. *
  515. *****************************************************************************/
  516.  
  517. void do_swnext()
  518. {
  519.   /* *** interne Daten *** */
  520.   win_typ *hilf,  /* Zeiger fuer erstes Fester in Liste */
  521.       *dummy; /* Zeiger fuer leeres Element in der Fensterliste */
  522.  
  523.   if (akt_winp->next->next == akt_winp) /* Test, ob nur ein Fenster */
  524.   {
  525.     print_err(PROMPT_ONEWINDOW); /* Wenn ja, Meldung und Ende */
  526.     return;
  527.   }
  528.   kopf(W_NOTAKT);   /* Altes Fenster als inaktiv markieren */
  529.   rahmen(W_NOTAKT);
  530.   wrefresh(akt_winp->winp);
  531.  
  532.   check_buff();              /* Sonst evtl. Pufferinhalt in Text eintragen */
  533.   dummy = akt_winp->next;    /* dummy auf leeres Element der Liste setzen  */
  534.   hilf = dummy->next;        /* hilf auf erstes Fenster in Liste setzen    */
  535.   dummy->next = hilf->next;
  536.   dummy->prev = hilf;        /* Dummyfenstereintrag vor hilf einkoppeln,   */
  537.   dummy->next->prev = dummy; /* da aktuelles Fenster immer am Listenende   */
  538.   akt_winp->next = hilf;     /* stehen muss.                               */
  539.   hilf->prev = akt_winp;
  540.   hilf->next = dummy;
  541.   akt_winp = hilf;           /* hilf wird zum aktuellen Fenster            */
  542.   show_win(W_AKT);           /* Aktuellen Fensterinhalt neu zeichnen       */
  543. }
  544.  
  545. /*****************************************************************************
  546. *
  547. *  Funktion       Zum Vorgaenger des aktuellen Fensters (do_swprev)
  548. *  --------
  549. *
  550. *  Beschreibung : Das aktuelle Fenster, das vor dem Dummyelement steht, wird
  551. *                 hinter dem Dummy-Element eingefuegt. Das Element vor dem
  552. *                 aktuellen Fenster wird dann zum aktuellen Fenster. Man
  553. *                 kommt also ueber diese Funktion in das Fenster, das un-
  554. *                 mittelbar vor dem aktuellen Fenster geoeffnet wurde.
  555. *
  556. *****************************************************************************/
  557.  
  558. void do_swprev()
  559. {
  560.   /* *** interne Daten *** */
  561.   win_typ *hilf,    /* zeigt auf Vorgaenger des aktuell werdenden Fensters */
  562.       *old_akt; /* Zeiger fuer Fenster, das beim Aufruf aktuell war */
  563.  
  564.   if (akt_winp->next->next == akt_winp) /* Test, ob nur ein Fenster da    */
  565.   {
  566.     print_err(PROMPT_ONEWINDOW); /* Wenn ja, Meldung und raus */
  567.     return;
  568.   }
  569.   kopf(W_NOTAKT);   /* Altes Fenster als inaktiv markieren */
  570.   rahmen(W_NOTAKT);
  571.   wrefresh(akt_winp->winp);
  572.  
  573.   check_buff();                          /* Pufferinhalt in Text sichern   */
  574.   akt_winp = (old_akt = akt_winp)->prev; /* old_akt und akt_winp setzen    */
  575.   akt_winp->next = old_akt->next;        /* Aktuelles Fenster wird mit dem */
  576.   hilf = akt_winp->prev;                 /* vor ihm stehenden vertauscht   */
  577.   akt_winp->prev = old_akt;
  578.   old_akt->prev = hilf;
  579.   hilf->next = old_akt;
  580.   akt_winp->next->prev = akt_winp;
  581.   old_akt->next = akt_winp;
  582.   show_win(W_AKT);                        /* Fensterinhalt neu zeichnen     */
  583. }
  584.  
  585. /*****************************************************************************
  586. *
  587. *  Funktion       Window absolut anspringen (do_swnum)
  588. *  --------
  589. *
  590. *  Beschreibung : Der Nutzer kann eine Fensternummer eingeben. Falls die
  591. *                 Nummer existiert, wird das Fenster mit dieser Nummer
  592. *                 zum aktuellen Fenster.
  593. *
  594. *****************************************************************************/
  595.  
  596. void do_swnum()
  597. {
  598.   /* *** interne Daten *** */
  599.   char num_str [21];  /* String fuer einzulesende Fensternummer */
  600.   int  num;           /* eingelesene Nummer als Integer         */
  601.  
  602.   print_stat (PROMPT_WINDOWNUM);
  603.   read_stat (num_str,20,GS_NUM);   /* Nummer einlesen, nur 2 Ziffern erlaubt */
  604.   clear_stat();                    /* Statuszeile wieder loeschen            */
  605.   check_buff();                    /* Pufferinhalt in Text uebernehmen       */
  606.   kopf(W_NOTAKT);   /* Altes Fenster als inaktiv markieren */
  607.   rahmen(W_NOTAKT);
  608.   wrefresh(akt_winp->winp);
  609.  
  610.   /* String in Integer umwandeln. Test, ob Nummer == 0 oder aktuelle Fnstnr. */
  611.   if ((num = atoi (num_str)) && num != akt_winp->wini)
  612.     if(make_akt_win(num)) /* Wenn alles in Ordnung, versuchen, gewuenschtes  */
  613.       show_win(W_AKT);         /* Fenster zum aktuellen zu machen. Klappte das,   */
  614.     else                  /* Fensterinhalt neu zeichnen, sonst Meldung       */
  615.     {
  616.       pe_or (PROMPT_WINNMNFND);
  617.       rahmen(W_AKT); /* Doch wieder aktiv, kopf kommt von setz_cursor */
  618.       setz_cursor(W_AKT);
  619.     }
  620.   else                    /* Fehler bei Nummer, dann nur Cursor plazieren    */
  621.     setz_cursor(W_AKT);
  622. }
  623.  
  624. /*****************************************************************************
  625. *
  626. *  Funktion       Funktion mehrmals ausfuehren (do_repeat)
  627. *  --------
  628. *
  629. *  Beschreibung : Der User muss die Anzahl der Wiederholungen eingeben.
  630. *                 Anschliessend,falls die eingegebene Anzahl groesser 0 war,
  631. *                 wird ein Kommando eingelesen, welches dann von der Funktion
  632. *                 taste so oft zurueckgegeben wird, wie der User spezifizierte.
  633. *
  634. *****************************************************************************/
  635.  
  636. void do_repeat()
  637. {
  638.   /* *** interne Daten *** */
  639.   char zahl_str[6];  /* String fuer Anzahl der Wiederholungen */
  640.   int  i;            /* Stringinhalt als Integer */
  641.  
  642.   if(ks_index < MACRO_NEST_DEPTH - 1) /* Testen, ob noch ein Puffer frei */
  643.   {                                   /* Wenn ja, Wiederholungsanzahl einlesen */
  644.     print_stat(PROMPT_REPEAT);
  645.     read_stat(zahl_str,5,GS_NUM);
  646.     clear_stat();                     /* Statuszeile wieder loeschen */
  647.     if ((i=atoi(zahl_str)) > 0)       /* String nach Integer, muss > 0 sein */
  648.     {
  649.       /* Mit get_comstr wird eine Befehlsfolge von der Tastatur eingelesen */
  650.       /* und im ersten freien Puffer (ks_index+1) abgelegt.                */
  651.       get_comstr(&puff_feld[ks_index+1].begin,&puff_feld[ks_index+1].end);
  652.       if(puff_feld[ks_index+1].begin)    /* keine Leereingabe? */
  653.       {
  654.     if(ks_index >=0)              /* Wenn schon ein Puffer aktiv, dann  */
  655.       puff_feld[ks_index].current = keystack; /* Position darin merken  */
  656.     keystack = puff_feld[++ks_index].begin; /* Position im neuen setzen */
  657.             /* Puffer soll nach Ausfuehrung der Wiederholung wieder */
  658.     puff_feld[ks_index].free_flag = TRUE;         /* freigegeben werden */
  659.     e_keystack = puff_feld[ks_index].end; /* Pufferende merken          */
  660.     puff_feld[ks_index].anz_rep = i - 1;  /* Anzahl der Wdh. eintragen  */
  661.       }
  662.     }
  663.     setz_cursor(W_AKT);  /* Cursor an seine richtige Position setzen */
  664.   }
  665.   else      /* falls kein Puffer mehr frei, Fehlermeldung ausgeben */
  666.   {
  667.     clear_buff = TRUE;  /* beim naechsten Aufruf von newwgetch() Puffer loeschen */
  668.     print_err(PROMPT_RECURSION);
  669.   }
  670. }
  671.  
  672. /*****************************************************************************
  673. *
  674. *  Funktion       Blockanfang an aktueller Position setzen (do_blstart)
  675. *  --------
  676. *
  677. *  Beschreibung : An der aktuellen Cursorposition wird - falls zulaessig, d.h.
  678. *                 falls der Blockanfang vor dem Blockende liegt oder noch
  679. *                 kein Blockende definiert wurde - der Blockstart festgelegt.
  680. *                 War schon ein Blockende vorhanden, so wird show_win(W_AKT)
  681. *                 aufgerufen.
  682. *
  683. *****************************************************************************/
  684.  
  685. void do_blstart()
  686. {
  687.   akt_winp->block.s_line = akt_winp->textline;  /* Zeile und Spalte als Block- */
  688.   akt_winp->block.s_col = akt_winp->screencol;  /* eintragen */
  689.   if(highblockflag)                    /* Falls Block gehighlighted sein soll, */
  690.     show_win(W_AKT);                        /* markierten Block anzeigen */
  691. }
  692.  
  693. /*****************************************************************************
  694. *
  695. *  Funktion       Blockende (normal) an aktueller Position setzen (do_blnormend)
  696. *  --------
  697. *
  698. *  Beschreibung : An der aktuellen Cursorposition wird - falls zulaessig, d.h.
  699. *                 falls der Blockanfang vor dem Blockende liegt oder noch
  700. *                 kein Blockanfang definiert wurde - das Blockende festgelegt.
  701. *                 War schon ein Blockanfang vorhanden, so wird show_win(W_AKT)
  702. *                 aufgerufen.
  703. *
  704. *****************************************************************************/
  705.  
  706. void do_blnormend()
  707. {
  708.   akt_winp->block.e_line = akt_winp->textline; /* Zeile und Spalte als Block- */
  709.   akt_winp->block.e_col = akt_winp->screencol; /* ende eintragen              */
  710.   akt_winp->block.typ = BT_NORMAL;             /* Blocktyp eintragen          */
  711.   if(highblockflag)  /* Falls Block gehighlighted dargestellt werden soll,    */
  712.     show_win(W_AKT);      /* Fenstrinhalt neu darstellen */
  713. }
  714.  
  715. /*****************************************************************************
  716. *
  717. *  Funktion       Blockende (Rechteck) an aktueller Position setzen (do_blrechtend)
  718. *  --------
  719. *
  720. *  Beschreibung : An der aktuellen Cursorposition wird - falls zulaessig, d.h.
  721. *                 falls der Blockanfang vor dem Blockende liegt oder noch
  722. *                 kein Blockanfang definiert wurde - das Blockende festgelegt.
  723. *                 War schon ein Blockanfang vorhanden, so wird show_win(W_AKT)
  724. *                 aufgerufen.
  725. *
  726. *****************************************************************************/
  727.  
  728. void do_blrechtend()
  729. {
  730.   akt_winp->block.e_line = akt_winp->textline;  /* Aktuelle Zeile und Spalte */
  731.   akt_winp->block.e_col = akt_winp->screencol;  /* als Blockende eintragen   */
  732.   akt_winp->block.typ = BT_RECHTECK;            /* Blocktyp eintragen        */
  733.   if(highblockflag) /* Falls Block gehighlighted dargestellt werden soll,    */
  734.     show_win(W_AKT);     /* Fenstrinhalt neu darstellen */
  735. }
  736.  
  737. /*****************************************************************************
  738. *
  739. *  Funktion       Blockmarkierung loeschen (do_blunmark)
  740. *  --------
  741. *
  742. *  Beschreibung : Die Blockmarkierungen werden geloescht und ein show_win(W_AKT)
  743. *                 durchgefuehrt, um eventuelle Blockmarkierungen auf dem
  744. *                 Schirm zu loeschen.
  745. *
  746. *****************************************************************************/
  747.  
  748. void do_blunmark()
  749. {
  750.   if(block_defined())   /* Wenn ein Block markiert ist         */
  751.     if(tst_overlap())   /* und dieser im Fenster sichtbar ist, */
  752.     {                   /* Blockgrenzen loeschen und           */
  753.       akt_winp->block.e_line = akt_winp->block.s_line = -1;
  754.       show_win(W_AKT);       /* Fensterinhalt neu zeichnen          */
  755.     }
  756.     else    /* Ist der Block nicht im Fenster, dann nur die Grenzen loeschen */
  757.       akt_winp->block.e_line = akt_winp->block.s_line = -1;
  758. }
  759.  
  760. /*****************************************************************************
  761. *
  762. *  Funktion       Block loeschen (do_blweg)
  763. *  --------
  764. *
  765. *  Beschreibung : Falls ein Block markiert ist, wird in Abhaengigkeit vom Typ
  766. *                 der Block geloescht, die Cursor- und Bildschirmposition an-
  767. *                 gepasst und evtl. der Bildschirm neu gezeichnet.
  768. *
  769. *****************************************************************************/
  770.  
  771. void do_blweg()
  772. {
  773.   if (block_defined())  /* Nur ausfuehren, wenn ein Block definiert ist */
  774.   {
  775.     /* In laenge wird die Differenz der letzten und der ersten Zeile */
  776.     /* eingetragen */
  777.     akt_winp->block.laenge = akt_winp->block.e_line-akt_winp->block.s_line;
  778.     if (akt_winp->block.typ == BT_RECHTECK)   /* Abhaengig vom Blocktyp wird */
  779.       del_rechteck();                         /* entweder del_rechteck oder  */
  780.     else                                      /* del_normal aufgerufen       */
  781.     {
  782.       del_normal();
  783.       if (akt_winp->textline < akt_winp->ws_line)  /* Falls Cursor durch das  */
  784.     akt_winp->ws_line = akt_winp->textline;    /* Loeschen des Blocks     */
  785.       if (akt_winp->screencol < akt_winp->ws_col)  /* ausserhalb des Fensters */
  786.     akt_winp->ws_col = akt_winp->screencol;    /* steht, Fenster anpassen */
  787.     }   /* Anschliessend die Blockgrenzen loeschen */
  788.     akt_winp->block.e_line = akt_winp->block.s_line = -1;
  789.     show_win(W_AKT); /* Fensterinhalt neu zeichnen */
  790.   }
  791. }
  792.  
  793. /*****************************************************************************
  794. *
  795. *  Funktion       Block kopieren (do_blcopy)
  796. *  --------
  797. *
  798. *  Beschreibung : Falls ein Block markiert ist, wird in Abhaengigkeit vom Typ
  799. *                 der Block in einen Puffer kopiert und dieser dann an der
  800. *                 aktuellen Position eingefuegt.  Danach wird der Puffer frei-
  801. *                 gegeben und evtl. der Bildschirm neu gezeichnet.
  802. *
  803. *****************************************************************************/
  804.  
  805. void do_blcopy()
  806. {
  807.   /* *** interne Daten *** */
  808.   int ok;  /* Zwischenspeicher fuer Rueckgabewert der Insert-Funktionen */
  809.  
  810.   if (block_defined())  /* Nur ausfuehren, falls ein Block markiert ist */
  811.   {
  812.     if (akt_winp->block.typ == BT_RECHTECK)     /* Abhaengig vom Blocktyp */
  813.     {                                           /* entweder save_rechteck */
  814.       akt_winp->block.bstart = save_rechteck(); /* und ins_rechteck auf-  */
  815.       ok = ins_rechteck(&akt_winp->block);      /* rufen oder             */
  816.     }
  817.     else
  818.     {
  819.       akt_winp->block.bstart = save_normal();   /* save_normal und ins_normal */
  820.       ok = ins_normal(&akt_winp->block);        /* aufrufen */
  821.     }
  822.     block_free(akt_winp->block.bstart);         /* Blocktext freigeben        */
  823.     show_win(W_AKT);                                 /* Fensterinhalt neu anzeigen */
  824.     if(!ok)                                     /* Falls beim Einfuegen ein   */
  825.       print_err(B_SIZE_ERRTEXT);                /* Fehler auftrat, Meldung    */
  826.   }
  827. }
  828.  
  829. /*****************************************************************************
  830. *
  831. *  Funktion       Block verschieben (do_blmove)
  832. *  --------
  833. *
  834. *  Beschreibung : Falls ein Block markiert ist, wird er kopiert, geloescht
  835. *                 und an der aktuellen Cursorposition wieder eingefuegt.
  836. *
  837. *****************************************************************************/
  838.  
  839. void do_blmove()
  840. {
  841.   /* *** interne Daten *** */
  842.   int old_sc,  /* Zwischenspeicher fuer Spalte falls Einfuegen nicht klappt */
  843.       old_tl;  /* Zwischenspeicher fuer Zeile falls Einfuegen nicht klappt */
  844.  
  845.   if (block_defined()) /* Nur ausfuehren, wenn ein Block maekiert ist */
  846.   {
  847.     if (akt_winp->block.typ == BT_RECHTECK)  /* Blocktyp ermitteln */
  848.     {
  849.       akt_winp->block.bstart = save_rechteck();  /* Blocktext abspeichern    */
  850.       del_rechteck();                            /* Block im Text loeschen   */
  851.       if(!ins_rechteck(&akt_winp->block))        /* Block an aktueller       */
  852.       {                                          /* Position einfuegen       */
  853.     old_sc = akt_winp->screencol;            /* klappt das nicht, dann   */
  854.     old_tl = akt_winp->textline;             /* Position merken,         */
  855.     akt_winp->screencol = akt_winp->block.s_col; /* zum Anfang des alten */
  856.     gotox(akt_winp->block.s_line);  /* Blocks gehen und dort wieder hin. */
  857.     ins_rechteck(&akt_winp->block); /* Einfuegen an alter position muss  */
  858.     akt_winp->screencol = old_sc;   /* funktionieren. Cursorposition     */
  859.     gotox(old_tl);                  /* restaurieren                      */
  860.     print_err(B_SIZE_ERRTEXT);      /* Fehlermeldung ausgeben            */
  861.       }
  862.       else
  863.     show_win(W_AKT); /* Klappte Einfuegen, dann Fensterinhalt neu anzeigen */
  864.     }
  865.     else                                /* Normaler Block: */
  866.       if (akt_winp->maxline + 2 < MAX_ANZ_LINES) /* Test ob genug Zeilen frei */
  867.       {
  868.     akt_winp->block.bstart = save_normal(); /* Wenn ja, Blocktext merken, */
  869.     del_normal();                           /* Block im Text loeschen     */
  870.     ins_normal(&akt_winp->block);           /* An aktueller Pos. einfuegen*/
  871.     if (akt_winp->textline < akt_winp->ws_line)  /* Falls Cursor durch das  */
  872.       akt_winp->ws_line = akt_winp->textline;    /* Verschieben des Blocks  */
  873.     if (akt_winp->screencol < akt_winp->ws_col)  /* ausserhalb des Fensters */
  874.       akt_winp->ws_col = akt_winp->screencol;    /* steht, Fenster anpassen */
  875.     show_win(W_AKT);                             /* Fensterinhalt neu anzeigen */
  876.       }
  877.       else       /* Waren nicht genuegend Zeilen frei, Fehlermeldung ausgeben */
  878.     print_err(B_SIZE_ERRTEXT);
  879.     block_free(akt_winp->block.bstart);   /* Blocktext freigeben */
  880.   }
  881. }
  882.  
  883. /*****************************************************************************
  884. *
  885. *  Funktion       Block cutten (do_blcut)
  886. *  --------
  887. *
  888. *  Beschreibung : Falls ein Block markiert ist, wird in Abhaengigkeit vom Typ
  889. *                 der Block in einen Puffer, den sogenannten PASWTE-Puffer,
  890. *                 kopiert. Dieser kann mit der Paste-Funktion ino einem belie-
  891. *                 bigen Fenster eingefuegt werden.
  892. *
  893. *****************************************************************************/
  894.  
  895. void do_blcut()
  896. {
  897.   if (block_defined())      /* Nur ausfuehren, falls ein Block definiert ist */
  898.   {
  899.     if(global_block.bstart) /* Steht schon ein Block im Paste-Puffer, muss */
  900.       block_free(global_block.bstart);       /* dieser freigegeben werden. */
  901.     if (akt_winp->block.typ == BT_RECHTECK)  /* abhaengig vom Blocktyp die */
  902.       akt_winp->block.bstart = save_rechteck(); /* entsprechende Funktion zum */
  903.     else                                        /* Abspeichern des Blockes    */
  904.       akt_winp->block.bstart = save_normal();   /* verwenden                  */
  905.     show_win(W_AKT);                                 /* Fenster neu anzeigen       */
  906.     memcpy(&global_block,&akt_winp->block,sizeof(block_typ)); /* Daten des akt. */
  907.     print_stat(PROMPT_CUT); /* Blocks kopieren  */
  908.     sleep(1);                           /* Meldung ausgeben und 2 Sek. warten */
  909.     clear_stat();                       /* Meldung wieder loeschen */
  910.     setz_cursor(W_AKT);                      /* Cursor an richtige Position */
  911.   }
  912. }
  913.  
  914. /*****************************************************************************
  915. *
  916. *  Funktion       Block pasten (do_blpaste)
  917. *  --------
  918. *
  919. *  Beschreibung : Falls mit der cut-Funktion ein Block in den PASTE-Puffer ko-
  920. *                 piert wurde, wird dieser im aktuellen Fenster an der Cursor-
  921. *                 position eingefuegt.
  922. *
  923. *****************************************************************************/
  924.  
  925. void do_blpaste()
  926. {
  927.   /* *** interne Daten *** */
  928.   block_typ *hilf;  /* Zeiger fuer duplizierten Paste-Block */
  929.   int       ok;     /* Rueckgabewert der Insert-Funktionen */
  930.  
  931.   if (global_block.bstart)              /* Nur, wenn Paste-Puffer belegt */
  932.   {
  933.     if (akt_winp->maxline == -1)        /* Falls Text leer, Eine Zeile anlegen, */
  934.       koppel_line(IGNORE_COORS);        /* da sonst Dummy ueberschrieben wird.  */
  935.     /* Marker und lastpos sind im leeren Text egal */
  936.     hilf = dup_block(&global_block);    /* Blocktext duplizieren */
  937.     if (global_block.typ == BT_RECHTECK) /* Abhaengig vom Typ ins_rechteck */
  938.       ok = ins_rechteck(hilf);           /* oder ins_normal aufrufen       */
  939.     else
  940.       ok = ins_normal(hilf);
  941.     if(ok) /* Wenn ins_normal bzw. ins_rechteck geklappt haben, */
  942.       show_win(W_AKT);  /* Fensterinhalt neu anzeigen */
  943.     else   /* Klappte des Einfuegen nicht, Fehlermeldung ausgeben. */
  944.       print_err(B_SIZE_ERRTEXT);
  945.     block_free(hilf->bstart);     /* Blocktext des aktuellen Blocks freigeben */
  946.     free (hilf);                  /* Hilfsblockstruktur freigeben */
  947.   }
  948. }
  949.  
  950. /*****************************************************************************
  951. *
  952. *  Funktion       Block einruecken (do_blindent)
  953. *  --------
  954. *
  955. *  Beschreibung : Falls ein Block markiert wurde, werden alle Zeilen ab der
  956. *                 Blockstartzeile bis zur Blockendezeile um einen vom Nutzer
  957. *                 einzugebenden Wert eingerueckt. Dabei entscheidet das Vor-
  958. *                 zeichen ueber die Einrueckungsrichtung.
  959. *
  960. *****************************************************************************/
  961.  
  962. void do_blindent()
  963. {
  964.   /* *** interne Daten *** */
  965.   int  weite;         /* Eingelesene Weite als Integer */
  966.   char weit_str[10];  /* Eingelesene Weite als String  */
  967.  
  968.   if (block_defined())  /* Nur ausfuehren, falls ein Block markiert ist */
  969.   {
  970.     print_stat(PROMPT_ASKINDENT);
  971.     read_stat(weit_str,9,GS_ANY);  /* Weite als String einlesen              */
  972.     clear_stat();                  /* Statuszeile wieder loeschen            */
  973.     setz_cursor(W_AKT);                 /* Cursor wieder an richtige Position     */
  974.     if (weite = atoi(weit_str))    /* String in int wandeln und auf 0 testen */
  975.       if (indent_block(weite))     /* Weite != 0, dann Block einruecken      */
  976.     show_win(W_AKT);                /* und Fensterinhalt neu anzeigen         */
  977.   }
  978.   else                             /* War kein Block markiert, Meldung ausgeben */
  979.     print_err(PROMPT_NOBLOCK);
  980. }
  981.  
  982. /*****************************************************************************
  983. *
  984. *  Funktion       Block einlesen (do_blread)
  985. *  --------
  986. *
  987. *  Beschreibung : Eine vom Nutzer anzugebende Datei wird an der aktuellen
  988. *                 Cursorposition in den Text eingefuegt und als Block mar-
  989. *                 kiert.
  990. *
  991. *****************************************************************************/
  992.  
  993. void do_blread()
  994. {
  995.   /* *** interne Daten *** */
  996.   char name[MAXLENGTH+1];  /* Array fuer einzulesenden Dateinamen */
  997.   FILE *f;                 /* Filepointer fuer zu lesende Datei */
  998.  
  999.   print_stat(PROMPT_FILENAME);
  1000.   read_stat(name,MAXLENGTH,GS_ANY);  /* Dateiname einlesen */
  1001.   clear_stat();                      /* Statuszeile wieder loeschen */
  1002.   setz_cursor(W_AKT);                     /* Cursor an alte Position */
  1003.   if(name[0])                        /* Nur ausfuehren, wenn Name vorhanden */
  1004.     if (f=fopen(name,"r"))           /* Datei zum Lesen oeffnen */
  1005.     {
  1006.       akt_winp->block.typ = BT_NORMAL;     /* Blocktyp eintragen */
  1007.       if(lies_block(&akt_winp->block,f))   /* Block aus Datei lesen */
  1008.       {                                    /* Klappte das, dann Block in */
  1009.     if(!ins_normal(&akt_winp->block))  /* Text einfuegen. Falls Fehler */
  1010.       print_err(B_SIZE_ERRTEXT);       /* beim Einfuegen, dann Meldung */
  1011.     else                               /* Sonst Fensterinhalt neu */
  1012.       show_win(W_AKT);                      /* anzeigen */
  1013.     block_free(akt_winp->block.bstart);/* Blocktext freigeben */
  1014.     fclose (f);
  1015.       }
  1016.       else                                 /* lies_block lieferte FALSE, */
  1017.     print_err(PROMPT_BLOCKEMPT);       /* Meldung, dass Block leer */
  1018.     }
  1019.     else                                   /* Falls Datei nicht geoeffnet */
  1020.       print_err(PROMPT_FILENOTFD);         /* werden konnte, Meldung */
  1021. }
  1022.  
  1023. /*****************************************************************************
  1024. *
  1025. *  Funktion       Block schreiben (do_blwrite)
  1026. *  --------
  1027. *
  1028. *  Beschreibung : Falls ein Block markiert ist, wird dieser in einer vom
  1029. *                 Nutzer anzugebenden Datei abgespeichert. Dabei wird ge-
  1030. *                 testet, ob die Datei bereits existiert. Falls ja, wird der
  1031. *                 Nutzer gefragt, ob er die Datei ueberschreiben moechte.
  1032. *
  1033. *****************************************************************************/
  1034.  
  1035. void do_blwrite()
  1036. {
  1037.   /* *** interne Daten *** */
  1038.   char name[MAXLENGTH+1]; /* Array fuer einzulesenden Filenamen */
  1039.   FILE *f;                /* Pointer fuer Datei, in die Block geschrieben */
  1040.               /* werden soll. */
  1041.   if (block_defined())    /* Nur, wenn Block markiert ist */
  1042.   {
  1043.     print_stat(PROMPT_FILENAME);
  1044.     read_stat(name,MAXLENGTH,GS_ANY); /* Filenamen einlesen */
  1045.     clear_stat();                     /* Statuszeile wieder loeschen */
  1046.     if(name[0])                       /* Name leer ? */
  1047.     {
  1048.       setz_cursor(W_AKT);                  /* Nein, Cursor plazieren */
  1049.  
  1050.       /* Falls Datei schon existiert, Sicherheitsabfrage vornehmen, ob    */
  1051.       /* der User die Datei ueberschreiben moechte. Existiert die Datei   */
  1052.       /* und der User moechte sie nicht ueberschreiben, wird die Funktion */
  1053.       /* beendet.                                                         */
  1054.  
  1055.       if(!access(name,0) && !ja_nein(PROMPT_FILEEXIST))
  1056.       {
  1057.     setz_cursor(W_AKT);
  1058.     return;
  1059.       }
  1060.       if (f = fopen (name,"w"))  /* Datei oeffnen */
  1061.       {                          /* Klappte das, Block mit save_... aus */
  1062.     if (akt_winp->block.typ == BT_RECHTECK) /* Text ausschneiden */
  1063.       akt_winp->block.bstart = save_rechteck();
  1064.     else
  1065.       akt_winp->block.bstart = save_normal();
  1066.     schr_block(akt_winp->block.bstart,f); /* Block in offene Datei */
  1067.     fclose (f);                  /* schreiben und Datei schliessen */
  1068.     block_free (akt_winp->block.bstart);    /* Blocktext freigeben */
  1069.       }
  1070.       else     /* Konnte Datei nicht geoeffnet werden, Fehlermeldung */
  1071.       {
  1072.     print_stat (PROMPT_ERRWRITE);
  1073.     pe_or(name);
  1074.       }
  1075.     }
  1076.     setz_cursor(W_AKT);
  1077.   }
  1078. }
  1079.  
  1080. /*****************************************************************************
  1081. *
  1082. *  Funktion       Zum Blockende gehen (do_goblend)
  1083. *  --------
  1084. *
  1085. *  Beschreibung : Falls der Blockanfang markiert ist, wird der Cursor dorthin
  1086. *                 gesetzt.
  1087. *
  1088. *****************************************************************************/
  1089.  
  1090. void do_goblend()
  1091. {
  1092.   if(akt_winp->block.e_line != -1)           /* Ist Blockende gesetzt ? */
  1093.   {
  1094.     akt_winp->lastline = akt_winp->textline; /* Ja, dann aktuelle Position */
  1095.     akt_winp->lastcol = akt_winp->screencol; /* als letzte Position merken */
  1096.     gotox(akt_winp->block.e_line);           /* Blockende anspringen */
  1097.     akt_winp->screencol = akt_winp->block.e_col;
  1098.     adapt_screen(1);                         /* Fensterinhalt evtl. anpassen */
  1099.   }
  1100. }
  1101.  
  1102. /*****************************************************************************
  1103. *
  1104. *  Funktion       Zum Blockanfang (do_goblanf)
  1105. *  --------
  1106. *
  1107. *  Beschreibung : Falls der Blockanfang markiert ist, wird der Cursor dorthin
  1108. *                 gesetzt.
  1109. *
  1110. *****************************************************************************/
  1111.  
  1112. void do_goblanf()
  1113. {
  1114.   if(akt_winp->block.s_line != -1)           /* Blockanfang definiert ? */
  1115.   {
  1116.     akt_winp->lastline = akt_winp->textline; /* Aktuelle Position als   */
  1117.     akt_winp->lastcol = akt_winp->screencol; /* letzte Position merken  */
  1118.     gotox(akt_winp->block.s_line);           /* Blockanfang anspringen  */
  1119.     akt_winp->screencol = akt_winp->block.s_col;
  1120.     adapt_screen(1);                         /* Evtl. Fensterinhalt anpassen */
  1121.   }
  1122. }
  1123.  
  1124. /*****************************************************************************
  1125. *
  1126. *  Funktion       Blockhervorhebungsmodus togglen (do_toghbl)
  1127. *  --------
  1128. *
  1129. *  Beschreibung : Das highblockflag wird getoggled. Dadurch wird die Darstel-
  1130. *                 lung eines markierten Blocks beeinflusst (gehighlighted oder
  1131. *                 nicht gehighlighted).
  1132. *
  1133. *****************************************************************************/
  1134.  
  1135. void do_toghbl()
  1136. {
  1137.   print_stat(PROMPT_BLKHILGHT); /* Meldung ueber den neuen Zustand */
  1138.   print_stat(on_off[highblockflag ^= TRUE]); /* ausgeben */
  1139.   sleep(1);
  1140.   /* Wenn ein Block markiert ist und dieser im Fenster sichtbar ist, */
  1141.   /* wird der Fensterinhalt neu dargestellt.                         */
  1142.   if(block_defined() && tst_overlap())
  1143.     sw_ohne_refresh(W_AKT);
  1144.   else         /* anderenfalls wird ein sleep ausgefuehrt, damit in bei- */
  1145.     sleep(1);  /* den Faellen die Meldung gleichlange zu lesen ist.      */
  1146.   clear_stat();
  1147.   setz_cursor(W_AKT);
  1148. }
  1149.  
  1150. /*****************************************************************************
  1151. *
  1152. *  Funktion       Block an Filter uebergeben (do_bltofil)
  1153. *  --------
  1154. *
  1155. *  Beschreibung : Falls ein Block markiert ist, wird dieser an ein vom Nutzer
  1156. *                 anzugebendes Filterprogramm uebergeben. Die Ausgabe des Fil-
  1157. *                 ters wird ueber eine Pipe eingelesen und als Block in den
  1158. *                 Text eingefuegt.
  1159. *
  1160. *****************************************************************************/
  1161.  
  1162. void do_bltofil()
  1163. {
  1164.   if (block_defined() && bl_to_fil())
  1165.   {
  1166.     if (akt_winp->textline < akt_winp->ws_line)  /* Falls Cursor durch das  */
  1167.       akt_winp->ws_line = akt_winp->textline;    /* Filtern des Blocks      */
  1168.     if (akt_winp->screencol < akt_winp->ws_col)  /* ausserhalb des Fensters */
  1169.       akt_winp->ws_col = akt_winp->screencol;    /* steht, Fenster anpassen */
  1170.     show_win(W_AKT);
  1171.   }
  1172. }
  1173.  
  1174. /*****************************************************************************
  1175. *
  1176. *  Funktion       Shellflag invertieren (do_shelltog)
  1177. *  --------
  1178. *
  1179. *  Beschreibung : Das shellflag der aktuellen Windowstruktur wird invertiert.
  1180. *
  1181. *****************************************************************************/
  1182.  
  1183. void do_shelltog()
  1184. {
  1185.   akt_winp->shellflag ^= TRUE;
  1186.   setz_cursor(W_AKT);      /* Kopfzeile aktualisieren */
  1187. }
  1188.  
  1189.  
  1190. /*****************************************************************************
  1191. *
  1192. *  Funktion       Marker setzen (do_setmarker)
  1193. *  --------
  1194. *
  1195. *  Beschreibung : Falls der Text nicht leer ist, wird der Nutzer nach der
  1196. *                 Markernummer (0-9) gefragt. Fuer den angegebenen Marker
  1197. *                 werden dann Position und Fensternummer gespeichert.
  1198. *
  1199. *****************************************************************************/
  1200.  
  1201. void do_setmarker()
  1202. {
  1203.   /* *** interne Daten *** */
  1204.   int m;   /* Nummer des gewuenschten Markers */
  1205.  
  1206.   if(akt_winp->maxline >= 0)  /* Text nicht leer ? */
  1207.   {
  1208.     if(helpflag)
  1209.       print_stat(PROMPT_MARKER);
  1210.     m = newwgetch(status) - '0'; /* Markernummer einlesen */
  1211.     if(helpflag)
  1212.       clear_stat();
  1213.     if(m >= 0 && m <= 9)         /* Bereich ueberpruefen */
  1214.     {
  1215.       marker[m].col = akt_winp->screencol; /* aktuelle Position und */
  1216.       marker[m].line = akt_winp->textline; /* Fensternummer eintragen */
  1217.       marker[m].window = akt_winp->wini;
  1218.       setz_cursor(W_AKT);
  1219.     }
  1220.     else                         /* Bereichspruefung schlug fehl */
  1221.       print_err(PROMPT_ERRMARKER);
  1222.   }
  1223. }
  1224.  
  1225. /*****************************************************************************
  1226. *
  1227. *  Funktion       Marker anspringen (do_jumpmarker)
  1228. *  --------
  1229. *
  1230. *  Beschreibung : Der Nutzer wird nach der Nummer des anzuspringenden Markers
  1231. *                 gefragt. Existiert der Marker, oder das zu dem Marker gehoe-
  1232. *                 rende fenster nicht mehr, so wird eine Meldung ausgegeben.
  1233. *                 Sonst wird das zum Marker gehoerige Fenster zum aktuellen
  1234. *                 Fenster, und der Cursor wird richtig positioniert.
  1235. *
  1236. *****************************************************************************/
  1237.  
  1238. void do_jumpmarker()
  1239. {
  1240.   /* *** interne Daten *** */
  1241.   int     m;        /* Nummer des gewuenschten Markers */
  1242.   win_typ *old_win; /* Zwischenspeicher fuer beim Aufruf aktuelles Fenster */
  1243.  
  1244.   if(helpflag)
  1245.     print_stat(PROMPT_MARKER);
  1246.   m = newwgetch(status) - '0';  /* Markernummer einlesen */
  1247.   if(helpflag)
  1248.     clear_stat();
  1249.   if(m >= 0 && m <= 9)          /* Bereichspruefung fuer Markernummer */
  1250.     if(marker[m].window != -1)  /* Ist Marker gesetzt ? */
  1251.     {
  1252.       kopf(W_NOTAKT);   /* Altes Fenster als inaktiv markieren */
  1253.       rahmen(W_NOTAKT);
  1254.       wrefresh(akt_winp->winp);
  1255.  
  1256.       check_buff();             /* Pufferinhalt evtl. in Text eintragen */
  1257.       old_win = akt_winp;
  1258.       if(make_akt_win(marker[m].window)) /* zum Fenster gehen, in dem */
  1259.       {                                  /* der Marker gesetzt wurde  */
  1260.     akt_winp->lastcol  = akt_winp->screencol; /* aktuelle Position */
  1261.     akt_winp->lastline = akt_winp->textline; /*  als letzte merken */
  1262.  
  1263.     /* Steht der Marker hinter dem Textende, dann zur letzten Zeile  */
  1264.     /* gehen. Andernfalls die vom Marker angegebene Zeile anspringen */
  1265.     /* Falls Text leer, geht gotox richtig auf dummyp.               */
  1266.     gotox(akt_winp->maxline <= marker[m].line?akt_winp->maxline:marker[m].line);
  1267.     /* Falls Text leer, dann Spalte 0, sonst richtige Markerspalte */
  1268.     akt_winp->screencol = akt_winp->maxline>=0 ? marker[m].col : 0;
  1269.     if(old_win != akt_winp) /* Falls nicht aktuelles Fenster, dann */
  1270.       show_win(W_AKT);      /* Fensterkomplett neu zeichnen        */
  1271.     else
  1272.       rahmen(W_AKT);        /* Sonst Fenster wieder aktiv */
  1273.     adapt_screen(1);        /* Fensterinhalt anpassen              */
  1274.       }
  1275.       else /* Fenster konnte nicht angesprungen werden, Meldung ausgeben */
  1276.     print_err(PROMPT_STALEMARK);
  1277.     }
  1278.     else
  1279.       print_err(PROMPT_EMPTYMARK);
  1280.   else
  1281.     print_err(PROMPT_ERRINPUT);
  1282. }
  1283.  
  1284. /*****************************************************************************
  1285. *
  1286. *  Funktion       Letzte Position anspringen (do_lastpos)
  1287. *  --------
  1288. *
  1289. *  Beschreibung : Es wird die letzte Position vor einem Find/Replace/Goto/
  1290. *                 lastpos/Marker angesprungen. Diese Position ist Fenster-
  1291. *                 intern.
  1292. *
  1293. *****************************************************************************/
  1294.  
  1295. void do_lastpos()
  1296. {
  1297.   /* *** interne Daten und Initialisierung *** */
  1298.   int hilf = akt_winp->textline; /* Zwischenspeicher fuer Zeilennummer */
  1299.  
  1300.   if(akt_winp->lastline != -1)   /* Letzte Position gesetzt ? */
  1301.   {
  1302.     /* aktuelle Spalte als letzte Spalte merken, letzte Spalte zur */
  1303.     /* aktuellen machen                                            */
  1304.     swap_int(&akt_winp->screencol,&akt_winp->lastcol);
  1305.     gotox(akt_winp->lastline);  /* Letzte Zeile anspringen */
  1306.     akt_winp->lastline = hilf;  /* Vorher aktuelle Zeile wird Letzte Z. */
  1307.     adapt_screen(1);            /* Fensterinhalt anpassen */
  1308.   }
  1309. }
  1310.  
  1311. /*****************************************************************************
  1312. *
  1313. *  Funktion       Window gemaess Name anspringen (do_swname)
  1314. *  --------
  1315. *
  1316. *  Beschreibung : Der Nutzer kann einen Dateinamen eingeben. Falls die
  1317. *                 Nummer existiert, wird das Fenster mit diesem Namen
  1318. *                 zum aktuellen Fenster.
  1319. *
  1320. *****************************************************************************/
  1321.  
  1322. void do_swname()
  1323. {
  1324.   /* *** interne Daten und Initialisierung *** */
  1325.   char filename[MAXLENGTH+1]; /* Array fuer einzulesenden Filenamen    */
  1326.   int  wn = akt_winp->wini;   /* Zwischenspeicher fuer akt. Fensternr. */
  1327.  
  1328.   print_stat (PROMPT_FILENAME);
  1329.   read_stat (filename,MAXLENGTH,GS_ANY);  /* Filenamen einlesen */
  1330.   clear_stat();
  1331.   if(!filename[0])                        /* Filename leer ? */
  1332.   {
  1333.     setz_cursor(W_AKT);                        /* Dann verlassen */
  1334.     return;
  1335.   }
  1336.   kopf(W_NOTAKT);   /* Altes Fenster als inaktiv markieren */
  1337.   rahmen(W_NOTAKT);
  1338.   wrefresh(akt_winp->winp);
  1339.  
  1340.   check_buff();               /* sonst Pufferinhalt evtl. in Text eintragen, */
  1341.   if (sw_name(filename))      /* versuchen, gewuenschtes Fenster zum aktu- */
  1342.   {                           /* ellen zu machen. */
  1343.     if(akt_winp->wini == wn)  /* War es das aktuelle Fenster ? */
  1344.     {
  1345.       rahmen(W_AKT);          /* Fenster wird evtl. wieder aktiv */
  1346.       setz_cursor(W_AKT);          /* Dann nur Cursor setzen */
  1347.     }
  1348.     else                      /* Sonst komplettes Fenster neu zeichnen */
  1349.       show_win(W_AKT);
  1350.   }
  1351.   else                        /* Fenster nicht gefunden */
  1352.     /* Abfragen, ob Datei geladen werden soll */
  1353.     if(ja_nein(PROMPT_NEWWINDOW))
  1354.     {
  1355.       kopf(W_NOTAKT);   /* Altes Fenster als inaktiv markieren */
  1356.       rahmen(W_NOTAKT);
  1357.       wrefresh(akt_winp->winp);
  1358.  
  1359.       if (koppel_win())   /* Soll Datei neu geladen werden, */
  1360.       {                   /* dann neues Fenster erzeugen */
  1361.     akt_winp->filename = save_text(filename); /* Filenamen eintragen */
  1362.     if (!lies_file())  /* Datei in neues Fenster einlesen */
  1363.     {
  1364.       gb_win_frei();   /* Klappte das nicht, Fenster wieder loeschen, */
  1365.       rahmen(W_AKT);   /* Fenster highlighten */
  1366.       setz_cursor(W_AKT);   /* und Cursor an richtige Position */
  1367.     }
  1368.     else               /* Sonst Fensterwerte initialisieren */
  1369.       open_window();
  1370.       }
  1371.       else                 /* koppel_win klappte nicht */
  1372.       {
  1373.     pe_or("Zu viele Fenster! ");
  1374.     rahmen(W_AKT); /* Altes Fenster wieder aktiv */
  1375.     setz_cursor(); /* Cursor an richtige Position */
  1376.       }
  1377.     }
  1378.     else                   /* Fenster nicht gefunden, Datei soll aber */
  1379.     {
  1380.       rahmen(W_AKT);       /* Fenster highlighten */
  1381.       setz_cursor(W_AKT);       /* auch nicht neu geladen werden */
  1382.     }
  1383. }
  1384.  
  1385. /*****************************************************************************
  1386. *
  1387. *  Funktion       Datei unter neuem Namen abspeichern (do_newname)
  1388. *  --------
  1389. *
  1390. *  Beschreibung : Der Dateiname der Datei im aktuellen Fenster wird intern
  1391. *                 geaendert und der Text unter dem neuen Namen abgespeichert.
  1392. *
  1393. *****************************************************************************/
  1394.  
  1395. void do_newname()
  1396. {
  1397.   /* *** interne Daten *** */
  1398.   char name[MAXLENGTH+1];  /* Array fuer einzulesenden neuen Namen */
  1399.  
  1400.   print_stat(PROMPT_FILENAME);
  1401.   read_stat(name,MAXLENGTH,GS_ANY); /* Dateinamen einlesen */
  1402.   clear_stat();
  1403.   if(!name[0])                      /* Leerer Name, dann raus */
  1404.   {
  1405.     pos_cursor();
  1406.     return;
  1407.   }
  1408.   free(akt_winp->filename);         /* Sonst alten Namen freigeben       */
  1409.   akt_winp->attribs = STD_FATTR;    /* Attribute und read_only-Status    */
  1410.   akt_winp->read_only = FALSE;      /* initialisieren                    */
  1411.   akt_winp->filename = save_text(name); /* Neuen Namen abspeichern       */
  1412.   schreib_file();                   /* Datei unter neuem Namen speichern */
  1413.   setz_cursor(W_AKT);
  1414. }
  1415.  
  1416. /*****************************************************************************
  1417. *
  1418. *  Funktion       Macro definieren/ausfuehren (do_macro)
  1419. *  --------
  1420. *
  1421. *  Beschreibung : Nach Eingabe eines Grossbuchstabens kann der Benutzer
  1422. *                 einen Macro definieren, indem er die dem Macro zuzu-
  1423. *                 ordnenden Tasten drueckt. Beendet wird die Macrodefinition
  1424. *                 durch Druck der ESCAPE-Taste (get_comstr()).
  1425. *                 Nach Eingabe eines Kleinbuchstabens wird der entsprechende
  1426. *                 Macro - falls definiert - aufgerufen.
  1427. *
  1428. *****************************************************************************/
  1429.  
  1430. void do_macro()
  1431. {
  1432.   /* *** interne Daten *** */
  1433.   short int mnum;  /* Zum einlesen des Macrobuchstabens */
  1434.  
  1435.   if(helpflag)
  1436.     print_stat(PROMPT_MACRO);
  1437.   mnum = newwgetch(status);  /* Macrobuchstaben einlesen */
  1438.   if(helpflag)
  1439.     clear_stat();
  1440.   if(mnum>='A' && mnum<='Z') /* Macro definieren ? */
  1441.   {
  1442.     mnum -= 'A';
  1443.     line_free(macro[mnum].begin); /* vorherigen Macrotext freigeben */
  1444.     get_comstr(¯o[mnum].begin,¯o[mnum].end); /* und neuen einlesen */
  1445.   }
  1446.   else                       /* Macro ausfuehren */
  1447.     exec_macro(mnum);
  1448.   setz_cursor(W_AKT);
  1449. }
  1450.  
  1451. /*****************************************************************************
  1452. *
  1453. *  Funktion       Geloeschte Zeile wiederherstellen (do_restline)
  1454. *  --------
  1455. *
  1456. *  Beschreibung : Mittels rest_delline() wird die zuletzt geloeschte Zeile
  1457. *                 bzw. eine Leerzeile vor der aktuellen Zeile eingefuegt.
  1458. *
  1459. *****************************************************************************/
  1460.  
  1461. void do_restline()
  1462. {
  1463.   if(akt_winp->maxline < MAX_ANZ_LINES-1) /* noch Platz da? */
  1464.   {
  1465.     rest_delline();
  1466.     show_win(W_AKT);
  1467.   }
  1468.   else                /* Kein Platz mehr, Fehlermeldung ausgeben */
  1469.     print_err(T_SIZE_ERRTEXT);
  1470. }
  1471.  
  1472. /*****************************************************************************
  1473. *
  1474. *  Funktion       Alle modifizierten Files loeschen (do_saveall)
  1475. *  --------
  1476. *
  1477. *  Beschreibung : Ruft save_all auf, um alle geaenderten Dateien zu sichern.
  1478. *                 Anschliessend wird ein Refresh ausgefuehrt.
  1479. *
  1480. *****************************************************************************/
  1481.  
  1482. void do_saveall()
  1483. {
  1484.   save_all();
  1485.   show_win(W_AKT);
  1486. }
  1487.  
  1488. void (*funktion [])() = {do_refresh, do_bol,do_eol,do_halfup,do_halfdn,do_delete,
  1489.              do_backspace,do_home,do_nothome,do_insovr,do_textbeginn,
  1490.              do_eot,do_del_word,do_wleft,do_wright,do_right,do_left,
  1491.              do_up,do_down,do_pgup,do_pgdn,do_newline,do_delline,
  1492.              ueberschreiben,do_schreib_file,quit,do_control,do_help,
  1493.              do_movewin,do_sizewin,do_swnext,do_swprev,do_swnum,
  1494.              laden,do_win_zu,do_goto,do_ende,do_find,do_replace,
  1495.              do_underline,do_z_hoch,do_z_runter,do_z_oben,
  1496.              do_z_mitte,do_z_unten,do_deleol,do_toggle_size,
  1497.              do_repfr,do_repeat,do_repfr,do_join,do_open,do_tog_ai,
  1498.              do_tab,do_settab,do_tog_tkm,do_blstart,do_blnormend,
  1499.              do_blrechtend,do_blunmark,do_blweg,do_blcopy,
  1500.              do_blmove,do_blcut,do_blpaste,do_blindent,do_blread,
  1501.              do_blwrite,do_goblend,do_goblanf,do_toghbl,do_bltofil,
  1502.              do_setmarker,do_jumpmarker,do_lastpos,do_hopen,
  1503.              do_swname,do_newname,do_backtab,do_tog_bak,do_macro,
  1504.              do_restline,do_shelltog,do_endemit,quitmit,do_delete,
  1505.              do_togregex, do_matchpar, do_middle, do_saveall,
  1506.              do_inschar };
  1507.  
  1508. /*****************************************************************************
  1509. *
  1510. *  Funktion       Tastendruck auswerten (auswertung)
  1511. *  --------
  1512. *
  1513. *  Parameter    : t         :
  1514. *                   Typ          : int
  1515. *                   Wertebereich : 0-MAX_COMM_INDEX
  1516. *                   Bedeutung    : Nummer des Befehls. Ist t == BUCHSTABE,
  1517. *                                  dann steht der Buchstabe in letter.
  1518. *
  1519. *  Beschreibung : Anhand des Kommandos wird eine Funktion aufgerufen, die
  1520. *                 den Befehl ausfuehrt.
  1521. *
  1522. *****************************************************************************/
  1523.  
  1524. void auswertung (t)
  1525. int t;
  1526. {
  1527.   hide_show(MOUSE_HIDE);  /* Maus vor Ausführung der Operation verstecken */
  1528.   (*funktion[t])();
  1529.   hide_show(MOUSE_SHOW);  /* Maus nach der Operation wieder anzeigen */
  1530. }
  1531.