home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 5 Edit / 05-Edit.zip / ehp14cs.zip / aus_1.c next >
C/C++ Source or Header  |  1995-08-14  |  30KB  |  733 lines
  1. /****************************************************************/
  2. /*                                                              */
  3. /*      MODUL:  aus_1.c                                         */
  4. /*                                                              */
  5. /*      FUNKTIONEN:                                             */
  6. /*              - ueberschreiben (Neuen Text in altes Fenster)  */
  7. /*              - do_win_zu (Fenster schliessen)                */
  8. /*              - laden (Datei laden und Fenster oeffnen)       */
  9. /*              - do_schreib_file (Datei abspeichern)           */
  10. /*              - do_help (Hilfstexte an/aus)                   */
  11. /*              - do_refresh (refreshe Bildschirm)              */
  12. /*              - do_z_runter (Text und Cursor eine Z. runter)  */
  13. /*              - do_z_hoch (Text und Cursor eine Zeile hoch)   */
  14. /*              - do_z_mitte (aktuelle Zeile in Fenstermitte)   */
  15. /*              - do_z_unten (aktuelle Zeile an Fensterende)    */
  16. /*              - do_z_oben (aktuelle Zeile an Fensteranfang)   */
  17. /*              - do_bol (gehe an Zeilenanfang)                 */
  18. /*              - do_eol (gehe an Zeilenende)                   */
  19. /*              - do_halfup (gehe halbe Seite hoch)             */
  20. /*              - do_halfdn (gehe halbe Seite runter)           */
  21. /*              - do_delete (loesche aktuelles Zeichen)         */
  22. /*              - do_backspace (loesche Zeichen links)          */
  23. /*              - do_home (Cursor an Bildschirmanfang)          */
  24. /*              - do_middle (Cursor an Bildschirmmitte)         */
  25. /*              - do_nothome (Cursor an Bildschirmende)         */
  26. /*              - do_underline (Underlinemodus togglen)         */
  27. /*              - do_insovr (Schreibmodus togglen)              */
  28. /*              - do_matchpar (passennde Klammer finden)        */
  29. /*                                                              */
  30. /****************************************************************/
  31.  
  32. #define aus1_def
  33. #include "defs.h"
  34.  
  35. extern char backupflag,highblockflag,clear_buff,bufflag;
  36. extern int schreib_file(),to_shell();
  37. extern short int letter,lastcode,aktcode,taste();
  38. extern int save_delline(),rest_delline();
  39. extern int tst_overlap(),do_find(),do_replace(),do_repfr();
  40. extern char bufflag,*loadfile;
  41. extern bzeil_typ *save_normal(),*save_rechteck();
  42. extern block_typ global_block,*dup_block();
  43. extern puff_typ macro[],puff_feld[];
  44. extern int ks_index;
  45. extern short int *keystack,*e_keystack,newwgetch();
  46. extern WINDOW *status;
  47. extern marker_typ marker[];
  48. void do_refresh();
  49.  
  50. /* *** interne Daten und Initialisierung *** */
  51. char *on_off[] = 
  52. #ifdef GERMAN
  53.          {"ausgeschaltet.","eingeschaltet."}; /* Hilfstexte */
  54. #else
  55.          {"turned off.","turned on."}; /* Hilfstexte */
  56. #endif
  57.                  /* fuer Togglen der globalen Flags */
  58. char helpflag=TRUE;              /* Flag: Hilfstexte anzeigen       */
  59.  
  60. /****************************************************************************
  61. *
  62. *  Funktion       Neuen Text in altes Fenster (ueberschreiben)
  63. *  --------
  64. *
  65. *  Beschreibung : Fragt den User nach dem Filenamen der Datei und liest,
  66. *                 falls die Datei geladen werden konnte, diese ein.
  67. *                 Gelang dies nicht, wird das Fenster geschlossen.
  68. *
  69. *****************************************************************************/
  70.  
  71. void ueberschreiben()
  72. {
  73.   /* *** interne Daten und Initialisierung *** */
  74.   char    name[61],                 /* Name der zu ladenden Datei */
  75.       dummy[MAXLENGTH+1];       /* String fuer Fehlermeldung  */
  76.   int     wn = akt_winp->wini,      /* Variable fuer aktuelle Fensternummer */
  77.       ws;                       /* Fensternummer des Fensters, in dem Datei
  78.                        eventuell schon enthalten ist */
  79.  
  80.   if(!akt_winp->changeflag || ja_nein(PROMPT_WARNLOAD))
  81.   {
  82.     print_stat(PROMPT_FILENAME);
  83.     read_stat(name,60,GS_ANY); /* Filename nach name einlesen (alle Zeichen erlaubt) */
  84.     clear_stat();              /* Kommandozeile wieder loeschen */
  85.     if(!name[0])               /* Falls Leereingabe, Funktion beenden */
  86.     {
  87.       setz_cursor(W_AKT);
  88.       return;
  89.     }
  90.     bufflag = FALSE;            /* Pufferinhalt verwerfen */
  91.     akt_winp->filename[0]='\0'; /* leere Filenamen gibt es nicht */
  92.     free_text();                /* also wird aktuelles Fenster durch sw_name */
  93.     if (sw_name(name))          /* keinesfalls gefunden. sw_name checkt, */
  94.     {                           /* ob Datei in einem Fenster vorhanden */
  95.       sprintf(dummy,PROMPT_ALRDYLDD, akt_winp->wini);
  96.       if (!ja_nein(dummy))      /* Eingabe J/N, ob trotzdem ueberladen */
  97.       {
  98.     ws = akt_winp->wini;    /* Nummer des jetzt aktuellen Fensters merken */
  99.     make_akt_win(wn);       /* Zum alten Fenster gehen */
  100.     werase(akt_winp->winp); /* Fenster auf Bildschirm loeschen */
  101.     delwin(akt_winp->winp); /* Altes Fenster mit Curses loeschen */
  102.     gb_win_frei();          /* Window aus Liste auskoppeln */
  103.     make_akt_win(ws);       /* Wieder zum gefundenen Fenster gehen */
  104.     do_refresh();           /* Jetzt aktuellen Bildschirm zeichnen */
  105.     return;
  106.       }
  107.       else                      /* Wenn trotzdem überladen werden soll, */
  108.     make_akt_win(wn);       /* dann wieder zum alten Fenster gehen  */
  109.     }
  110.     line_free(akt_winp->filename); /* Filenamen deallokieren */
  111.     akt_winp->filename = save_text (name); /* Speicher fuer Filenamen holen */
  112.                        /* und Filename merken */
  113.     if (!lies_file ())          /* Datei einlesen. Falls das nicht klappt, */
  114.     {
  115.       werase(akt_winp->winp);   /* Fenster auf Bildschirm loeschen */
  116.       delwin(akt_winp->winp);   /* Fenster freigeben */
  117.       gb_win_frei ();           /* und aus Liste auskoppeln */
  118.       if(akt_winp->next == akt_winp)    /* kein Fenster mehr ? */
  119.       {
  120.     write_config();         /* Dann Config-File schreiben */
  121.     ende(0, TRUE);          /* und Programm beenden */
  122.       }
  123.       do_refresh();             /* Sonst kompletten Schirm neu aufbauen */
  124.     }
  125.     else                /* laden funktionierte */
  126.     {
  127.       akt_winp->ws_line = akt_winp->ws_col = 0; /* Erste Zeile und Spalte zeigen */
  128.       akt_winp->textcol = akt_winp->screencol = 0; /* Cursor nach oben links */
  129.       akt_winp->block.s_line = akt_winp->block.e_line = -1; /* kein Block markiert */
  130.       sw_ohne_refresh(W_AKT);                        /* Fenster darstellen */
  131.     }
  132.   }
  133.   setz_cursor(W_AKT);                /* Cursor plazieren und refresh ausfuehren */
  134. }
  135.  
  136. /****************************************************************************
  137. *
  138. *  Funktion       Fenster schliessen (do_win_zu)
  139. *  --------
  140. *
  141. *  Parameter    : wait_mouse:
  142. *                 Typ         : char
  143. *                 Wertebereich: TRUE, FALSE
  144. *                 Bedeutung   : Rufe im Falle, daß das zu schließende
  145. *                               Fenster das letzte offene war, ende()
  146. *                               mit wait_mouse als 2. Parameter auf.
  147. *
  148. *  Beschreibung : Nach einer Rueckfrage wird ggf. der dem Fenster assoziierte
  149. *                 Text freigegeben und das Fenster geschlossen.
  150. *
  151. *****************************************************************************/
  152.  
  153. void do_win_zu(wait_mouse)
  154. char wait_mouse;
  155. {
  156.   if(!akt_winp->changeflag ||     /* Hat sich Text nicht geaendert ? */
  157.      (akt_winp->changeflag &&     /* oder falls doch, will der User abbrechen ? */
  158.      ja_nein(PROMPT_WARNCLOSE)))
  159.   {
  160.     bufflag = FALSE;              /* Pufferinhalt verwerfen */
  161.     free_text();                  /* Text des aktuellen Fensters freigeben */
  162.     werase(akt_winp->winp);       /* Fenster fuer Curses loeschen */
  163.     delwin(akt_winp->winp);
  164.     gb_win_frei();                /* Fenster aus Liste auskoppeln */
  165.     if(akt_winp->next == akt_winp)      /* wenn keine Textfiles mehr, */
  166.     {
  167.       write_config();                   /* Config-File schreiben und Editor */
  168.       ende(0, wait_mouse);              /* beenden */
  169.     }
  170.     do_refresh();                       /* Sonst ganzen Schirm neu aufbauen */
  171.   }
  172.   setz_cursor(W_AKT);             /* und Cursor an richtige Position */
  173. }
  174.  
  175. /****************************************************************************
  176. *
  177. *  Funktion       laden (laden)
  178. *  --------
  179. *
  180. *  Ergebnis     : TRUE, falls File geladen werden konnte, sonst FALSE
  181. *  Beschreibung : Fragt den User nach dem Filenamen der Datei.
  182. *                 Falls schon ein Fenster mit dieser Datei existiert, wird
  183. *                 der User gefragt, ob wirklich neu geladen werden soll.
  184. *                 Wenn ja, dann oeffnet die Funktion, falls die Datei
  185. *                 geladen werden konnte, dafuer ein Fenster.
  186. *
  187. *****************************************************************************/
  188.  
  189. int laden()
  190. {
  191.   /* *** interne Daten und Initialisierung *** */
  192.   char    name[61],            /* Name der zu ladenden Datei */
  193.       dummy[MAXLENGTH+1];  /* String fuer Fehlermeldung */
  194.   int     wn = akt_winp->wini; /* Nummer des aktuellen Fensters */
  195.       /* um entscheiden zu koennen, ob Fenster neu gezeichnet werden muss */
  196.  
  197.   check_buff();                 /* Puffer evtl. zurueckschreiben */
  198.   print_stat(PROMPT_FILENAME);
  199.   read_stat(name,60,GS_ANY);    /* Filenamen einlesen (max. 60 zeichen) */
  200.   clear_stat();                 /* Kommandozeile wieder loeschen */
  201.   if(!name[0])                  /* Abbruch, falls leerer Name */
  202.   {
  203.     setz_cursor(W_AKT);
  204.     return (FALSE);
  205.   }
  206.   rahmen(W_NOTAKT); /* Rahmen "unhighlighten", damit falls anderes Fenster */
  207.   kopf(W_NOTAKT);   /* zum aktiven wird, nicht 2 gehighlightet */
  208.   if(akt_winp->next != akt_winp) /* Schon ein Fenster auf ? */
  209.     wrefresh(akt_winp->winp);
  210.   if (sw_name(name))            /* Versuchen, ein Fenster mit diesem Datei- */
  211.   {                             /* namen zu finden */
  212.     sprintf(dummy,PROMPT_ALRDYLDD,akt_winp->wini);
  213.     if (!ja_nein(dummy))        /* Falls gefunden, fragen, ob trotzdem neu laden */
  214.     {
  215.       show_win(W_AKT);           /* Falls nein, gefundenes Fenster zeichnen */
  216.       return (TRUE);
  217.     }
  218.   }
  219.   if (koppel_win())             /* Neues Fenster in Fensterliste einhaengen */
  220.   {                             /* Falls das klappt, Speicherplatz fuer File- */
  221.     akt_winp->filename = save_text (name); /* namen holen und merken */
  222.     akt_winp->block.bstart = (bzeil_typ*) NULL;
  223.     if (!lies_file())           /* Datei einlesen */
  224.     {                           /* klappt das nicht, neu eingehaengtes Fenster */
  225.       gb_win_frei();            /* wieder auskoppeln */
  226.       rahmen(W_AKT);            /* Altes Fenster wieder optisch aktivieren */
  227.       setz_cursor(W_AKT);
  228.       return(FALSE);
  229.     }
  230.     open_window();              /* Klappte Einlesen, dann Fenster auf Schirm */
  231.     return(TRUE);               /* oeffnen, Koordinaten initialisieren usw. */
  232.   }
  233.   if(wn != akt_winp->wini)      /* Falls das aktuelle Fenster ein anderes ist */
  234.     show_win(W_AKT);             /* als vorher, dann neu zeichnen */
  235.   print_err(PROMPT_NOWINDOW); /* Falls koppel_win nicht klappte, Error */
  236.   return(FALSE);
  237. }
  238.  
  239. /*****************************************************************************
  240. *
  241. *  Funktion       Datei abspeichern (do_schreib_file)
  242. *  --------
  243. *
  244. *  Beschreibung : Die Datei im aktuellen Fenster wird mit der Funktion
  245. *                 schreib_file abgespeichert. Danach wird die Funktion
  246. *                 setz_cursor aufgerufen, damit in der unteren Rahmenzeile
  247. *                 der Text GEAENDERT verschwindet.
  248. *
  249. *****************************************************************************/
  250.  
  251. void do_schreib_file()
  252. {
  253.   schreib_file(); /* Aktuellen Text abspeichern */
  254.   setz_cursor(W_AKT);  /* Cursor wieder an richtige Stelle */
  255. }
  256.  
  257. /*****************************************************************************
  258. *
  259. *  Funktion       Hilfstexte an/aus (do_help)
  260. *  --------
  261. *
  262. *  Beschreibung : Die Hilfstextoption wird an- bzw. ausgeschaltet
  263. *
  264. *****************************************************************************/
  265.  
  266. void do_help()
  267. {
  268.   print_stat(PROMPT_HELPTEXT); /* Wenn helpflag TRUE ist, wird "eingeschaltet" */
  269.   print_stat(on_off[helpflag ^= TRUE]); /* ausgegeben, sonst "ausgeschaltet" */
  270.   sleep(2); /* 2 Sekunden warten, damit User die Meldung lesen kann. */
  271.   clear_stat();  /* Statuszeile wieder loeschen */
  272.   setz_cursor(W_AKT); /* und Cursor wieder an richtige Position */
  273. }
  274.  
  275. /*****************************************************************************
  276. *
  277. *  Funktion       refreshe Bildschirm (do_refresh)
  278. *  --------
  279. *
  280. *  Beschreibung : Der Bildschirm wird geloescht, alle Fenster, Rahmen und
  281. *                 Kopfzeilen neu gezeichnet und danach setz_cursor() aufge-
  282. *                 rufen.
  283. *
  284. *****************************************************************************/
  285.  
  286. void do_refresh()
  287. {
  288.   /* *** interne Daten und Initialisierung *** */
  289.   win_typ *oldwin = akt_winp; /* Zeiger auf Fenster, das bei Aufruf der */
  290.                   /* Funktion aktuell war. */
  291.  
  292.   check_buff();         /* Evtl. Pufferinhalt in Text schreiben */
  293.   werase(curscr);       /* Gesamten Bildschirm loeschen */
  294.   for(akt_winp=akt_winp->next->next; akt_winp != oldwin->next; akt_winp=akt_winp->next)
  295.   { /* Alle Fenster durchlaufen */
  296.     sw_ohne_refresh(akt_winp == oldwin ? W_AKT : W_NOTAKT); /* Fensterinhalt neu ausgeben */
  297.     kopf(akt_winp == oldwin ? W_AKT : W_NOTAKT); /* Kopf des Fensters ausgeben */
  298. #ifdef OWN_CURSES
  299.     wnoutrefresh(akt_winp->winp); /* Fensterinhalt anzeigen */
  300. #else
  301.     wrefresh(akt_winp->winp);
  302. #endif
  303.   } /* noch nicht in physikalischen Bildschirm uebertragen */
  304.   akt_winp = oldwin; /* Das Fester, das vorher aktuelle war, wieder zum */
  305.   pos_cursor();      /* aktuellen machen, Cursor positionieren */
  306. #ifdef OWN_CURSES
  307.   doupdate();       /* und virtuellen Bildschirm in physikalischen uebertragen */
  308. #endif
  309. }
  310.  
  311. /*****************************************************************************
  312. *
  313. *  Funktion       Text und Cursor eine Zeile runter (do_z_runter)
  314. *  --------
  315. *
  316. *  Beschreibung : Der Text wird mitsamt Cursor um eine Zeile nach unten
  317. *                 bewegt.
  318. *
  319. *****************************************************************************/
  320.  
  321. void do_z_runter()
  322. {
  323.   /* *** interne Daten und Initialisierung *** */
  324.   int   i=0;      /* Zaehler fuer Wiederholungen */
  325.   short int hilf; /* Zum Einlesen einer Tastenkombination */
  326.  
  327.   nodelay (akt_winp->winp,TRUE); /* taste soll -1 liefern, falls keine */
  328.   do                             /* Taste gedrueckt ist. */
  329.     i++;
  330.   while ((hilf=taste(akt_winp->winp)) == aktcode); /* Falls der gleiche */
  331.   /* Code noch mal im Puffer, ganze Aktion wiederholen */
  332.   lastcode = hilf;  /* Zuletzt gelesene Tastenkombination merken */
  333.   nodelay (akt_winp->winp,FALSE); /* Funktion taste soll auf Taste warten */
  334.  
  335.   if(akt_winp->maxline >= 0 && akt_winp->ws_line > 0)
  336.   { /* Falls Text nicht leer und noch nicht die erste Textzeile zu sehen ist, */
  337.     if(i==1) /* Nur einmel ? */
  338.     {
  339.       akt_winp->ws_line--; /* Nummer der ersten sichtbaren Zeile dekrementieren */
  340.       text_down(0);        /* Text ab Zeile 0 (ganzes Fenster) um 1 nach unten  */
  341.       if(akt_winp->textline >= akt_winp->ws_line + akt_winp->dy)
  342.     up(); /* Stand Cursor in letzter Schirmzeile, Cursor 1 Zeile hoch */
  343.       setz_cursor(W_AKT);        /* Cursor an richtige Position */
  344.     }
  345.     else /* mehrere Wiederholungen */
  346.     {
  347.       /* Fensterinhalt scrollen. Falls zuweit, dann letzte Zeile anzeigen */
  348.       if((akt_winp->ws_line -= i) < 0)
  349.     akt_winp->ws_line = 0;
  350.       /* Ist der Cursor aus dem Fenster gerutscht, dann wird er */
  351.       /* in die letzte Fensterzeile gestellt. Das kann nicht    */
  352.       /* hinter dem Textende sein, da er sonst nicht aus dem    */
  353.       /* Fenster gerutscht waere.                               */
  354.       if(akt_winp->textline >= akt_winp->ws_line+akt_winp->dy)
  355.     gotox(akt_winp->ws_line+akt_winp->dy-1);
  356.       show_win(W_AKT); /* Fensterinhalt darstellen */
  357.       setz_cursor(W_AKT); /* Cursor an richtige Position stellen */
  358.     }
  359.   }
  360. }
  361.  
  362. /*****************************************************************************
  363. *
  364. *  Funktion       Text und Cursor eine Zeile hoch (do_z_hoch)
  365. *  --------
  366. *
  367. *  Beschreibung : Der Text wird mitsamt Cursor um eine Zeile nach oben
  368. *                 bewegt.
  369. *
  370. *****************************************************************************/
  371.  
  372. void do_z_hoch()
  373. {
  374.   /* *** interne Daten und Initialisierung *** */
  375.   int   i=0;      /* Zaehler fuer Wiederholungen */
  376.   short int hilf; /* Zum Einlesen einer Tastenkombination */
  377.  
  378.   nodelay (akt_winp->winp,TRUE); /* taste soll -1 liefern, falls keine */
  379.   do                             /* Taste gedrueckt ist. */
  380.     i++;
  381.   while ((hilf=taste(akt_winp->winp)) == aktcode); /* Falls der gleiche */
  382.   /* Code noch mal im Puffer, ganze Aktion wiederholen */
  383.   lastcode = hilf;  /* Zuletzt gelesene Tastenkombination merken */
  384.   nodelay (akt_winp->winp,FALSE); /* Funktion taste soll auf Taste warten */
  385.  
  386.   if(akt_winp->ws_line < akt_winp->maxline)
  387.   { /* Wenn noch nicht die letzte Textzeile zu sehen ist, */
  388.     if(i==1) /* Nur einmel ? */
  389.     {
  390.       akt_winp->ws_line++; /* dann Nummer der ersten sichtbaren Zeile erhoehen */
  391.       text_up(0);          /* gesamten Fenstertext um 1 Zeile nach oben */
  392.       if(akt_winp->textline < akt_winp->ws_line) /* Falls Cursor in oberster */
  393.     down();            /* Zeile, dann Cursor um 1 Zeile nach unten bewegen */
  394.       setz_cursor(W_AKT);       /* Cursor an richtige Position setzen */
  395.     }
  396.     else /* mehrere Wiederholungen */
  397.     {
  398.       /* Fensterinhalt scrollen. Falls zuweit, dann letzte Zeile anzeigen */
  399.       if((akt_winp->ws_line += i) > akt_winp->maxline)
  400.     akt_winp->ws_line = akt_winp->maxline;
  401.       /* Ist der Cursor aus dem Fenster gerutscht, dann wird er */
  402.       /* in die erste Fensterzeile gestellt.                    */
  403.       if(akt_winp->textline < akt_winp->ws_line)
  404.     gotox(akt_winp->ws_line);
  405.       show_win(W_AKT); /* Fensterinhalt darstellen */
  406.       setz_cursor(W_AKT); /* Cursor an richtige Position stellen */
  407.     }
  408.   }
  409. }
  410.  
  411. /*****************************************************************************
  412. *
  413. *  Funktion       aktuelle Zeile in Fenstermitte (do_z_mitte)
  414. *  --------
  415. *
  416. *  Beschreibung : Die aktuelle Zeile wird in die Fenstermitte bewegt.
  417. *
  418. *****************************************************************************/
  419.  
  420. void do_z_mitte()
  421. {
  422.   /* Erste sichtbare Zeile wird die, die einen halben Bildschirm (dy/2)  */
  423.   /* ueber der aktuellen Zeile liegt. Sollte dadurch ws_line kleiner als */
  424.   /* 0 werden (textline zu klein), wird die erster Textzeile zur ersten  */
  425.   /* sichtbaren Zeile gemacht */
  426.   if((akt_winp->ws_line = akt_winp->textline - akt_winp->dy/2)<0)
  427.     akt_winp->ws_line = 0;
  428.   show_win(W_AKT); /* Fensterinhalt anzeigen */
  429. }
  430.  
  431. /*****************************************************************************
  432. *
  433. *  Funktion       aktuelle Zeile an Fensterende (do_z_unten)
  434. *  --------
  435. *
  436. *  Beschreibung : Die aktuelle Zeile wird an das Fensterende bewegt.
  437. *
  438. *****************************************************************************/
  439.  
  440. void do_z_unten()
  441. {
  442.   /* Erste sichtbare Zeile wird aktuelle Zeile abzueglich einer Bild-   */
  443.   /* schirmlaenge. Ist das resultat kleiner 0 (textline zu klein), wird */
  444.   /* die erste Textzeile zur ersten sichtbaren Zeile */
  445.   if((akt_winp->ws_line = akt_winp->textline - akt_winp->dy + 1)<0)
  446.     akt_winp->ws_line = 0;
  447.   show_win(W_AKT); /* Fensterinhalt darstellen */
  448. }
  449.  
  450. /*****************************************************************************
  451. *
  452. *  Funktion       aktuelle Zeile an Fensteranfang (do_z_oben)
  453. *  --------
  454. *
  455. *  Beschreibung : Die aktuelle Zeile wird an den Fensteranfang bewegt.
  456. *
  457. *****************************************************************************/
  458.  
  459. void do_z_oben()
  460. {
  461.   if(akt_winp->textline >=0) /* Falls Text nicht leer, */
  462.   {
  463.     akt_winp->ws_line = akt_winp->textline; /* wird aktuelle Zeile zur */
  464.     show_win(W_AKT); /* erster sichtbaren, Fensterinhalt wird neu dargestellt */
  465.   }
  466. }
  467.  
  468. /*****************************************************************************
  469. *
  470. *  Funktion       Gehe an Zeilenanfang (do_bol)
  471. *  --------
  472. *
  473. *  Beschreibung : Der Cursor wird an den Zeilenanfang bewegt.
  474. *
  475. *****************************************************************************/
  476.  
  477. void do_bol()
  478. {
  479.   bol();                    /* Cursor an Zeilenanfang stellen */
  480.   if(akt_winp->ws_col)      /* Wenn erste Spalte nicht auf Bildschirm, */
  481.   {
  482.     akt_winp->ws_col = 0;   /* Dann erste Spalte zur ersten sichtbaren */
  483.     show_win(W_AKT);             /* machen, Fensterinhalt neu darstellen    */
  484.   }
  485.   setz_cursor(W_AKT);  /* Cursor an richtige Position */
  486. }
  487.  
  488. /*****************************************************************************
  489. *
  490. *  Funktion       Gehe an Zeilenende (do_eol)
  491. *  --------
  492. *
  493. *  Beschreibung : Der Cursor wird an das Zeilenende bewegt.
  494. *
  495. *****************************************************************************/
  496.  
  497. void do_eol()
  498. {
  499.   eol(); /* Cursor intern ans Zeilenende setzen */
  500.   /* Falls Cursorposition rechts vom Bildschirm oder */
  501.   if(akt_winp->ws_col + akt_winp->dx <= akt_winp->screencol
  502.   || akt_winp->ws_col > akt_winp->screencol) /* links vom Bildschirm */
  503.   { /* dann Position anpassen */
  504.     /* Falls screencol < dx, dann kann erste Spalte dargestellt werden. */
  505.     /* Sonst wird die aktuelle Spalte zur letzten sichtbaren Spalte. */
  506.     akt_winp->ws_col = (akt_winp->screencol < akt_winp->dx) ?
  507.     0 : akt_winp->screencol - akt_winp->dx + 1;
  508.     show_win(W_AKT); /* Fensterinhalt darstellen */
  509.   }
  510.   setz_cursor(W_AKT); /* Cursor an richtige Position setzen */
  511. }
  512.  
  513. /*****************************************************************************
  514. *
  515. *  Funktion       Gehe halbe Seite hoch (do_halfup)
  516. *  --------
  517. *
  518. *  Beschreibung : Der Cursor wird um eine halbe Seite nach oben bewegt.
  519. *
  520. *****************************************************************************/
  521.  
  522. void do_halfup()
  523. {
  524.   /* *** interne Daten *** */
  525.   register int hilf;   /* zum Einlesen einer Tastenkombination */
  526.  
  527.   nodelay (akt_winp->winp,TRUE); /* taste soll -1 liefern, falls keine */
  528.   do                             /* Taste gedrueckt ist. */
  529.     if((akt_winp->ws_line -= half_up()) < 0) /* Cursor hochbewegen und */
  530.       akt_winp->ws_line = 0; /* neuen Fensterstart berechnen */
  531.   while ((hilf=taste(akt_winp->winp)) == aktcode); /* Falls der gleiche */
  532.   /* Code noch mal im Puffer, ganze Aktion wiederholen */
  533.   lastcode = hilf;  /* Zuletzt gelesene Tastenkombination merken */
  534.   nodelay (akt_winp->winp,FALSE); /* Funktion taste soll auf Taste warten */
  535.   show_win(W_AKT);                 /* Text im Fenster neu anzeigen     */
  536.   setz_cursor(W_AKT);               /* Cursor an richtige Position setzen */
  537. }
  538.  
  539. /*****************************************************************************
  540. *
  541. *  Funktion       Gehe halbe Seite runter (do_halfdn)
  542. *  --------
  543. *
  544. *  Beschreibung : Der interne Cursor wird um eine halbe Seite nach unten bewegt.
  545. *                 Dann wird die Fensterposition angepasst und der
  546. *                 Fensterinhalt erneut dargestellt. Steht der Cursor in der
  547. *                 letzten Textzeile, so wird diese in die Bildschirmmitte
  548. *                 plaziert.
  549. *
  550. *****************************************************************************/
  551.  
  552. void do_halfdn()
  553. {
  554.   /* *** interne Daten *** */
  555.   register int hilf;   /* Zum Einlesen einer Tastenkombination */
  556.  
  557.   nodelay (akt_winp->winp,TRUE); /* taste soll -1 liefern, falls keine */
  558.   do                             /* Taste gedrueckt ist. */
  559.     akt_winp->ws_line += half_down(); /* Cursor und Fensterstart anpassen */
  560.   while ((hilf=taste(akt_winp->winp)) == aktcode); /* Falls noch mal der */
  561.   /* gleiche Code im Tastaturpuffer, Aktion wiederholen */
  562.   lastcode = hilf;   /* letzte Tastenkombination merken */
  563.   nodelay (akt_winp->winp,FALSE); /* Fkt. taste soll wieder auf Taste warten */
  564.   show_win(W_AKT);                  /* Text im Fenster neu anzeigen     */
  565.   setz_cursor(W_AKT);                /* Cursor an richtige Position setzen */
  566. }
  567.  
  568. /*****************************************************************************
  569. *
  570. *  Funktion       loesche aktuelles Zeichen (do_delete)
  571. *  --------
  572. *
  573. *  Beschreibung : Das unter dem Cursor stehende Zeichen wird geloescht.
  574. *
  575. *****************************************************************************/
  576.  
  577. void do_delete()
  578. {
  579.   if (is_last())    /* steht man am / hinterm Zeilenende ? */
  580.     do_join();
  581.   else
  582.     if (delete())   /* Zeichen, auf dem der Cursor steht loeschen */
  583.     {               /* klappt das, wird die aktuelle Zeile neu angezeigt */
  584.       lineout(akt_winp->textline-akt_winp->ws_line);
  585.       setz_cursor(W_AKT); /* und der Cursor an die richtige Position gesetzt */
  586.     }
  587. }
  588.  
  589. /*****************************************************************************
  590. *
  591. *  Funktion       loesche Zeichen links (do_backspace)
  592. *  --------
  593. *
  594. *  Beschreibung : Das links vom Cursor stehende Zeichen wird geloescht.
  595. *
  596. *****************************************************************************/
  597.  
  598. void do_backspace()
  599. {
  600.   if(backspace())  /* Das Zeichen links vom Cursor wird geloescht */
  601.   {                /* Klappt das, wird gecheckt, ob Cursor links vom Schirm */
  602.     if(akt_winp->screencol < akt_winp->ws_col)
  603.       text_right(); /* Falls ja, Text um eine Spalte nach rechts bewegen */
  604.     lineout(akt_winp->textline-akt_winp->ws_line); /* Zeile neu anzeigen */
  605.     setz_cursor(W_AKT); /* cursor an richtige Position setzen */
  606.   }
  607.   else /* es ging nicht nach links. Das ist sicher, da delete in backspace */
  608.   {    /* nur dann einen Fehler liefert, wenn Abschlußnull gelöscht werden */
  609.        /* soll, aber das kann hier nicht auftreten. */
  610.     if (akt_winp->textline > 0) /* geht es eine Zeile hoch ? */
  611.     {
  612.       do_up();
  613.       do_join();
  614.     }
  615.   }
  616. }
  617.  
  618. /*****************************************************************************
  619. *
  620. *  Funktion       Cursor an Bildschirmanfang (do_home)
  621. *  --------
  622. *
  623. *  Beschreibung : Der Cursor wird in die erste Zeile des Bildschirms
  624. *                 bewegt.
  625. *
  626. *****************************************************************************/
  627.  
  628. void do_home()
  629. {
  630.   gotox(akt_winp->ws_line); /* Cursor intern auf erste Bildschirmzeile setzen */
  631.   setz_cursor(W_AKT);            /* Cursor auf Bildschirm plazieren */
  632. }
  633.  
  634. /*****************************************************************************
  635. *
  636. *  Funktion       Cursor an Bildschirmmitte (do_middle)
  637. *  --------
  638. *
  639. *  Beschreibung : Der Cursor wird in die mittlere Zeile des Fensters
  640. *                 bewegt.
  641. *
  642. *****************************************************************************/
  643.  
  644. void do_middle()
  645. {
  646.   gotox(akt_winp->ws_line+akt_winp->dy/2); /* Cursor intern auf Mitte setzen */
  647.   setz_cursor(W_AKT);                      /* Cursor auf Bildschirm plazieren */
  648. }
  649.  
  650. /*****************************************************************************
  651. *
  652. *  Funktion       Cursor an Bildschirmende (do_nothome)
  653. *  --------
  654. *
  655. *  Beschreibung : Der Cursor wird in die letzte Zeile des Bildschirms
  656. *                 bewegt.
  657. *
  658. *****************************************************************************/
  659.  
  660. void do_nothome()
  661. {
  662.   gotox(akt_winp->ws_line + akt_winp->dy -1); /* Cursor in letzte Bild- */
  663.   setz_cursor(W_AKT); /* schirmzeile. Anschliessend Cursor auf Schirm plazieren */
  664. }
  665.  
  666. /*****************************************************************************
  667. *
  668. *  Funktion       Underlinemodus toggeln (do_underline)
  669. *  --------
  670. *
  671. *  Beschreibung : Die unterstrichene Schriftart wird aktiviert/deaktiviert.
  672. *
  673. *****************************************************************************/
  674.  
  675. void do_underline()
  676. {
  677.   akt_winp->underflag ^= TRUE;  /* Flag fuer Unterstreichung togglen */
  678.   setz_cursor(W_AKT);                /* Kopfzeile aktualisieren */
  679. }
  680.  
  681. /*****************************************************************************
  682. *
  683. *  Funktion       Schreibmodus toggeln (do_insovr)
  684. *  --------
  685. *
  686. *  Beschreibung : Der Schreibmodus wird invertiert.
  687. *
  688. *****************************************************************************/
  689.  
  690. void do_insovr()
  691. {
  692.   akt_winp->insflag ^= TRUE;    /* Insertflag togglen */
  693.   setz_cursor(W_AKT);                /* Kopfzeile aktualisieren */
  694. }
  695.  
  696. /*****************************************************************************
  697. *
  698. *  Funktion       Passende Klammer aufsuchen (do_matchpar)
  699. *  --------
  700. *
  701. *  Beschreibung : Es wird in der Umgebung nach einer öffnenden oder
  702. *                 schließenden Klammer gesucht (rund, eckig,
  703. *                 geschweift). Zu der gefundenen Klammer wird die
  704. *                 passende gesucht (bei öffnender wird vorwärts,
  705. *                 bei schließender rückwärts gesucht).
  706. *                 Wird eine passende Klammer gefunden, wird der
  707. *                 Cursor dorthin positioniert und der Bildschirm
  708. *                 angepaßt. Andernfalls bleibt der Cursor an seiner
  709. *                 aktuellen Position.
  710. *
  711. *****************************************************************************/
  712.  
  713. void do_matchpar()
  714. {
  715.   /* *** lokale Daten *** */
  716.   int  old_sc = akt_winp->screencol,  /* Spaltennummer beim Aufruf */
  717.        old_tl = akt_winp->textline;   /* Zeilennummer beim Aufruf  */
  718.  
  719.   if (find_next_par())  /* Klammer gefunden ? */
  720.   {
  721.     if (search_match_par ())
  722.       adapt_screen (1);             /* Falls Zeile der gefundenen Klammer */
  723.     else                            /* außerhalb des Bildschirms steht,   */
  724.     {                               /* anpassen.                          */
  725.       akt_winp->screencol = old_sc; /* Falls nicht gefunden, Cursor wieder*/
  726.       akt_winp->textline  = old_tl; /* an die Stelle von vor dem Aufruf   */
  727.       beep ();
  728.     }
  729.   }
  730.   else
  731.      beep();
  732. }
  733.