home *** CD-ROM | disk | FTP | other *** search
/ Mega Top 1 / os2_top1.zip / os2_top1 / APPS / EDITORS / EHP12 / AUS_2.C < prev    next >
C/C++ Source or Header  |  1993-11-22  |  43KB  |  982 lines
  1. /****************************************************************/ 
  2. /*                                                              */
  3. /*      MODUL:  aus_2.c                                         */
  4. /*                                                              */
  5. /*      FUNKTIONEN:                                             */
  6. /*              - do_textbeginn (gehe zum Textbeginn)           */
  7. /*              - do_eot (gehe zum Textende)                    */
  8. /*              - do_deleol (loesche bis Zeilenende)            */
  9. /*              - do_del_word (loesche Wort, auf dem Cursor st.)*/
  10. /*              - do_wleft (gehe Wort nach links)               */
  11. /*              - do_wright (gehe Wort nach rechts)             */
  12. /*              - do_right (gehe ein Zeichen nach rechts)       */
  13. /*              - do_left (gehe ein Zeichen nach links)         */
  14. /*              - do_up (gehe eine Zeile nach oben)             */
  15. /*              - do_down (gehe eine Zeile nach unten)          */
  16. /*              - do_settab (Tablaenge setzen)                  */
  17. /*              - do_backtab (an vorherige Tabposition springen)*/
  18. /*              - do_tab (Tab einfuegen)                        */
  19. /*              - do_pgup (Page Up ausfuehren)                  */
  20. /*              - do_pgdn (Page Down ausfuehren)                */
  21. /*              - do_open (leere Zeile vor aktueller einfuegen) */
  22. /*              - do_hopen (leere Zeile hinter aktueller efg.)  */
  23. /*              - do_newline (newline ausfuehren)               */
  24. /*              - do_delline (loesche eine Zeile)               */
  25. /*              - do_join (Zeilenverknuepfung ausfuehren)       */
  26. /*              - do_goto (Springe bestimmte Zeile an)          */
  27. /*              - do_ende (beende Editor)                       */
  28. /*              - ex_load (Loadfile ausführen)                  */
  29. /*              - do_endemit (beende Editor mit Load-File)      */
  30. /*              - quit (verlasse Editor)                        */
  31. /*              - quitmit (verlasse Editor mit Load-File)       */
  32. /****************************************************************/
  33.  
  34. #ifdef OS2
  35. #define INCL_DOSPROCESS
  36. #include <os2.h>
  37. #else
  38. extern long old_int;
  39. #endif
  40.  
  41. #include "defs.h"
  42. #include <process.h>
  43.  
  44. extern char backupflag,highblockflag,clear_buff,bufflag;
  45. extern int schreib_file(),to_shell();
  46. extern short int letter,lastcode,aktcode,taste();
  47. extern int save_delline(),rest_delline();
  48. extern int tst_overlap();
  49. extern void do_find(),do_replace(),do_repfr();
  50. extern char bufflag,*loadfile,*mktemp();
  51. extern bzeil_typ *save_normal(),*save_rechteck();
  52. extern block_typ global_block,*dup_block();
  53. extern puff_typ macro[],puff_feld[];
  54. extern int ks_index;
  55. extern short int *keystack,*e_keystack,newwgetch();
  56. extern WINDOW *status;
  57. extern marker_typ marker[];
  58. #ifdef MOUSE
  59. #ifdef OS2
  60. extern int mouse_handle;
  61. extern char mouse_active;
  62. extern TID mouse_ThreadID, mouse_jn_ThreadID;
  63. #endif
  64. #endif
  65.  
  66. /* *** interne Daten und Initialisierung *** */
  67. void do_join();
  68. extern char *on_off[], /* Hilfstexte */
  69.                /* fuer Togglen der globalen Flags */
  70.         helpflag;  /* Flag: Hilfstexte anzeigen       */
  71.  
  72. /*****************************************************************************
  73. *
  74. *  Funktion       Gehe zum Textbeginn (do_textbeginn)
  75. *  --------
  76. *
  77. *  Beschreibung : Der Cursor wird in die erste Textzeile bewegt.
  78. *
  79. *****************************************************************************/
  80.  
  81. void do_textbeginn()
  82. {
  83.   akt_winp->lastline = akt_winp->textline;  /* Cursorposition als letzte */
  84.   akt_winp->lastcol  = akt_winp->screencol; /* Position merken */
  85.   textbeginn();          /* Cursor intern an Textanfang positionieren */
  86.   akt_winp->ws_line = 0; /* Erste Zeile wird erste sichtbare Zeile */
  87.   show_win(W_AKT);           /* Text im Fenster neu anzeigen     */
  88. }
  89.  
  90. /*****************************************************************************
  91. *
  92. *  Funktion       Cursor an Textende (do_eot)
  93. *  --------
  94. *
  95. *  Beschreibung : Der Cursor wird an das Textende bewegt.
  96. *
  97. *****************************************************************************/
  98.  
  99. void do_eot()
  100. {
  101.   akt_winp->lastline = akt_winp->textline;  /* Cursorposition als letzte */
  102.   akt_winp->lastcol  = akt_winp->screencol; /* Position merken */
  103.   textende();  /* Cursor intern ans Textende setzen */
  104.   /* Erste Zeile wird die Zeile, die eine halbe Bildschirmlaenge ueber */
  105.   /* dem Textende liegt. Ist das Ergebnis kleiner 0 (zu wenig Zeilen), */
  106.   /* wird die erste Textzeile erste sichtbare Zeile. */
  107.   if((akt_winp->ws_line = akt_winp->maxline - akt_winp->dy/2) < 0)
  108.     akt_winp->ws_line = 0;
  109.   show_win(W_AKT); /* Fensterinhalt neu darstellen */
  110. }
  111.  
  112. /*****************************************************************************
  113. *
  114. *  Funktion       loesche bis Zeilenende (do_deleol)
  115. *  --------
  116. *
  117. *  Beschreibung : Mit der aktuellen Cursorposition beginnend, wird der Rest
  118. *                 der Zeile geloescht.
  119. *
  120. *****************************************************************************/
  121.  
  122. void do_deleol()
  123. {
  124.   if (delete_eol())  /* Zeileninhalt bis zum Zeilenende loeschen */
  125.   { /* hat das geklappt, wird die Zeile neu angezeigt */
  126.     lineout(akt_winp->textline-akt_winp->ws_line);
  127.     setz_cursor(W_AKT);  /* und der Cursor auf seine richtige Position gesetzt */
  128.   }
  129. }
  130.  
  131. /*****************************************************************************
  132. *
  133. *  Funktion       loesche Wort, auf dem der Cursor steht (do_del_word)
  134. *  --------
  135. *
  136. *  Beschreibung : Das Wort, auf dem der Cursor steht, wird geloescht.
  137. *
  138. *****************************************************************************/
  139.  
  140. void do_del_word()
  141. {
  142.   if (is_last()) /* an oder hinter Zeilenende ? */
  143.     do_join();   /* Dann nächste Zeile ranziehen */
  144.   else
  145.     if (delete_word())  /* Wort in Textstruktur loeschen */ 
  146.     { /* hat das geklappt, Zeile neu anzeigen */
  147.       lineout(akt_winp->textline-akt_winp->ws_line);
  148.       setz_cursor(W_AKT); /* und Cursor auf seine richtige Position setzen */
  149.     }
  150. }
  151.  
  152. /*****************************************************************************
  153. *
  154. *  Funktion       Wort links (do_wleft)
  155. *  --------
  156. *
  157. *  Beschreibung : Der Cursor wird um ein Wort nach links bewegt..
  158. *
  159. *****************************************************************************/
  160.  
  161. void do_wleft()
  162. {
  163.   if (word_left()    /* Cursor ein Wort nach links */
  164.   && akt_winp->screencol < akt_winp->ws_col) /* klappte das, und steht der */
  165.   /* Cursor nun links vom Bildschirm, muss das Fenster angepasst werden. */
  166.   {
  167.     akt_winp->ws_col = akt_winp->screencol; /* Aktuelle Spalte wird erste */
  168.     sw_ohne_refresh(W_AKT); /* Fensterinhalt wird neu angezeigt */
  169.   }
  170.   setz_cursor(W_AKT);  /* Cursor auf seine richtige Position setzen */
  171. }
  172.  
  173. /*****************************************************************************
  174. *
  175. *  Funktion       Wort rechts (do_wright)
  176. *  --------
  177. *
  178. *  Beschreibung : Der Cursor wird um ein Wort nach rechts bewegt.
  179. *
  180. *****************************************************************************/
  181.  
  182. void do_wright()
  183. {
  184.   if (word_right() /* Cursor intern um ein Wort nach rechts bewegen */
  185.   && akt_winp->screencol >= akt_winp->ws_col + akt_winp->dx)
  186.   /* klappte das, und steht der Cursor dadurch rechts vom Bildschirm, */
  187.   /* so muss der Fensterinhalt angepasst werden */
  188.   {
  189.     /* Aktuelle Spalte wird zur letzten sichtbaren */
  190.     akt_winp->ws_col = akt_winp->screencol - akt_winp->dx + 1;
  191.     sw_ohne_refresh(W_AKT);  /* Fensterinhalt neu darstellen */
  192.   }
  193.   setz_cursor(W_AKT);  /* Cursor an seine richtige Position setzen */
  194. }
  195.  
  196. /*****************************************************************************
  197. *
  198. *  Funktion       fuehre Move nach rechts aus (do_right)
  199. *  --------
  200. *
  201. *  Beschreibung : Der Cursor wird intern um ein Zeichen nach rechts bewegt.
  202. *                 Bewegt sich dabei der Cursor aus dem Fenster, so wird
  203. *                 das Fenster gescrollt.
  204. *
  205. *****************************************************************************/
  206.  
  207. void do_right()
  208. {
  209.   /* *** interne Daten *** */
  210.   register int hilf,  /* Zum Einlesen einer Tastenkombination */
  211.            i=0;   /* Zaehler, um wieviele Spalten gescrollt werden muss */
  212.  
  213.   nodelay (akt_winp->winp,TRUE); /* taste soll -1 bei nichtgedrueckter */
  214.   do                             /* Taste liefern */
  215.     if (right()  /* Wenn Cursor nach rechts bewegt werden konnte und */
  216.     && akt_winp->screencol >= akt_winp->ws_col+akt_winp->dx)
  217.       i++; /* Rand ueberschritten wurde, dann Scrollzaehler erhoehen */
  218.   while ((hilf=taste(akt_winp->winp)) == aktcode); /* Naechste Tastenkom- */
  219.   /* bination lesen. Falls gleich der letzten, Aktion wiederholen */
  220.   lastcode = hilf; /* letzte Tastenkombination merken */
  221.   nodelay (akt_winp->winp,FALSE); /* taste soll wieder auf Tastendruck warten */
  222.   if(i>1)   /* Wenn um mehr als eine Spalte gescrollt werden soll, ist es */
  223.   { /* guenstiger, den gesamten Fensterinhalt neu zu zeigen. */
  224.     akt_winp->ws_col+=i; /* Fensterinhalt um i Spalten nach links */
  225.     sw_ohne_refresh(W_AKT);   /* Fensterinhalt neu anzeigen */
  226.   }
  227.   else if (i==1)
  228.     text_left(); /* Sonst Inhalt mit text_left um 1 nach links bewegen */
  229.   setz_cursor(W_AKT); /* Cursor an seine richtige Position setzen */
  230. }
  231.  
  232. /*****************************************************************************
  233. *
  234. *  Funktion       fuehre Move nach links aus (do_left)
  235. *  --------
  236. *
  237. *  Beschreibung : Der Cursor wird intern um ein Zeichen nach links bewegt.
  238. *                 Bewegt sich dabei der Cursor aus dem Fenster, so wird
  239. *                 das Fenster gescrollt.
  240. *
  241. *****************************************************************************/
  242.  
  243. void do_left()
  244. {
  245.   /* *** interne Daten *** */
  246.   register int hilf,  /* Zum Einlesen einer Tastenkombination */
  247.            i=0;   /* Zaehler, um wieviele Spalten gescrollt werden muss */
  248.  
  249.   nodelay (akt_winp->winp,TRUE); /* Funktion taste soll /1 liefern, */
  250.   do                             /* Falls keine Taste gedrueckt ist */
  251.     if (left() /* konnte der Cursor nach links bewegt werden und geriet er */
  252.     && akt_winp->screencol < akt_winp->ws_col) /* dadurch ausserhalb des */
  253.       i++;       /* Bildschirms, wird der Scrollzaehler erhoeht. */
  254.   while ((hilf=taste(akt_winp->winp)) == aktcode); /* Naechste Tasten- */
  255.   /* kombination einlesen. Ist die gleich der letzten, Aktion wiederholen */
  256.   lastcode = hilf; /* Letzte Tastenkombination merken */
  257.   nodelay (akt_winp->winp,FALSE); /* Funktion Taste soll wieder auf Tasten- */
  258.                   /* druck warten */
  259.   if(i>1) /* Muss um mehr als eine Spalte gescrollt werden, ist es */
  260.   {       /* guenstiger, den Fensterinhalt neu anzuzeigen */
  261.     akt_winp->ws_col-=i; /* Fensterinhalt um i Spalten nach rechts */
  262.     sw_ohne_refresh(W_AKT);   /* Fensterinhalt neu anzeigen */
  263.   }
  264.   else if (i==1) /* Muss nur um eine Spalte gescrollt werden, so kann das */
  265.     text_right(); /* mit der Funktion text_right geschehen. */
  266.   setz_cursor(W_AKT);  /* Cursor an seine richtige Position setzen */
  267. }
  268.  
  269. /*****************************************************************************
  270. *
  271. *  Funktion       fuehre Move nach oben aus (do_up)
  272. *  --------
  273. *
  274. *  Beschreibung : Der Cursor wird intern um ein Zeichen nach oben bewegt.
  275. *                 Bewegt sich dabei der Cursor aus dem Fenster, so wird
  276. *                 das Fenster gescrollt.
  277. *
  278. *****************************************************************************/
  279.  
  280. void do_up()
  281. {
  282.   /* *** interne Daten und Initialisierung *** */
  283.   register int hilf,  /* Zum Einlesen einer Tastenkombination */
  284.            i=0;   /* Zaehler, wie oft gescrollt werden muss */
  285.  
  286.   nodelay (akt_winp->winp,TRUE); /* Funktion taste soll -1 liefern, wenn */
  287.   do                             /* keine Taste gedrueckt ist. */
  288.   {
  289.     if(up()  /* Wenn Cursor 1 Zeile nach oben bewegt werden konnte und */
  290.     && akt_winp->textline < akt_winp->ws_line) /* dadurch Cursor ausserhalb */
  291.       i++; /* des Fensters steht, Scrollzaehler erhoehen. */
  292.   }while ((hilf=taste(akt_winp->winp)) == aktcode); /* Naechste Tasten- */
  293.   /* kombination einlesen. Falls diese gleich der letzten, Aktion wiederholen */
  294.   lastcode = hilf; /* letzte Tastenkombination merken */
  295.   nodelay (akt_winp->winp,FALSE); /* Funktion taste soll wieder auf */
  296.                   /* Tastendruck warten */
  297.   akt_winp->ws_line -= i; /* Fensterstart anpassen */
  298.   if(i>1) /* Falls um mehr als eine Zeile gescrollt werden muss, */
  299.     sw_ohne_refresh(W_AKT); /* komplettes Fenster neu anzeigen */
  300.   else if(i == 1) /* Sonst kann das Scrollen mit der Funktion text_down */
  301.     text_down(0); /* erledigt werden */
  302.   setz_cursor(W_AKT);  /* Cursor an richtige Position setzen */
  303. }
  304.  
  305. /*****************************************************************************
  306. *
  307. *  Funktion       fuehre Move nach unten aus (do_down)
  308. *  --------
  309. *
  310. *  Beschreibung : Der Cursor wird intern um ein Zeichen nach unten bewegt.
  311. *                 Bewegt sich dabei der Cursor aus dem Fenster, so wird
  312. *                 das Fenster gescrollt.
  313. *
  314. *****************************************************************************/
  315.  
  316. void do_down()
  317. {
  318.   /* *** interne Daten und Initialisierung *** */
  319.   register int hilf,  /* Zum Einlesen einer Tastenkombination */
  320.            i=0;   /* Zaehler, wie weit gescrollt werden muss */
  321.  
  322.   nodelay (akt_winp->winp,TRUE); /* Funktion taste soll -1 liefern, falls */
  323.   do                             /* keine Taste gedrueckt ist.            */
  324.   {
  325.     if(down() /* Falls Cursor um eine Zeile nach unten bewegt werden konnte */
  326.     && akt_winp->textline >= akt_winp->ws_line+akt_winp->dy) /* und Cursor */
  327.       i++; /* dadurch Fenster verlaesst, Scrollzaehler erhoehen */
  328.   }while ((hilf=taste(akt_winp->winp)) == aktcode); /* Tastenkombination */
  329.   /* einlesen. Falls diese gleich der letzten, Aktion wiederholen */
  330.   lastcode = hilf;  /* Letzte Tastenkombination merken */
  331.   nodelay (akt_winp->winp,FALSE); /* Funktion taste soll wieder auf Tasten- */
  332.                   /* druck warten */
  333.   akt_winp->ws_line += i; /* Fensterinhalt um i Zeilen nach oben */
  334.   if(i>1)  /* Falls mehr als eine Zeile gescrollt werden muss, */
  335.     sw_ohne_refresh(W_AKT); /* ganzes Fenster neu zeichnen */
  336.   else
  337.     if(i == 1)         /* Sonst Scrolling mit Funktion text_up erledigen */
  338.       text_up(0);
  339.   setz_cursor(W_AKT);       /* Cursor an richtige Position setzen */
  340. }
  341.  
  342. /*****************************************************************************
  343. *
  344. *  Funktion       Tablaenge setzen (do_settab)
  345. *  --------
  346. *
  347. *  Beschreibung : Die Tablaenge wird neu eingestellt. Ist die Eingabe leer,
  348. *                 so wird die Tablaenge nicht veraendert.
  349. *
  350. *****************************************************************************/
  351.  
  352. void do_settab()
  353. {
  354.   /* *** interne Daten *** */
  355.   char dummy[100],  /* String fuer Ausgabeaufbereitung */
  356.        num_str[6];  /* String fuer Eingabe */
  357.   int  num;         /* Ergebnis der Umwandlung von num_str in integer */
  358.  
  359.   sprintf(dummy,PROMPT_TABLEN,akt_winp->tablen);
  360.   print_stat(dummy);            /* Prompt ausgeben */
  361.   read_stat(num_str,6,GS_NUM);  /* Eingabe lesen (nur Ziffern (GS_NUM)) */
  362.   clear_stat();                 /* Statuszeile loeschen */
  363.   if((num = atoi(num_str)) > 0) /* Eingabe in Integer umwandeln */
  364.     akt_winp->tablen = num;     /* Falls Wert groesser 0, als neue Tab- */
  365.   setz_cursor(W_AKT);                /* laenge merken, Cursor positionieren */
  366. }
  367.  
  368. /*****************************************************************************
  369. *
  370. *  Funktion       eine Tabposition zurueckspringen (do_backtab)
  371. *  --------
  372. *
  373. *  Beschreibung : Abhaengig vom Autoindent- und Insertmodus wird auf den
  374. *                 Backtab-key reagiert:
  375. *                       AUTOINDENT: Tab richtet sich nach darueberliegender
  376. *                                   Zeile.
  377. *                       INSERT:     feste Tabweite zurueckspringen
  378. *
  379. *****************************************************************************/
  380.  
  381. void do_backtab()
  382. {
  383.   /* *** interne Daten *** */
  384.   register int diff,  /* Entfernung zur naechsten Tabgrenze (nur benutzt, */
  385.               /* falls Autoindent abgeschaltet) */
  386.            nsc;   /* Spaltennummer der Tabgrenze links des Cursors */
  387.  
  388.   if(akt_winp->autoindflag && up()) /* Falls Autoindent eingeschaltet, und */
  389.   { /* Cursor eine Zeile nach oben bewegt werden konnte, */
  390.     /* naechste Tabgrenze links vom Cursor nsc zuweisen. */
  391.     if ((nsc = akt_winp->tablen * ((akt_winp->screencol-1)/akt_winp->tablen))
  392.     >= fastll (akt_winp->alinep->text)) /* Ist nsc hinter Zeilenende, */
  393.       akt_winp->screencol = nsc; /* screencol auf nsc setzen. */
  394.     else                  /* Ist nsc in der Zeile, dann ein Wort nach links */
  395.       word_left();
  396.     down();   /* Anschliessed in die urspruengliche Zeile zurueckkehren */
  397.   }
  398.   else  /* Falls Autoindent ausgeschaltet ist, Entfernung zur naechsten */
  399.     /* links vom Cursor gelegenen Tab-Grenze berechnen */
  400.     for(diff = (akt_winp->screencol-1)%akt_winp->tablen + 1;diff>0;diff--)
  401.       left(); /* So oft dann den Cursor nach links bewegen */
  402.  
  403.   if(akt_winp->ws_col > akt_winp->screencol) /* Falls Cursor dadurch */
  404.   {                                          /* links vom Fenster, */
  405.     akt_winp->ws_col = akt_winp->screencol;  /* Aktuelle Spalte zur ersten */
  406.     sw_ohne_refresh(W_AKT); /* sichtbaren Spalte machen, Fensterinhalt neu zeigen */
  407.   }
  408.   setz_cursor(W_AKT); /* Cursor an richtige Position setzen */
  409. }
  410.  
  411. /*****************************************************************************
  412. *
  413. *  Funktion       Tab einfuegen (do_tab)
  414. *  --------
  415. *
  416. *  Beschreibung : Abhaengig vom Autoindent- und Insertmodus wird auf den
  417. *                 Tab-key reagiert:
  418. *                       AUTOINDENT: Tab richtet sich nach darueberliegender
  419. *                                   Zeile.
  420. *                       INSERT:     Spaces werden eingefuegt.
  421. *
  422. *****************************************************************************/
  423.  
  424. void do_tab()
  425. {
  426.   /* *** interne Daten und Initialisierung *** */
  427.   register int old_sc,  /* Zwischenspeicher fuer Cursorspalte */
  428.            dsc = 0, /* Entfernung, die durch Tab geskipt wird */
  429.            anz_ins; /* Anzahl der eingefuegten Blanks */
  430.  
  431.   if(akt_winp->autoindflag && up()) /* Bei Autoindent eine Zeile hoch */
  432.   {
  433.     old_sc = akt_winp->screencol; /* falls das klappt, Spalte merken */
  434.     word_right();                 /* ein Wort nach rechts */
  435.     down();                       /* und wieder in alte Zeile */
  436.     dsc = akt_winp->screencol - old_sc; /* "Streckenlaenge" merken */
  437.     akt_winp->screencol = old_sc; /* Screencol wieder auf alten Wert */
  438.   }
  439.   /* falls normaler Tab oder bei autoindent nicht weitergegangen werden */
  440.   if(!dsc) /* konnte, Entfernung zur naechsten festen Tabgrenze berechnen */
  441.     dsc = akt_winp->tablen - akt_winp->screencol%akt_winp->tablen;
  442.   if(akt_winp->insflag) /* Falls Insert-Mode aktiv, dsc Blanks einfuegen */
  443.   {
  444.     if((anz_ins = insert(dsc)) < dsc) /* Falls weniger als dsc chars ein- */
  445.     { /* gefuegt werden konnten, eingefuegte Zeichen loeschen */
  446.       mdelete(anz_ins);
  447.       print_err("Zeile zu lang! ");  /* und Fehlermeldung ausgeben */
  448.       return;
  449.     }
  450.     else
  451.       while(anz_ins--)   /* Eingefuegte Zeichen mit Blanks belegen */
  452.     enter_char(' ');
  453.   }
  454.   else  /* Falls im Overwrite-Modus, dsc Zeichen nach rechts bewegen */
  455.     while(dsc--)
  456.       right();
  457.   if(akt_winp->ws_col + akt_winp->dx <= akt_winp->screencol)
  458.   { /* Falls Cursor ausserhalb des Fensters, Fensterinhalt anpassen */
  459.     /* Aktuelle Spalte soll in der Mitte des Fensters stehen */
  460.     akt_winp->ws_col = akt_winp->screencol - akt_winp->dx/2;
  461.     sw_ohne_refresh(W_AKT); /* Anschliessend Fensterinhalt neu anzeigen */
  462.   }
  463.   setz_cursor(W_AKT);  /* Cursor an seine Position plazieren */
  464. }
  465.  
  466. /*****************************************************************************
  467. *
  468. *  Funktion       Page Up ausfuehren (do_pgup)
  469. *  --------
  470. *
  471. *  Beschreibung : Der interne Cursor wird um eine Seite hochbewegt.
  472. *                 Dann wird die Fensterposition angepasst und der
  473. *                 Fensterinhalt erneut dargestellt.
  474. *
  475. *****************************************************************************/
  476.  
  477. void do_pgup()
  478. {
  479.   /* *** interne Daten *** */
  480.   register int hilf;  /* Zum Einlesen einer Tastenkombination */
  481.  
  482.   nodelay (akt_winp->winp,TRUE);  /* Funktion taste soll -1 liefern, */
  483.   do                              /* falls keine Taste gedrueckt ist */
  484.     if((akt_winp->ws_line -= screen_up()) < 0) /* Neuen Fensterstart */
  485.       akt_winp->ws_line = 0;                   /* berechnen          */
  486.   while ((hilf=taste(akt_winp->winp)) == aktcode); /* Naechste Tasten- */
  487.   /* kombination lesen. Ist sie gleich der letzten, Aktion wiederholen */
  488.   lastcode = hilf; /* zuletzt gelesene Tastenkombination merken */
  489.   nodelay (akt_winp->winp,FALSE); /* Fkt. Taste soll auf Taste warten */
  490.   show_win(W_AKT);                 /* Text im Fenster neu anzeigen     */
  491. }
  492.  
  493. /*****************************************************************************
  494. *
  495. *  Funktion       Page Down ausfuehren (do_pgdn)
  496. *  --------
  497. *
  498. *  Beschreibung : Der interne Cursor wird um eine Seite nach unten bewegt.
  499. *                 Dann wird die Fensterposition angepasst und der
  500. *                 Fensterinhalt erneut dargestellt. Steht der Cursor in der
  501. *                 letzten Textzeile, so wird diese in die Bildschirmmitte
  502. *                 plaziert.
  503. *
  504. *****************************************************************************/
  505.  
  506. void do_pgdn()
  507. {
  508.   /* *** interne Daten *** */
  509.   register int hilf;  /* Zum Einlesen einer Tastenkombination */
  510.  
  511.   nodelay (akt_winp->winp,TRUE);  /* Funktion taste soll -1 liefern, */
  512.   do                              /* falls keine Taste gedrueckt ist */
  513.     akt_winp->ws_line += screen_down(); /* Cursor um eine Seite nach unten */
  514.                       /* bewegen und Fensterstart anpassen */
  515.   while ((hilf=taste(akt_winp->winp)) == aktcode); /* Naechste Tasten- */
  516.   /* kombinationo einlesen. Falls gleich der letzten, Aktion wiederholen */
  517.   lastcode = hilf;                    /* letzte Tastenkombination merken */
  518.   nodelay (akt_winp->winp,FALSE); /* Fkt. taste soll auf Taste warten */
  519.   show_win(W_AKT);                  /* Text im Fenster neu anzeigen     */
  520. }
  521.  
  522. /*****************************************************************************
  523. *
  524. *  Funktion       leere Zeile vor aktueller einfuegen (do_open)
  525. *  --------
  526. *
  527. *  Beschreibung : vor der aktuellen Zeile wird eine Zeile eingefuegt, die dann
  528. *                 zur aktuellen wird.
  529. *
  530. *****************************************************************************/
  531.  
  532. void do_open()
  533. {
  534.   /* *** interne Daten *** */
  535.   int indpos,  /* Zur Berechnung, wie weit eingerueckt werden muss */
  536.       old_sc;  /* Zwischenspeicher fuer alte Cursorspalte          */
  537.  
  538.   if(akt_winp->maxline < MAX_ANZ_LINES-1) /* Nur neue Zeile einfuegen, */
  539.   {      /* wenn dadurch maximale Zeilenzahl nicht ueberschritten wird */
  540.     check_buff();  /* evtl. noch im Puffer befindliche Daten in Text kopieren */
  541.     if(akt_winp->maxline >= 0)   /* Enthaelt Text mindestens eine Zeile ? */
  542.     {                     /* Ja, dann muss auf Autoindent geachtet werden */
  543.       if(akt_winp->autoindflag)             /* Autoindent eingeschaltet ? */
  544.     indpos = akt_winp->alinep->text ? strspn(akt_winp->alinep->text," ")
  545.                     : 0; /* Ja, dann die Anzahl */
  546.               /* fuehrender Blanks in der aktuellen Zeile ermitteln */
  547.       akt_winp->alinep = akt_winp->alinep->prev; /* da up nicht vor die erste */
  548.       akt_winp->textline--; /* Zeile geht, muss man "zu Fuss" eine Zeile hoch.    */
  549.       old_sc = akt_winp->screencol;    /* Zeile wird dahinter eingefuegt, */
  550.       akt_winp->screencol = MAXLENGTH; /* also screencol aufs Ende        */
  551.       koppel_line(ADAPT_COORS);  /* Zeile in Textstruktur einfuegen      */
  552.       if (akt_winp->autoindflag) /* Bei Autoindent stellt man sich ueber */
  553.     akt_winp->screencol = indpos; /* den Anfang der Zeile darunter   */
  554.       else
  555.     akt_winp->screencol = old_sc;
  556.  
  557.       if(akt_winp->screencol < akt_winp->ws_col /* Wenn Cursor links oder */
  558.       || akt_winp->ws_col+akt_winp->dx < akt_winp->screencol) /* rechts   */
  559.       { /* ausserhalb des Fensters steht, wird die aktuelle Spalte zur    */
  560.     akt_winp->ws_col = akt_winp->screencol; /* ersten sichtbaren      */
  561.     sw_ohne_refresh(W_AKT);  /* Fensterinhalt neu anzeigen                 */
  562.       }
  563.       else /* Steht Cursor innerhalb des Fensters, wird mit text_down eine */
  564.     text_down(akt_winp->textline - akt_winp->ws_line); /* Zeile auf    */
  565.     }   /* dem Bildschirm eingefuegt */
  566.     else  /* War der Text leer, wird lediglich eine neue Zeile erzeugt */
  567.       koppel_line(IGNORE_COORS); /* Marker und lastpos sind im leeren Text egal */
  568.     setz_cursor(W_AKT);      /* Cursor an richtige Position setzen */
  569.   }
  570.   else                /* Wuerde der Text durch eine weitere Zeile zu lang, */
  571.     print_err(T_SIZE_ERRTEXT);     /* Fehlermeldung ausgeben */
  572. }
  573.  
  574. /*****************************************************************************
  575. *
  576. *  Funktion       leere Zeile hinter aktueller einfuegen (do_hopen)
  577. *  --------
  578. *
  579. *  Beschreibung : hinter der aktuellen Zeile wird eine Zeile eingefuegt, die dann
  580. *                 zur aktuellen wird.
  581. *
  582. *****************************************************************************/
  583.  
  584. void do_hopen()
  585. {
  586.   /* *** interne Daten und Initialisierung *** */
  587.   int hilfs  = akt_winp->shellflag, /* Zwischenspeicher fuer shellflag */
  588.       hilfi  = akt_winp->insflag,   /* Zwischenspeicher fuer insflag   */
  589.       old_sc = akt_winp->screencol; /* Zwischenspeicher fuer screencol */
  590.  
  591.   check_buff(); /* evtl. noch im Puffer stehende Daten in Text uebertragen */
  592.   akt_winp->screencol = fastll(akt_winp->alinep->text); /* Ans Zeilenende */
  593.   akt_winp->insflag = TRUE; /* so wird auf jeden Fall neue Zeile eingefuegt */
  594.   akt_winp->shellflag = FALSE;    /* keine Zeile an Shell schicken */
  595.   if(!do_newline())    /* Zeile einfuegen und testen, ob das geklappt hat */
  596.     akt_winp->screencol = old_sc; /* Falls nein, Cursor wieder in alte Spalte */
  597.   akt_winp->insflag = hilfi;      /* Insflag und shellflag restaurieren */
  598.   akt_winp->shellflag = hilfs;
  599.   setz_cursor(W_AKT);         /* Damit Flags in Kopf richtig angezeigt werden */
  600. }
  601.  
  602. /*****************************************************************************
  603. *
  604. *  Funktion       newline ausfuehren (do_newline)
  605. *  --------
  606. *
  607. *  Ergebnis     :
  608. *                   Typ          : int
  609. *                   Wertebereich : TRUE,FALSE
  610. *                   Bedeutung    : TRUE: Es konnte noch eine Zeile eingefuegt
  611. *                                  werden.
  612. *
  613. *  Beschreibung : Die aktuelle Zeile wird evtl. gesplittet und in der
  614. *                 Textstruktur eine neue Zeile angelegt. Falls dabei der
  615. *                 Cursor aus dem Fenster laeuft, wird der Bildschirm ge-
  616. *                 scrollt.
  617. *
  618. *****************************************************************************/
  619.  
  620. int do_newline()
  621. {
  622.   /* *** interne Daten und Initialisierung *** */
  623.   char *cmd,           /* An SHELL zu uebergebende Kommandozeile */
  624.        swflag = FALSE; /* Zeigt an, ob Fensterinhalt neu gezeigt werden muss */
  625.   int  old_sc;         /* Zwischenspeicher fuer Cursorspalte */
  626.  
  627.   if (akt_winp->insflag) /* Falls im Insert-Mode, dann */
  628.     if (new_line())      /* Zeile einfuegen und testen, ob das geklappt hat */
  629.     { /* Testen, ob Fenster gescrollt werden muss */
  630.       if (akt_winp->textline-akt_winp->ws_line >= akt_winp->dy)
  631.       {
  632.     akt_winp->ws_line++; /* wenn ja, Nummer der ersten Zeile + 1 */
  633.     text_up(0);          /* und Fensterinhalt scrollen */
  634.       }
  635.       else /* Wenn nicht gescrollt werden muss, eine Zeile einfuegen */
  636.     text_down(akt_winp->textline-akt_winp->ws_line);
  637.       if(akt_winp->autoindflag)    /* Wenn Autoindent aktiv ist, */
  638.       {                            /* neue Zeile korrekt einruecken */
  639.     indent_line();             /* Dann wird getestet, ob der Cursor */
  640.     if(akt_winp->ws_col + akt_winp->dx <= akt_winp->screencol /* rechts */
  641.     || akt_winp->screencol < akt_winp->ws_col) /* oder links vom */
  642.     {                                          /* Fenster steht  */
  643.       akt_winp->ws_col = akt_winp->screencol;  /* Wenn ja, dann wird */
  644.       swflag = TRUE; /* aktuelle Spalte zur ersten sichtbaren, und */
  645.     }            /* das Fenster wird als neu zu zeichnend markiert */
  646.     else         /* Wenn der Cursor innerhalb des Fensters blieb, */
  647.       lineout(akt_winp->textline - akt_winp->ws_line); /* dann muss */
  648.       } /* nur die Zeile neu gezeigt werden */
  649.     }
  650.     else /* Wenn keine neue Zeile eingefuegt werden konnte, dann */
  651.     {
  652.       print_err (T_SIZE_ERRTEXT); /* Fehlermeldung ausgeben */
  653.       return (FALSE);             /* und Funktion abbrechen */
  654.     }
  655.   else                  /* OVERWRITE-modus */
  656.   {
  657.     if (!down())        /* Cursor eine Zeile nach unten bewegen */
  658.       return(FALSE);    /* Klappte das nicht, Funktion abbrechen */
  659.     else                /* Klappte es, Cursor an Zeilenanfang stellen */
  660.       bol();
  661.     if (akt_winp->textline-akt_winp->ws_line >= akt_winp->dy) /* Testen, */
  662.     { /* ob Cursor nach unten aus dem Fenster gegangen ist */
  663.       akt_winp->ws_line++; /* Wenn ja, Fensterstart anpassen */
  664.       text_up(0);          /* und Fensterinhalt scrollen */
  665.     }
  666.   }
  667.   /* Wenn Cursor am linken Rand stehen kann, (kein Autoindent oder kein */
  668.   /* Insert-Mode) dann muss die erste Spalte sichtbar sein              */
  669.   if((!akt_winp->autoindflag || !akt_winp->insflag) && akt_winp->ws_col)
  670.   { /* Ist das nicht so, wird der Fensterinhalt als neu zu zeichnend   */
  671.     swflag = TRUE;        /* markiert und Spalte 0 als erste sichtbare */
  672.     akt_winp->ws_col = 0; /* markiert. */
  673.   }
  674.  
  675.      /*** Testen, ob Zeile an SHELL uebergeben werden muss *** */
  676.  
  677.   if(akt_winp->shellflag && (cmd = akt_winp->alinep->prev->text))
  678.   { /* Das ist der Fall, wenn shellflag gesetzt ist und die aufgespaltene */
  679.     old_sc = akt_winp->screencol; /* Zeile nicht leer ist. Dann wird die  */
  680.     up();  /* Cursorspalte gemerkt und der Cursor eine Zeile hochbewegt.  */
  681.     if(akt_winp->maxline < MAX_ANZ_LINES-1) /* Platz fuer weitere Zeile ? */
  682.     {
  683.       koppel_line(ADAPT_COORS);  /* Zeile einfuegen, so dass Shellausgabe */
  684.                  /* nicht mit evtl. Zeilenrest vermischt wird */
  685.       if(to_shell(cmd))   /* nur wenn auch etwas eingefuegt werden konnte */
  686.       {                    /* eine Zeile nach Ende der Ausgabe anspringen */
  687.     gotox(akt_winp->block.e_line+1); /* Steht Cursor anschliessend    */
  688.     /* unter dem Fenster, Fensterposition anpassen */
  689.     if(akt_winp->textline >= akt_winp->ws_line + akt_winp->dy)
  690.       akt_winp->ws_line = akt_winp->textline - akt_winp->dy/2;
  691.     swflag = TRUE;        /* veraenderter Bildschirminhalt */
  692.       }
  693.       else                     /* Wenn keine Shellausgabe vorhanden ist, */
  694.     del_line(ADAPT_COORS); /* eingefuegte Leerzeile wieder loeschen  */
  695.     }
  696.     else                       /* konnte keine Zeile mehr einfuegen */
  697.       pe_or(T_SIZE_ERRTEXT);   /* also Fehlermeldung ausgeben */
  698.     akt_winp->screencol = old_sc; /* Cursorspalte restaurieren */
  699.   }
  700.   if(swflag)            /* Wenn Fensterinhalt als zu restaurierend gekenn- */
  701.     sw_ohne_refresh(W_AKT);  /* zeichnet, Fensterinhalt neu anzeigen */
  702.   setz_cursor(W_AKT);        /* Cursor an richtige Position setzen */
  703.   return (TRUE);
  704. }
  705.  
  706. /*****************************************************************************
  707. *
  708. *  Funktion       loesche eine Zeile (do_delline)
  709. *  --------
  710. *
  711. *  Beschreibung : Die aktuelle Zeile wird aus der Textstruktur geloescht
  712. *                 und der Bildschirm aktualisiert.
  713. *
  714. *****************************************************************************/
  715.  
  716. void do_delline()
  717. {
  718.   /* *** interne Daten und Initialisierung *** */
  719.   register int i=0,  /* Zaehler fuer geloeschte Zeilen */
  720.            hilf, /* Zum Einlesen einer Tastenkombination */
  721.            ret;  /* Zwischenspeicher fuer Rueckgabewert von del_line */
  722.  
  723.   nodelay (akt_winp->winp,TRUE); /* Funktion taste soll -1 liefern, falls */
  724.   do                             /* keine Taste gedrueckt ist. */
  725.   {
  726.     save_delline();              /* zu loeschende Zeile abspeichern */
  727.     if((ret = del_line(ADAPT_COORS)) != NO_LINE_DEL) /* Zeile loeschen, */
  728.       i++;    /* Rueckgabewert von del_line merken und Zaehler anpassen */
  729.   }while ((hilf=taste(akt_winp->winp)) == aktcode); /* Naechste Tasten- */
  730.   /* kombination einlesen. Falls gleich der letzten, Aktion wiederholen */
  731.   lastcode = hilf; /* Zuletzt gelesene Tastenkombination merken */
  732.   nodelay (akt_winp->winp,FALSE); /* Fkt. taste soll auf Taste warten */
  733.  
  734.   if(i == 1 && ret == LAST_LINE_DEL) /* Wenn nur die letzte Zeile geloescht */
  735.   {  /* wurde, dann diese Zeile auf Bildschirm loeschen, Rahmen reparieren */
  736.     wmove(akt_winp->winp,akt_winp->maxline+2-akt_winp->ws_line,1);
  737.     wclrtoeol(akt_winp->winp);
  738.     mvwaddch(akt_winp->winp,akt_winp->maxline+2-akt_winp->ws_line,akt_winp->dx + 1,REST_CHAR);
  739.     setz_cursor(W_AKT);
  740.   }
  741.   if(i) /* Wenn mindestens eine Zeile geloescht wurde, testen ob Cursor */
  742.   {     /* nach oben aus dem Fenster gewandert ist.                     */
  743.     if(akt_winp->textline < akt_winp->ws_line) /* Wenn ja, dann warum ? */
  744.       if(akt_winp->textline == -1) /* Wenn wegen "Text leer", dann      */
  745.     akt_winp->ws_line = 0;     /* ws_line auf 0 setzen              */
  746.       else                         /* Sonst aktuelle Zeile zur ersten   */
  747.     akt_winp->ws_line = akt_winp->textline; /* sichtbaren machen    */
  748.     show_win(W_AKT); /* Anschliessend Fensterinhalt anzeigen                 */
  749.   }
  750. }
  751.  
  752. /*****************************************************************************
  753. *
  754. *  Funktion       Zeilenverknuepfung ausfuehren (do_join)
  755. *  --------
  756. *
  757. *  Beschreibung : Mittels der Funktion join werden die aktuelle und die
  758. *                 nachfolgende Zeile verknuepft. Falls dabei ein Fehler
  759. *                 auftritt, wird gegebenfalls eine Fehlermeldung ausgegeben.
  760. *
  761. *****************************************************************************/
  762.  
  763. void do_join()
  764. {
  765.   /* *** interne Daten *** */
  766.   char first_of_2nd_is_blank,
  767.        first_is_blank;
  768.  
  769.   if (akt_winp->maxline > 0      /* Geht nur, wenn mehr als eine Zeile */
  770.   && akt_winp->alinep->next != akt_winp->dummyp) /* und aktuelle Z. */
  771.   {                              /* nicht letzte Zeile ist */
  772.     first_of_2nd_is_blank = (!akt_winp->alinep->next->text ||
  773.               *(akt_winp->alinep->next->text) == ' ');
  774.     first_is_blank = !akt_winp->alinep->text;
  775.     do_eol();            /* Zunächst ein Zeichen rechts vom Zeilenende */
  776.     if (first_of_2nd_is_blank)  /* Ist erstes Zeichen der nächsten Zeile kein */
  777.       do_right();        /* Blank, dann nicht nach rechts. */
  778.     switch (join(ADAPT_COORS))   /* Verknuepfung ausfuehren, Ergebnis testen */
  779.     {
  780.       case J_TOOLONG : print_err(L_SIZE_ERRTEXT); /* Zeile wurde zu lang, */
  781.                break;                     /* Meldung ausgeben     */
  782.       case J_OK      : if(first_of_2nd_is_blank) /* Falls Blank, dann */
  783.              do_del_word();   /* Text ranziehen */
  784.                else               /* Sonst Blank einfügen */
  785.                { /* geht gut, da join() mindestens ein Zeichen */
  786.              /* Aber nur einfügen, wenn erste Zeile nicht
  787.                 leer war ! */
  788.              if (!first_is_blank)
  789.              {
  790.                insert(1);  /* Platz am Zeilenende läßt */
  791.                enter_char(' ');
  792.              }
  793.                }
  794.                show_win(W_AKT); /* Alles OK, Fensterinhalt neu anzeigen */
  795.     }
  796.   }
  797. }
  798.  
  799. /*****************************************************************************
  800. *
  801. *  Funktion       Springe bestimmte Zeile an (do_goto)
  802. *  --------
  803. *
  804. *  Beschreibung : Nach Einlesen einer Zeilennummer wird, falls moeglich,
  805. *                 die aktuelle Zeile entsprechend gesezt.
  806. *
  807. *****************************************************************************/
  808.  
  809. void do_goto()
  810. {
  811.   /* *** interne Daten *** */
  812.   char number[10]; /* String fuer einzulesende Zeilennummer */
  813.   int numi;        /* Eingelesene Zeilennummer als Integer  */
  814.  
  815.   print_stat(PROMPT_LINENUMB);
  816.   read_stat(number,9,GS_NUM);     /* Zeilennummer einlesen (nur Ziffern) */
  817.   clear_stat();                   /* Statuszeile wieder loeschen */
  818.  
  819.   /* String in int wandeln und Bereichspruefung durchfuehren */
  820.   if((numi = atoi(number)) > 0 && numi <= akt_winp->maxline+1)
  821.   { /* Wenn Zeilennummer im korrekten Bereich, dann */
  822.     akt_winp->lastline = akt_winp->textline; /* aktuelle Position als  */
  823.     akt_winp->lastcol = akt_winp->screencol; /* letzte Position merken */
  824.     gotox(numi-1);                     /* gewuenschte Zeile anspringen */
  825.     if((akt_winp->ws_line = numi-akt_winp->dy/2) < 0) /* Zeile in der Mitte */
  826.       akt_winp->ws_line = 0; /* plazieren. Falls das nicht geht, weil       */
  827.       /* Zeilennummer zu klein, ws_line entsprechend anpassen               */
  828.     sw_ohne_refresh(W_AKT);  /* Fensterinhalt neu anzeigen */
  829.   }
  830.   setz_cursor(W_AKT);        /* Cursor an richtige Position setzen */
  831. }
  832.  
  833. /*****************************************************************************
  834. *
  835. *  Funktion       beende editor (do_ende)
  836. *  --------
  837. *
  838. *  Beschreibung : Nach einer Rueckfrage wird der Editor evtl. beendet.
  839. *                 Nach dem letzten Speichern geaenderte Files werden ab-
  840. *                 gespeichert. Danach wird das Config-File geupdatet.
  841. *
  842. *****************************************************************************/
  843.  
  844. void do_ende()
  845. {
  846.   /* Meldung ausgeben und J/N-Abfrage vornehmen */
  847.   if(!did_anything_change() || ja_nein(PROMPT_WARNSAVE))
  848.     /* Will User wirklich beenden, alle geaenderten Dateien sichern */
  849.     if(save_all() || ja_nein(PROMPT_EXITANYWY)) /* Bei Fehler Abfrage */
  850.     { /* Wenn Speichern klappte, oder Abfrage mit J beantwortet wurde, */
  851.       write_config();  /* wird die Konfigurationsdatei gespeichert, */
  852.       alles_frei();    /* aller reservierter Speicher freigegeben   */
  853.       ende(0, TRUE);   /* und der Editor beendet.                   */
  854.     }
  855.   setz_cursor(W_AKT); /* Will der User doch nicht abbrechen, wird der Cursor */
  856. }                /* an seine korrekte Position gesetzt. */
  857.  
  858. /******************************************************************************
  859. *
  860. * Funktion     : Loadfile ausführen (ex_load)
  861. * --------------
  862. *
  863. * Beschreibung : Das in der globalen Variablen spezifizierte loadfile wird
  864. *                ausgeführt. Dazu wird der Inhalt der Datei in eine tempo-
  865. *                räre Datei kopiert (mit system("copy...")). An die temporäre
  866. *                Datei wird eine Zeile angehängt, die "exit" enthält.
  867. *                Dann wird command.com über spawnlp aufgerufen, als Parameter
  868. *                wird "<"+<Name der temporären Datei> übergeben. Die Shell
  869. *                liest also die Kommandos aus der temporären Datei und wird
  870. *                anschließend durch exit beendet. Anschließend wird die
  871. *                tempräre Datei gelöscht und der Return-Wert von spawnlp
  872. *                behandelt.
  873. *
  874. ******************************************************************************/
  875.  
  876. void ex_load()
  877. {
  878.   int sys_ret;      /* Rückgabewert der system-Funktion */
  879.   int ex_st;
  880.  
  881.   if(access(loadfile,4) == 0)  /* Lese-Zugriff auf Loadfile ? */
  882.   {
  883.     sys_ret = system(loadfile);
  884.     if(sys_ret == -1)
  885.       fprintf(stderr,NO_LOAD_ERRTEXT);  /* Falls system nicht klappte, */
  886.     ex_st=sys_ret;       /* Fehlermeldung ausgeben und ende */
  887.   }
  888.   else
  889.   {
  890.     fprintf(stderr,"Loadfile %s nicht gefunden !\n",loadfile);
  891.     ex_st=1;
  892.   }
  893. #ifdef MOUSE
  894. #ifdef OS2
  895.   mouse_active = FALSE;
  896.   DosWaitThread (&mouse_ThreadID, DCWW_WAIT);
  897.   if (mouse_jn_ThreadID) /* Wurde schon einmal ja_nein aufgerufen? */
  898.     DosWaitThread (&mouse_jn_ThreadID, DCWW_WAIT);
  899. #else
  900.   set_mouse_int(0); /* Mausroutine maskieren */
  901. #endif
  902. #endif
  903. #ifndef OS2
  904.   *(long*)(27*4) = old_int; /* Vektor des Break-Interruptes restaurieren */
  905. #endif
  906.   exit (ex_st);
  907. }
  908.  
  909. /*****************************************************************************
  910. *
  911. *  Funktion       beende editor mit loadfile (do_endemit)
  912. *  --------
  913. *
  914. *  Beschreibung : Nach einer Rueckfrage wird der Editor evtl. beendet.
  915. *                 Nach dem letzten Speichern geaenderte Files werden ab-
  916. *                 gespeichert. Danach wird das Config-File geupdatet
  917. *                 und das Load-File ausgefuehrt.
  918. *
  919. *****************************************************************************/
  920.  
  921. void do_endemit()
  922. {
  923.   /* Funktion der Abfragen s.o. */
  924.   if(!did_anything_change() || ja_nein(PROMPT_WARNSAVE))
  925.     if(save_all() || ja_nein(PROMPT_EXITANYWY))
  926.     {
  927.       write_config();  /* Konfigurationsdatei abspeichern */
  928.       alles_frei();    /* Saemtlichen reservierten Speicherplatz freigeben */
  929.       clear();         /* Bildschirm loeschen */
  930.       refresh();
  931.       endwin();        /* Curses "abschalten" */
  932.       ex_load();       /* Loadfile ausführen, Programm wird beendet */
  933.     }
  934.   setz_cursor(W_AKT); /* Will User doch nicht beenden, Cursor wieder plazieren */
  935. }
  936.  
  937.  
  938. /*****************************************************************************
  939. *
  940. *  Funktion       verlasse editor (quit)
  941. *  --------
  942. *
  943. *  Beschreibung : Das Programm wird (nach Rueckfrage) beendet.
  944. *
  945. *****************************************************************************/
  946.  
  947. void quit()
  948. {
  949.   if (!did_anything_change() || ja_nein (PROMPT_WARNQUIT))
  950.   { /* Sicherheitsabfrage */
  951.     write_config();  /* Wenn User wirklich beenden will, Config-Datei */
  952.     alles_frei();    /* speicher, Speicherplatz freigeben, */
  953.     ende(0, TRUE);   /* Editor beenden */
  954.   }
  955.   setz_cursor(W_AKT);     /* Falls doch nicht beendet werden soll, Cursor */
  956. }                    /* wieder an richtige Position stellen */
  957.  
  958. /*****************************************************************************
  959. *
  960. *  Funktion       quit mit Ausfuehren des load-Files (quitmit)
  961. *  --------
  962. *
  963. *  Beschreibung : Nach einer positiv beantworteten Rueckfrage wird die
  964. *                 Config-Datei gespeichert und der Editor mit dem
  965. *                 Load-File ueberlagert.
  966. *
  967. *****************************************************************************/
  968.  
  969. void quitmit()
  970. {
  971.   if (!did_anything_change() || ja_nein (PROMPT_WARNQUIT))
  972.   { /* Sicherheitsabfrage */
  973.     write_config(); /* Falls mit J geantwortet wurde, Config-Datei */
  974.     alles_frei();   /* speichern, Speicherplatz freigeben, */
  975.     clear();        /* Bildschirm loeschen */
  976.     refresh();
  977.     endwin();       /* Curses "abschalten" */
  978.     ex_load();
  979.   }
  980.   setz_cursor(W_AKT); /* Wollte User doch nicht beenden, Cursor plazieren */
  981. }
  982.