home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 5 Edit / 05-Edit.zip / ehp14cs.zip / window.c < prev   
Text File  |  1995-05-10  |  61KB  |  1,571 lines
  1. /****************************************************************/
  2. /*                                                              */
  3. /*      MODUL:  window.c                                        */
  4. /*                                                              */
  5. /*      FUNKTIONEN:                                             */
  6. /*              - adapt_screen (Bildschirm anpassen)            */
  7. /*              - init_win (Fenster-Standards setzen)           */
  8. /*              - print_hilf (Hilfstext in Statuszeile anzeigen)*/
  9. /*              - print_stat (Text in Statuszeile ausgeben)     */
  10. /*              - clear_stat (Statuszeile loeschen)             */
  11. /*              - read_stat (Text in Statuszeile einlesen)      */
  12. /*              - rahmen (Rahmen zeichnen)                      */
  13. /*              - kopf (Kopf in Window-Rahmen schreiben)        */
  14. /*              - open_window (Fenster oeffnen)                 */
  15. /*              - nfr_win (naechstfreie Windownummer ermitteln) */
  16. /*              - koppel_win (Neues Fenster in Liste haengen)   */
  17. /*              - gb_win_frei (Fensterlistenelement freigeben)  */
  18. /*              - pos_cursor (Cursor positionieren)             */
  19. /*              - setz_cursor (Cursor setzen mit kopf neu)      */
  20. /*              - sw_ohne_refresh (aktuelles Window anzeigen)   */
  21. /*              - show_win (Aktuelles Window zeigen und refrsh) */
  22. /*              - text_down (scrolle Window eine Zeile runter)  */
  23. /*              - text_up (scrolle Window eine Zeile hoch)      */
  24. /*              - text_right (Text um eine Position nach rechts)*/
  25. /*              - text_left (Text um eine Position nach links)  */
  26. /*              - fastcharout (Zeichen in Window ausgeben)      */
  27. /*              - lineout (aktuelle Zeile ausgeben)             */
  28. /*              - mal_und_merk (Ecken zeichnen und alte merken) */
  29. /*              - cpwins2stdscr (Fenster in stdscr kopieren)    */
  30. /*              - eckenhw (Ecken zeichnen bzw. loeschen)        */
  31. /*              - win_right (Fenster nach rechts bewegen)       */
  32. /*              - win_left (Fenster nach links bewegen)         */
  33. /*              - win_up (Fenster nach oben bewegen)            */
  34. /*              - win_down (Fenster nach unten bewegen)         */
  35. /*              - size_right (Fenster verbreitern)              */
  36. /*              - size_left (Fenster verschmaelern)             */
  37. /*              - size_up (Unteren Fensterrand nach oben)       */
  38. /*              - size_down (Unteren Fensterrand nach unten)    */
  39. /*              - toggle_size (Gespeicherte Groesse wird akt.)  */
  40. /*              - make_akt_win (Fenster zum aktuellen machen)   */
  41. /*              - sw_name (Fenster gemaess Name suchen)         */
  42. /*              - push_win_back (Fenster in Hintergrund)        */
  43. /*              - check_and_scroll_by_one (eine Z. scrollen)    */
  44. /****************************************************************/
  45.  
  46. #include "defs.h"
  47.  
  48. void clear_stat(), setz_cursor(int), show_win(int),
  49.      fastcharout(int,int,char*,int), lineout (int);
  50.  
  51. extern char *fastzeichen();
  52. extern char space;
  53. extern WINDOW *status;
  54. extern char helpflag,backupflag,highblockflag,def_aiflag,linebrkflag;
  55. extern int blockattr,in_block(),def_tab;
  56. extern short int *cur_to_poi();
  57.  
  58. /* *** globale Daten und Initialisierung *** */
  59. static int       statx=0;     /* Cursorpositioon X im Statusfenster */
  60. static short int anz_win = 0; /* Anzahl geoeffneter Fenster         */
  61.  
  62. /*****************************************************************************
  63. *
  64. *  Funktion       Bildschirm anpassen (adapt_screen)
  65. *  --------
  66. *
  67. *  Paramater    : blen     :
  68. *                   Typ         : int
  69. *                   Wertebereich: 0-MAXINT
  70. *                   Bedeutung   : Länge des rechts am Rand noch sichtbar
  71. *                                 zu machenden Bereichs
  72. *
  73. *  Ergebnis     :
  74. *                   Typ          : int
  75. *                   Wertebereich : TRUE, FALSE
  76. *                   Bedeutung    : TRUE: show_win wurde ausgeführt
  77. *                                  FALSE: kein show_win, nur setz_cursor
  78. *
  79. *  Beschreibung : ws_col und ws_line werden so angepasst, dass die aktuelle
  80. *                 Zeile nach Moeglichkeit in der Mitte des Bildschirms steht
  81. *                 und ein Begriff der Länge blen noch vor den rechten Rand
  82. *                 passt. Stand die aktuelle Zeile schon im Fenster, so wird
  83. *                 sie nicht in der Fenstermitte plaziert, sondern bleibt
  84. *                 an der aktuellen Position. Das Fenster wird mit show_win
  85. *                 neu angezeigt, falls ws_col/ws_line geändert wurden.
  86. *
  87. *****************************************************************************/
  88.  
  89. int adapt_screen(blen)
  90. int blen;
  91. {
  92.   /* *** interne Daten und Initialisierung *** */
  93.  
  94.   /* Steht der Cursor schon im Fenster und zwar mindestens blen   */
  95.   /* Zeichen vom rechten Rand entfernt, dann ist alles in Ordnung */
  96.   /* und es wird nur der Cursor an die richtige Position gesetzt  */
  97.   if (akt_winp->textline >= akt_winp->ws_line
  98.   && akt_winp->textline < akt_winp->ws_line+akt_winp->dy
  99.   && akt_winp->screencol >= akt_winp->ws_col
  100.   && akt_winp->screencol < akt_winp->ws_col+akt_winp->dx-blen)
  101.   {
  102.     setz_cursor(W_AKT);
  103.     return FALSE;
  104.   }
  105.  
  106.   else  /* Cursor nicht im Fenster oder zu weit rechts */
  107.   {
  108.     /* Cursorzeile in die Mitte setzen. Falls Zeilennummer zu klein, */
  109.     /* alles ab erste Zeile anzeigen */
  110.     if ((akt_winp->ws_line = akt_winp->textline - akt_winp->dy/2) < 0)
  111.       akt_winp->ws_line=0;
  112.     /* Fensterinhalt so weit wie moeglich nach rechts. Falls */
  113.     /* Spaltennummer zu klein, alles ab 1. Spalte anzeigen   */
  114.     if ((akt_winp->ws_col=akt_winp->screencol-akt_winp->dx+blen)<0)
  115.       akt_winp->ws_col = 0;
  116.     show_win(W_AKT); /* Fensterinhalt neu anzeigen */
  117.     return TRUE;
  118.   }
  119. }
  120.  
  121. /*****************************************************************************
  122. *
  123. *  Funktion       Fenster-Standards setzen (init_win)
  124. *  --------
  125. *
  126. *  Beschreibung : Fuer das aktuelle Fenster wird Scrolling verhindert
  127. *                 und der Fensterinhalt geloescht.
  128. *
  129. *****************************************************************************/
  130.  
  131. void init_win()
  132. {
  133.   scrollok(akt_winp->winp,FALSE); /* Nicht scrollen bei Zeilenumbruch */
  134.   werase (akt_winp->winp);        /* Fensterinhalt loeschen           */
  135. }
  136.  
  137. /*****************************************************************************
  138. *
  139. *  Funktion       Hilfstext in Statuszeile anzeigen (print_hilf)
  140. *  --------
  141. *
  142. *  Parameter    : txt       :
  143. *                   Typ          : char*
  144. *                   Wertebereich : Pointer auf ASCII-Zeichenkette
  145. *                   Bedeutung    : Auszugebender Text
  146. *
  147. *  Beschreibung : Der Text wird in der Statuszeile ausgegeben. Enthaelt er
  148. *                 ein in runde Klammern eingeschlossenes Zeichen, so wird
  149. *                 dieses Zeichen mit dem Attribut A_STANDOUT versehen.
  150. *
  151. *****************************************************************************/
  152.  
  153. void print_hilf(txt)
  154. register char *txt;
  155. {
  156.   /* *** interne Daten *** */
  157.   register short int c; /* auszugebendes Zeichen */
  158.  
  159.   clear_stat();   /* Statusfenster loeschen */
  160.   wmove(status,0,statx);
  161.   while (*txt)
  162.   {
  163.     if (*txt == '(' && txt[1] && txt[2] == ')')
  164.     { /* Zeichen in Klammern eingeschlossen, dann highlighten */
  165.       c = txt[1] | 256*A_STANDOUT;
  166.       txt+=3;
  167.     }
  168.     else  /* Sonst normal darstellen */
  169.       c = *txt++;
  170.     waddch(status,c);  /* Ins Statusfenster ausgeben */
  171.     statx++;
  172.   }
  173.   wrefresh(status);
  174. }
  175.  
  176. /*****************************************************************************
  177. *
  178. *  Funktion       text in statuszeile ausgeben (print_stat)
  179. *  --------
  180. *
  181. *  Parameter    : txt         :
  182. *                   Typ          : char *
  183. *                   Wertebereich : Pointer auf ASCII-Zeichenkette
  184. *                   Bedeutung    : auszugebender Text
  185. *
  186. *  Beschreibung : In dem Fenster status wird in Spalte statx txt
  187. *                 ausgegeben.  Die Variable statx wird um die Laenge des aus-
  188. *                 gegebenen Textes erhoeht.
  189. *
  190. *****************************************************************************/
  191.  
  192. void print_stat(txt)
  193. char *txt;
  194. {
  195.   mvwaddstr(status,0,statx,txt);
  196.   statx+=strlen(txt); /* Spaltenzaehler anpassen */
  197.   wrefresh(status);
  198. }
  199.  
  200. /*****************************************************************************
  201. *
  202. *  Funktion       Statuszeile loeschen (clear_stat)
  203. *  --------
  204. *
  205. *  Beschreibung : Das Fenster status wird geloescht und statx auf 0 gesetzt.
  206. *                 In der Statuszeile werden anschliessend die globalen Flags
  207. *                 angezeigt.
  208. *
  209. *****************************************************************************/
  210.  
  211. void clear_stat()
  212. {
  213.   if (statx) /* Nur wenn schon etwas drinsteht */
  214.   {
  215.     statx = 0;        /* Spaltenzaehler loeschen */
  216.     werase (status);
  217.     wrefresh(status);
  218.   }
  219. }
  220.  
  221.  
  222. /*****************************************************************************
  223. *
  224. *  Funktion       Text in Statuszeile einlesen (read_stat)
  225. *  --------
  226. *
  227. *  Parameter    : input         :
  228. *                   Typ          : char *
  229. *                   Wertebereich : Pointer auf Speicherbereich
  230. *                   Bedeutung    : Bereich, in dem eingegebener Text gespei-
  231. *                                  chert wird
  232. *                 len           :
  233. *                   Typ          : int
  234. *                   Wertebereich : 0 - MAXLENGTH
  235. *                   Bedeutung    : Anzahl einzulesender Zeichen
  236. *
  237. *                 typ           :
  238. *                   Typ          : int
  239. *                   Wertebereich : GS_NUM, GS_ANY
  240. *                   Bedeutung    : GS_NUM: nur Ziffern einlesen
  241. *                                  GS_ANY: alle Zeichen zulassen
  242. *
  243. *  Beschreibung : In der Statuszeile wird ein Text mit max. len Zeichen
  244. *                 Laenge eingelesen.
  245. *
  246. *****************************************************************************/
  247.  
  248. void read_stat(input,len,typ)
  249. char *input;
  250. int len,typ;
  251. {
  252.   newgetstr(status,0,statx,input,len,typ);
  253.   statx += strlen(input); /* Spaltenzaehler anpassen */
  254. }
  255.  
  256.  
  257. /*****************************************************************************
  258. *
  259. *  Funktion       rahmen zeichnen (rahmen)
  260. *  --------
  261. *
  262. *  Parameter    : modus         :
  263. *                   Typ          : int
  264. *                   Wertebereich : W_AKT, W_NOTAKT
  265. *                   Bedeutung    : Angabe, ob Fenster, für das der Rahmen
  266. *                                  gezeichnet werden soll, das aktuelle ist
  267. *                                  oder nicht
  268. *
  269. *  Beschreibung : In das aktuelle Fenster wird rechts und links ein Rand
  270. *                 gezeichnet.
  271. *
  272. *****************************************************************************/
  273.  
  274. void rahmen(modus)
  275. {
  276.   /* *** interne Daten und Initialisierung *** */
  277.   register int i,                 /* Schleifenzaehler    */
  278.            bx=akt_winp->dx+1, /* Breite des Fensters */
  279.            by=akt_winp->dy+1; /* Hoehe des Fensters  */
  280.  
  281.   if(akt_winp->next != akt_winp) /* Nur zeichnen, falls aktuelles Fenster */
  282.   {                              /* nicht das Dummy-Fenster ist. */
  283.     if(modus == W_AKT)
  284.       wstandout(akt_winp->winp); /* Falls aktuelles Fenster, dann highlighten */
  285.     else
  286.       wstandend(akt_winp->winp);
  287.     mvwaddch(akt_winp->winp,1,bx,'');
  288.     mvwaddch(akt_winp->winp,by-1,bx,'');
  289.     for(i=1;i<by;i++)
  290.     {
  291.       mvwaddch(akt_winp->winp,i,0,BORDER_VER);
  292.       mvwaddch(akt_winp->winp,i,bx,BORDER_VER);
  293.     }
  294.     mvwaddch(akt_winp->winp,1,bx,'');
  295.     mvwaddch(akt_winp->winp,by-1,bx,'');
  296.     if(modus == W_AKT)
  297.       wstandend(akt_winp->winp); /* Wurde gehighlightet, dann Highlighten wieder abschalten */
  298.   }
  299. }
  300.  
  301.  
  302. /*****************************************************************************
  303. *
  304. *  Funktion       Kopf in Window-Rahmen schreiben (kopf)
  305. *  --------
  306. *
  307. *  Parameter    : modus         :
  308. *                   Typ          : int
  309. *                   Wertebereich : W_AKT, W_NOTAKT
  310. *                   Bedeutung    : Angabe, ob Fenster, für das der Kopf
  311. *                                  gezeichnet werden soll, das aktuelle ist
  312. *                                  oder nicht
  313. *
  314. *  Beschreibung : In das aktuelle Fenster werden in die oberste (Rahmen) und
  315. *                 in die unterste Zeile Informationen geschrieben. Die Farbe,
  316. *                 in der das geschieht, hängt vom Modus des Fensters ab.
  317. *
  318. *****************************************************************************/
  319.  
  320. void kopf(modus)
  321. int modus;
  322. {
  323.   /* *** interne Daten und Initialisierung *** */
  324.   char         tbuff[BUFFSIZE];   /* Zum Zusammensetzen des Kopf-/Fusszeile */
  325.   register int i,                 /* Schleifenzaehler                       */
  326.            bx=akt_winp->dx+1, /* Fensterbreite                          */
  327.            by=akt_winp->dy+1; /* Fensterhoehe                           */
  328.   static char  kl_template [BUFFSIZE], /* Schablonen zum Erstellen der */
  329.            kf_template [BUFFSIZE], /* Kopf- und Fußzeilen          */
  330.            f_template  [BUFFSIZE],
  331.            init = FALSE;      /* gibt an, ob Schablonen initialisiert   */
  332.  
  333.   if (!init)
  334.   {
  335.     init = TRUE;
  336.     sprintf(kf_template,"%s %%5d%c%s %%5d%c%%s%c%%s%c%%s%c%%s%c%%s%c%%s",
  337.       PROMPT_LINE, BORDER_HOR, PROMPT_COLUMN, BORDER_HOR,
  338.       BORDER_HOR, BORDER_HOR, BORDER_HOR, BORDER_HOR, BORDER_HOR);
  339.     sprintf(kl_template,"%c%c%c%c %s %c%c%c%c%%s%c%%s%c%%s%c%%s%c%%s%c%%s",
  340.       BORDER_HOR, BORDER_HOR, BORDER_HOR, BORDER_HOR, PROMPT_WINDOWEMP,
  341.       BORDER_HOR, BORDER_HOR, BORDER_HOR, BORDER_HOR, 
  342.       BORDER_HOR, BORDER_HOR, BORDER_HOR, BORDER_HOR, BORDER_HOR);
  343.     sprintf(f_template,"%c%%d. %s %%s%c%c%%s%c%c%%s",
  344.       BORDER_HOR, PROMPT_WINDOW, BORDER_HOR, BORDER_HOR, BORDER_HOR, 
  345.       BORDER_HOR, BORDER_HOR, BORDER_HOR);
  346.   }
  347.  
  348.   if(akt_winp->next != akt_winp) /* Nur zeichnen, falls aktuelles Fenster */
  349.   {                              /* nicht das Dummy-Fenster ist. */
  350.     if(modus == W_AKT)
  351.       wstandout(akt_winp->winp); /* Bei aktuellen Fenster Rahmen highlighten */
  352.     else
  353.       wstandend(akt_winp->winp);
  354.     mvwaddch (akt_winp->winp,0,bx,''); /* rechte obere Ecke */
  355.     mvwaddch (akt_winp->winp,0,0,'');  /* linke obere Ecke  */
  356.     mvwaddch(akt_winp->winp,by,bx-1,''); /* rechte untere Ecke */
  357.     mvwaddch(akt_winp->winp,by,bx,'\\'); /* rechte untere Ecke */
  358.     mvwaddch(akt_winp->winp,by,0,CORNER_LL);  /* linke untere Ecke  */
  359.     mvwaddch(akt_winp->winp,by,1,'');  /* linke untere Ecke  */
  360.     if (akt_winp->maxline >= 0) /* Fenster nicht leer ? */
  361.       sprintf(tbuff,kf_template,
  362.       akt_winp->textline+1, akt_winp->screencol+1,
  363.       akt_winp->insflag?PROMPT_INSERT:PROMPT_OVERWRITE,
  364.       akt_winp->underflag?PROMPT_UNDERLINE:"",
  365.       akt_winp->autoindflag?"Indent":"",
  366.       akt_winp->shellflag?"SHELL":"",
  367.       akt_winp->tabflag?"Tabs":"Spcs",
  368.       akt_winp->linebreak?PROMPT_LINEBREAK:"");
  369.     else                        /* Fenster leer */
  370.       sprintf(tbuff,kl_template, akt_winp->insflag?PROMPT_INSERT:
  371.     PROMPT_OVERWRITE, akt_winp->underflag?PROMPT_UNDERLINE:"", 
  372.     akt_winp->autoindflag?"Indent":"",
  373.     akt_winp->shellflag?"SHELL":"", akt_winp->tabflag?"Tabs":"Spcs",
  374.     akt_winp->linebreak?PROMPT_LINEBREAK:"");
  375.     tbuff[akt_winp->dx] = '\0'; /* Zeile abschneiden, damit sie nicht ueber */
  376.                 /* den Rand hinausgeht. */
  377.     /* Zeile zentriert in erster Fensterzeile anzeigen */
  378.     mvwaddstr(akt_winp->winp,0,1+(akt_winp->dx - strlen(tbuff))/2,tbuff);
  379.     /* Rest des Rahmens in Kopfzeile */
  380.     for (i=1;i<1+(akt_winp->dx - strlen(tbuff))/2;i++)          
  381.       mvwaddch(akt_winp->winp,0,i,BORDER_HOR);
  382.     for (i=1+(akt_winp->dx - strlen(tbuff))/2+strlen(tbuff); i<bx;i++)
  383.       mvwaddch(akt_winp->winp,0,i,BORDER_HOR);
  384.  
  385.     /* Fusszeile zusammenbasteln */
  386.     sprintf(tbuff,f_template, akt_winp->wini, akt_winp->filename, 
  387.       akt_winp->read_only?PROMPT_WRTPROTCT:"",
  388.       akt_winp->changeflag?PROMPT_MODIFIED:"");
  389.     tbuff[akt_winp->dx-1]='\0'; /* s.o. */
  390.     mvwaddstr(akt_winp->winp,by,2,tbuff);
  391.     /* Rest des Rahmens in Fusszeile */
  392.     for(i=2+strlen(tbuff);i<bx-1;i++)           
  393.       waddch(akt_winp->winp,BORDER_HOR);
  394.     if(modus == W_AKT)
  395.       wstandend(akt_winp->winp); /* Falls Kopf gehighlightet wurde, Highlighten wieder aus */
  396.   }
  397. }
  398.  
  399. /*****************************************************************************
  400. *
  401. *  Funktion       Fenster oeffnen (open_window)
  402. *  --------
  403. *
  404. *  Beschreibung : Das aktuelle Fenster, fuer das schon Speicher alloziert
  405. *                 sein muss, wird initialisiert : Die (Block-)Koordinaten,
  406. *                 Cursorposition, Fensterstart und Fenstergroesse werden
  407. *                 gesetzt, das Fenster wird durch Curses angelegt, der Inhalt
  408. *                 geloescht und eingerahmt. Anschliessend wird der Kopf in
  409. *                 die oberste Zeile und die Fusszeile in die unterste Zeile
  410. *                 geschrieben.
  411. *
  412. *****************************************************************************/
  413.  
  414. void open_window()
  415. {
  416.   /* Fenster mit Curses anlegen */
  417.   akt_winp->winp = newwin(START_HEIGHT,START_WIDTH,START_Y,START_X);
  418.  
  419.   akt_winp->ws_line = 0; /* Ab erster Zeile anzeigen */
  420.   akt_winp->ws_col = 0;  /* Ab erster Spalte anzeigen */
  421.   akt_winp->ax = akt_winp->x = START_X; /* Fensterposition und */
  422.   akt_winp->ay = akt_winp->y = START_Y; /* alte Fensterposition setzen */
  423.   akt_winp->adx = akt_winp->dx = START_WIDTH-2;  /* Fenstergroesse und alte */
  424.   akt_winp->ady = akt_winp->dy = START_HEIGHT-2; /* Fenstergroesse setzen   */
  425.  
  426.   akt_winp->autoindflag = def_aiflag;
  427.   akt_winp->shellflag = FALSE; /* Default: kein Shellmodus,   */
  428.   akt_winp->underflag = FALSE; /* keine Unterstreichung       */ 
  429.   akt_winp->insflag = TRUE;    /* Insert-Mode                 */ 
  430.   akt_winp->tabflag = TRUE;    /* Blanks zu Tabs kompr.       */ 
  431.   akt_winp->tablen = def_tab;  /* Tablaenge setzen            */ 
  432.   akt_winp->linebreak = linebrkflag;
  433.  
  434.   akt_winp->lastline = akt_winp->lastcol = -1; /* letzte Position setzen */
  435.   akt_winp->block.e_line = akt_winp->block.s_line =  /* kein Block */
  436.   akt_winp->block.laenge = -1;
  437.   akt_winp->block.bstart = (bzeil_typ*) NULL;
  438.   init_win();  /* Curses-Defaults fuer Fenster setzen */
  439.   show_win(W_AKT);  /* Fensterinhalt anzeigen */
  440. }
  441.  
  442.  
  443. /*****************************************************************************
  444. *
  445. *  Funktion      naechstfreie Windownummer ermitteln (nfr_win)
  446. *  --------
  447. *
  448. *  Ergebnis     :
  449. *                   Typ          : int
  450. *                   Wertebereich : 0-maxint
  451. *                   Bedeutung    : 0 = keine Windownummern mehr frei
  452. *                                  1 - maxint = freie Windownummer
  453. *
  454. *  Beschreibung : Die Windowliste wird durchlaufen und nach noch nicht
  455. *                 vergebenen Nummern durchsucht.
  456. *
  457. *****************************************************************************/
  458.  
  459. int nfr_win()
  460. {
  461.   /* *** interne Daten *** */
  462.   register int     i=0; /* Laufende Fensternummer */
  463.   register win_typ *wp; /* Zeiger zum Durchlaufen der Fensterliste */
  464.  
  465.   while (++i)
  466.   {
  467.     wp = akt_winp->next->next; /* Erstes Element hinter dummy-Element */
  468.     while (wp != akt_winp->next && wp->wini != i)
  469.       wp = wp->next; /* Ganze Liste nach Nummer i absuchen */
  470.     if (wp == akt_winp->next)
  471.       return (i); /* Nummer nicht gefunden, also zurueckgeben */
  472.   }
  473.   return (0); /* 0 : Keine Fensternummer mehr frei */
  474. }
  475.  
  476.  
  477. /*****************************************************************************
  478. *
  479. *  Funktion       Fensterelement allozieren und in Liste koppeln (koppel_win)
  480. *  --------
  481. *
  482. *  Ergebnis     : Typ           : int
  483. *                 Wertebereich  : TRUE, FALSE
  484. *                 Bedeutung     : TRUE : Es gab noch freie Fensternummern
  485. *                                 FALSE : Keine Nummer mehr frei
  486. *
  487. *  Beschreibung : Fuer ein neues Element vom Typ win_typ wird Speicher allo-
  488. *                 ziert.  Das neue Element wird dann in die Windowliste hinter
  489. *                 akt_winp eingehaengt.  Das neue Fenster wird anschliessend
  490. *                 zum aktuellen Fenster.
  491. *                 Achtung: Es wird keine Initialisierung der Struktur
  492. *                 vorgenommen.
  493. *
  494. *****************************************************************************/
  495.  
  496. int koppel_win()
  497. {
  498.   /* *** interne Daten *** */
  499.   register win_typ *hilf;   /* Temp. Zeiger auf neues Fenster */
  500.   int              nfr_num; /* Nummer des neuen Fensters      */
  501.  
  502.   /* Testen, ob noch ein Fenster geoeffnet werden kann    */
  503.   /* Klappt nicht, falls keine Fensternummer mehr frei    */
  504.   if (nfr_num = nfr_win())
  505.   {
  506.     anz_win++; /* Ein Fenster mehr geoeffnet */
  507.     hilf = (win_typ*) reserve_mem (sizeof (win_typ));
  508.     hilf->winp = (WINDOW*) NULL; /* Damit z.B. print_err erkennt, daß */
  509.                  /* noch kein curses-Fenster zugeordnet ist */
  510.     hilf->next = akt_winp->next; /* Fenster hinter aktuellem */
  511.     hilf->prev = akt_winp; /* Fenster in Liste einhaengen    */
  512.     akt_winp->next = hilf;
  513.     hilf->next->prev = hilf;
  514.     hilf->wini = nfr_num; /* Naechste freie Windownummer einsetzen */
  515.     hilf->winp = NULL; /* Noch kein Curses-Fenster, wird von print_err erkannt */
  516.     akt_winp = hilf; /* Neues Fenster zum aktuellen machen */
  517.     return (TRUE);
  518.   }
  519.   else
  520.     return(FALSE);
  521. }
  522.  
  523.  
  524. /*****************************************************************************
  525. *
  526. *  Funktion       Fensterlistenelement freigeben  (gb_win_frei)
  527. *  --------
  528. *
  529. *  Beschreibung : Das Element wird aus der Liste herausgenommen und der dazu-
  530. *                 gehoerige Speicher freigegeben.
  531. *
  532. *****************************************************************************/
  533.  
  534. void gb_win_frei ()
  535. {
  536.   /* *** interne Daten *** */
  537.   register win_typ *hilf; /* Zeiger auf momentan aktuelles Fenster */
  538.  
  539.   if ((hilf = akt_winp)->next != hilf) /* Mind. ein Fenster ? */
  540.   {
  541.     anz_win--; /* Ein Fenster weniger geoeffnet */
  542.     line_free(hilf->filename); /* Filenamentext freigeben */
  543.     akt_winp = hilf->prev;     /* Vorgaenger zum aktuellen machen */
  544.     hilf->next->prev = akt_winp; /* Fenster aus Liste auskoppeln  */
  545.     akt_winp->next = hilf->next;
  546.     free (hilf); /* Speicherplatz fuer Fensterstruktur freigeben */
  547.   }
  548. }
  549.  
  550. /*****************************************************************************
  551. *
  552. *  Funktion       cursor positionieren (pos_cursor)
  553. *  --------
  554. *
  555. *  Beschreibung : Cursor wird im aktuellen Fenster an die durch
  556. *                 screencol und textline angegebene Position gesetzt.
  557. *                 Ist der Text leer, wird der Cursor in die erste
  558. *                 Zeile gesetzt.
  559. *
  560. *****************************************************************************/
  561.  
  562. void pos_cursor()
  563. {
  564.   wmove (akt_winp->winp,(akt_winp->maxline == -1)+ /* leer, dann 1 Z. weiter */
  565.      akt_winp->textline-akt_winp->ws_line+1,   /* runter */
  566.      akt_winp->screencol-akt_winp->ws_col+1);
  567.   wrefresh (akt_winp->winp);
  568. }
  569.  
  570. /*****************************************************************************
  571. *
  572. *  Funktion       cursor setzen (setz_cursor)
  573. *  --------
  574. *
  575. *  Parameter    : modus         :
  576. *                   Typ          : int
  577. *                   Wertebereich : W_AKT, W_NOTAKT
  578. *                   Bedeutung    : Angabe, ob Fenster das aktuelle ist und
  579. *                                  somit der Kopf gehighlightet werden soll
  580. *
  581. *  Beschreibung : Cursor wird im aktuellen Fenster an die durch
  582. *                 screencol und textline angegebene Position gesetzt.
  583. *                 Der Kopf wird aktualisiert und das window refresht.
  584. *
  585. *****************************************************************************/
  586.  
  587. void setz_cursor(modus)
  588. int modus;
  589. {
  590.   if(akt_winp->next != akt_winp) /* Nur, wenn ein Fenster offen */
  591.   {
  592.     kopf(modus);  /* Kopf- und Fusszeile anzeigen */
  593.     pos_cursor(); /* Cursor positionieren */
  594.   }
  595. }
  596.  
  597. /*****************************************************************************
  598. *
  599. *  Funktion       Aktuelles Window anzeigen (sw_ohne_refresh)
  600. *  --------
  601. *
  602. *  Parameter    : modus         :
  603. *                   Typ          : int
  604. *                   Wertebereich : W_AKT, W_NOTAKT
  605. *                   Bedeutung    : Angabe, ob Fenster das aktuelle ist und
  606. *                                  somit der Rahmen gehighlightet werden soll
  607. *
  608. *  Beschreibung : Mit der Zeile akt_winp->ws_line beginnend werden
  609. *                 akt_winp->dy Zeilen in dem aktuellen Fenster, bei der
  610. *                 obersten Zeile beginnend, ausgegeben.
  611. *                 Gibt es keine weiteren Textzeilen, so wird der Rest
  612. *                 des Fenster geloescht
  613. *
  614. *****************************************************************************/
  615.  
  616. void sw_ohne_refresh(modus)
  617. int modus;
  618. {
  619.   /* *** interne Daten und Initialisierung *** */
  620.   zeil_typ     *alte_zeile = akt_winp->alinep;   /* Zeiger auf Cursorzeile  */
  621.   register int i,                                /* Zaehler fuer Zeilen     */
  622.            alte_nummer = akt_winp->textline; /* Zeiger auf Zeilennummer */
  623.  
  624.   gotox(akt_winp->ws_line); /* erste anzuzeigende Zeile anspringen */
  625.  
  626.   for(i=0;i<akt_winp->dy;i++)
  627.   {
  628.     lineout(i);    /* Zeile ausgeben */
  629.     if(!down())    /* eine Zeile runter */
  630.     {              /* geht das nicht, dann Rest des Bildschirms loeschen */
  631.       wmove (akt_winp->winp, i+2, 1);
  632.       wclrtobot(akt_winp->winp);
  633.       break;
  634.     }
  635.   }
  636.   rahmen(modus); /* Rahmen anzeigen */
  637.   akt_winp->alinep = alte_zeile;    /* Cursorzeile restaurieren */
  638.   akt_winp->textline = alte_nummer;
  639. }
  640.  
  641.  
  642. /*****************************************************************************
  643. *
  644. *  Funktion       Aktuelles Window anzeigen und refreshen (show_win)
  645. *  --------
  646. *
  647. *  Parameter    : modus         :
  648. *                   Typ          : int
  649. *                   Wertebereich : W_AKT, W_NOTAKT
  650. *                   Bedeutung    : Angabe, ob Fenster das aktuelle ist und
  651. *                                  somit der Rahmen gehighlightet werden soll
  652. *
  653. *  Beschreibung : Mit der Zeile akt_winp->ws_line beginnend werden
  654. *                 akt_winp->dy Zeilen in dem aktuellen Fenster, bei der
  655. *                 obersten Zeile beginnend, ausgegeben.
  656. *                 Gibt es keine weiteren Textzeilen, so wird der Rest
  657. *                 des Fenster geloescht
  658. *
  659. *****************************************************************************/
  660.  
  661. void show_win(modus)
  662. int modus;
  663. {
  664.   sw_ohne_refresh(modus);            /* Fensterinhalt anzeigen */
  665.   setz_cursor(modus);                /* setz_cursor ruft refresh auf */
  666. }
  667.  
  668. /*****************************************************************************
  669. *
  670. *  Funktion       scrolle window um eine zeile nach unten (text_down)
  671. *  --------
  672. *
  673. *  Parameter    : line         :
  674. *                   Typ          : int
  675. *                   Wertebereich : 0 - akt_winp->dy-1
  676. *                   Bedeutung    : Einzufuegende Zeile im Fenster
  677. *
  678. *  Beschreibung : Es wird in der <line>ten Zeile eine Zeile im Fenster ein-
  679. *                 gefuegt. Falls die <line>te Bildschirmzeile exisitert, wird
  680. *                 sie in dieser Zeile angezeigt.
  681. *                 ws_line wird _a_u_f_ _k_e_i_n_e_n_ _F_a_l_l angepasst.
  682. *
  683. *****************************************************************************/
  684.  
  685. void text_down(line)
  686. int line;
  687. {
  688.   /* *** interne Daten *** */
  689.   zeil_typ  *alte_zeile; /* Zwischenspeicher Zeiger auf Cursorzeile */
  690.   int       alte_nummer; /* Zwischenspeicher fuer Zeilennummer      */
  691.   short int rc;          /* Zeichen zum Rahmenrestaurieren          */
  692.  
  693.   if(line == 0)
  694.     rc = REST_ARR_UP;
  695.   else
  696.     if(line == akt_winp->dy-1)
  697.       rc = REST_ARR_DN;
  698.     else
  699.       rc = REST_CHAR;
  700.   wmove(akt_winp->winp,line+1,1); /* Cursor auf uebergebene Zeile stellen */
  701.   winsertln(akt_winp->winp);      /* Eine Zeile im Fenster einfuegen */
  702.  
  703.   if (akt_winp->ws_line+line <= akt_winp->maxline)
  704.   { /* Wenn gewuenschte Zeile existiert: */
  705.     alte_zeile = akt_winp->alinep;    /* aktuelle Zeile merken */
  706.     alte_nummer = akt_winp->textline;
  707.     gotox(akt_winp->ws_line+line);    /* gewuenschte Zeile anspringen */
  708.     lineout(line);                          /* output current line */
  709.     akt_winp->alinep = alte_zeile;    /* Zeilenzeiger restaurieren */
  710.     akt_winp->textline = alte_nummer;
  711.   }
  712.   mvwaddch(akt_winp->winp,line+1,0,REST_CHAR); /* Rahmen reparieren, da durch   */
  713.   mvwaddch(akt_winp->winp,line+1,akt_winp->dx+1,rc); /* insertln korrupt */
  714.   if(line != akt_winp->dy-1) /* Falls nicht in letzter Zeile eingefügt, */
  715.     mvwaddch(akt_winp->winp,akt_winp->dy,akt_winp->dx+1,REST_ARR_DN);
  716.   if(akt_winp->dy > 2) /* Falls Fenster mehr als 1 Zeile hat, gescrollten */
  717.     /* Pfeil durch Rahmenzeichen ersetzen. */
  718.     mvwaddch(akt_winp->winp,2,akt_winp->dx+1,REST_CHAR);
  719. }
  720.  
  721. /*****************************************************************************
  722. *
  723. *  Funktion       scrolle Windowinhalt um eine Zeile nach oben (text_up)
  724. *  --------
  725. *
  726. *  Parameter    : line         :
  727. *                   Typ          : int
  728. *                   Wertebereich : 0 - akt_winp_dy-1
  729. *                   Bedeutung    : Zu loeschende Zeile im Fenster
  730. *
  731. *  Beschreibung : Falls dadurch das Fenster nicht leer wuerde, wird die
  732. *                 <line>te Textzeile des Windows geloescht, so dass
  733. *                 die letzte Zeile frei wird.  In dieser wird die neue
  734. *                 letzte Zeile angezeigt.
  735. *
  736. *****************************************************************************/
  737.  
  738. void text_up(line)
  739. int line;
  740. {
  741.   /* *** interne Daten *** */
  742.   zeil_typ *alte_zeile; /* Zwischenspeicher Zeiger auf Cursorzeile */
  743.   int      alte_nummer; /* Zwischenspeicher fuer Zeilennummer      */
  744.  
  745.   if(line || akt_winp->ws_line <= akt_winp->maxline)
  746.   {
  747.     wmove(akt_winp->winp,line+1,1); /* Cursor in gewuenschte Zeile */
  748.     wdeleteln(akt_winp->winp);      /* Zeile im Fenster loeschen   */
  749.     alte_zeile = akt_winp->alinep;  /* Cursorzeile merken          */
  750.     alte_nummer = akt_winp->textline;
  751.     gotox(akt_winp->ws_line+akt_winp->dy - 1); /* Zur <line>ten Zeile */
  752.     /* Falls die letzte Fensterzeile nicht existiert, Zeilenzeiger */
  753.     /* auf dummy-Element setzen, da dessen Text-Pointer NULL ist.  */
  754.     if(akt_winp->textline != akt_winp->ws_line + akt_winp->dy - 1)
  755.       akt_winp->alinep = akt_winp->dummyp;
  756.     lineout(akt_winp->dy - 1);   /* output current line */
  757.     akt_winp->alinep = alte_zeile;    /* Cursorzeile restaurieren */
  758.     akt_winp->textline = alte_nummer;
  759.     mvwaddch(akt_winp->winp,akt_winp->dy,0,REST_CHAR); /* Rahmen reparieren */
  760.     mvwaddch(akt_winp->winp,akt_winp->dy,akt_winp->dx+1,REST_ARR_DN);
  761.     mvwaddch(akt_winp->winp,1,akt_winp->dx+1,REST_ARR_UP);
  762.     if(akt_winp->dy > 2) /* Falls Fenster mehr als 1 Zeile hat, gescrollten */
  763.       /* Pfeil durch Rahmenzeichen ersetzen. */
  764.       mvwaddch(akt_winp->winp,akt_winp->dy-1,akt_winp->dx+1,REST_CHAR);
  765.   }
  766. }
  767.  
  768. /*****************************************************************************
  769. *
  770. *  Funktion       Text um eine Position nach rechts (text_right)
  771. *  --------
  772. *
  773. *  Beschreibung : alinep wird auf die erste Zeile im Fenster gesetzt.
  774. *                 Dann wird vor jede Zeile ein neuer Character eingefuegt.
  775. *                 Dadurch verschiebt sich der Restliche Text im Fenster
  776. *                 um eine Position nach rechts, wobei das am weitesten
  777. *                 rechts stehende Zeichen "aus dem Fenster faellt".
  778. *
  779. *****************************************************************************/
  780.  
  781. void text_right()
  782. {
  783.   /* *** interne Daten *** */
  784.   zeil_typ     *alte_zeile; /* Zwischenspeicher Zeiger auf Cursorzeile */
  785.   register int i,           /* Zaehler fuer Bildschirmzeile            */
  786.            alte_nummer; /* Zwischenspeicher fuer Zeilennummer      */
  787.  
  788.   if (akt_winp->ws_col > 0) /* Nur, wenn man noch scrollen kann */
  789.   {
  790.     check_buff(); /* evtl. Pufferinhalt in Text kopieren */
  791.     alte_zeile = akt_winp->alinep;    /* Cursorzeile merken */
  792.     alte_nummer = akt_winp->textline;
  793.     akt_winp->ws_col--; /* Nummer der ersten sichtbaren Spalte reduzieren */
  794.     gotox (akt_winp->ws_line); /* Zur ersten sichtbaren Zeile springen */
  795.     for (i=0;i<akt_winp->dy && akt_winp->ws_line+i <= akt_winp->maxline;i++)
  796.     { /* Von allen sichbaren Zeilen das erste sichtbare Zeichen einfuegen */
  797.       fastcharout(i,0,fastzeichen(akt_winp->ws_col),INSERT);
  798.       down(); /* Zur naechsten Zeile gehen */
  799.     }
  800.     akt_winp->alinep = alte_zeile;    /* Cursorzeile restaurieren */
  801.     akt_winp->textline = alte_nummer;
  802.   }
  803. }
  804.  
  805.  
  806. /*****************************************************************************
  807. *
  808. *  Funktion       scrolle Windowinhalt um eine Position nach links (text_left)
  809. *  --------
  810. *
  811. *  Beschreibung : Der Windowinhalt wird um eine Position nach links gescrollt,
  812. *                 so dass rechts neue Zeichen angezeigt werden muessen.
  813. *
  814. *****************************************************************************/
  815.  
  816. void text_left()
  817. {
  818.   /* *** interne Daten *** */
  819.   zeil_typ     *alte_zeile; /* Zwischenspeicher Zeiger auf Cursorzeile */
  820.   register int i,           /* Zaehler fuer Bildschirmzeile            */
  821.            alte_nummer; /* Zwischenspeicher fuer Zeilennummer      */
  822.   short int    rc;          /* Zeichen zum Reparieren des Rahmens      */
  823.  
  824.   if(akt_winp->ws_col < MAXLENGTH)      /* dann nichts mehr auf dem Schirm */
  825.   {
  826.     alte_zeile = akt_winp->alinep;    /* Cursorzeile merken */
  827.     alte_nummer = akt_winp->textline;
  828.     akt_winp->ws_col++; /* Nummer der ersten sichtbaren Spalte erhoehen */
  829.     gotox(akt_winp->ws_line); /* erste sichtbare Zeile anspringen */
  830.     for (i=0;i<akt_winp->dy && akt_winp->ws_line+i-1 < akt_winp->maxline;i++)
  831.     { /* In allen Fensterzeilen erstes Zeichen loeschen */
  832.       mvwdelch(akt_winp->winp,i+1,1);
  833.       fastcharout(i,akt_winp->dx - 1, /* Zeichen in letzer Spalte anzeigen */
  834.           fastzeichen(akt_winp->ws_col + akt_winp->dx-1),PUT);
  835.       if(i == 0)
  836.       rc = REST_ARR_UP;
  837.     else
  838.       if(i == akt_winp->dy-1)
  839.         rc = REST_ARR_DN;
  840.       else
  841.         rc = REST_CHAR;
  842.       mvwaddch(akt_winp->winp,i+1,akt_winp->dx+1,rc);
  843.       down(); /* Rahmen reparieren und zur naechsten Zeile gehen */
  844.     }
  845.     akt_winp->alinep = alte_zeile;    /* Cursorzeile restaurieren */
  846.     akt_winp->textline = alte_nummer;
  847.   }
  848. }
  849.  
  850. /******************************************************************************
  851. *
  852. * Funktion     : Attribute zum Zeichen hinzufügen (add_attrs)
  853. * --------------
  854. *
  855. * Parameter    : ib          :
  856. *                  Typ          : int
  857. *                  Wertebereich : Siehe Ergebnis von in_block
  858. *                  Bedeutung    : Angabe, ob das Zeichen im Block liegt
  859. *
  860. *              : s           :
  861. *                  Typ          : char *
  862. *                  Wertebereich : Zeiger aus ASCII-Zeichenkette
  863. *                  Bedeutung    : Zeiger auf auszugebendes Zeichen
  864. *
  865. * Ergebnis     :
  866. *                  Typ          : short int
  867. *                  Wertebereich : 0-MAXINT
  868. *                  Bedeutung    : Zeichen mit gesetzten Attributen
  869. *
  870. * Beschreibung : Zeigt s auf ein unterstrichenes Zeichen, so wird das
  871. *                Attribut für Unterstreichung zum Ergebnis hinzugeodert.
  872. *                Handelt es sich um einen Controlcode, so wird das Attribut
  873. *                für Invertierung dazugesetzt. Liegt das Zeichen an einer
  874. *                Position, die sich im Block befindet, und sollen Blöcke
  875. *                hervorgehoben werden, dann wird das Blockhighlight-Attribut
  876. *                dazugeodert.
  877. *                Wurde kein Attribut hinzugefügt, so wird das Standardattribut
  878. *                dazugeodert.
  879. *
  880. ******************************************************************************/
  881.  
  882. short int add_attrs(ib,s)
  883. int ib;
  884. char *s;
  885. {
  886.   unsigned short int c;  /* Zur Aufbereitung des Rückgabewertes */
  887.   unsigned int vf, /* Vordergrundfarbe */
  888.            hf; /* Hintergundfarbe */
  889.  
  890.   if(*s == '_' && s[1] == '' && s[2]) /* unterstrichenes Zeichen? */
  891.     c = s[2] | (256*A_UNDERLINE);
  892.   else
  893.     c = *s;
  894.  
  895.   /* Wenn Zeichen im Block, dann highlighten */
  896.   if(highblockflag && ib & B_IN_BLOCK)
  897.     c |= 256*blockattr;   /* Controlcodes werden wieder normal dargestellt */
  898. #ifdef OWN_CURSES
  899.   if(!(c >> 8)) /* Keine Attribute dazugeodert ? */
  900.     c |= 256*STD_ATTR; /* Dann Standardattribut hinzufügen */
  901. #endif
  902.  
  903.   if((c & 255) < 28) /* Controlcodes invertieren */
  904.   {
  905.     vf = c & 3840;  /* Vordergundfarbe ist c & (256*15) */
  906.     hf = c & 61440; /* Hintergrundfarbe ist c & (256*240) */
  907.     /* Vorder- und Hintergrund vertauschen  und 'A' zum Zeichen addieren */
  908.     c = (c & 255) | (vf<<4) | (hf>>4) + 64;
  909.   }
  910.   return (c);
  911. }
  912.  
  913. /*****************************************************************************
  914. *
  915. *  Funktion       Zeichen in window ausgeben (fastcharout)
  916. *  --------
  917. *
  918. *  Parameter:     y         :
  919. *                   Typ          : int
  920. *                   Wertebereich : 0 - Fensterhoehe-1
  921. *                   Bedeutung    : Zeile des Fensters, in dem das Zeichen
  922. *                                  ausgegeben werden soll
  923. *
  924. *                 x         :
  925. *                   Typ          : int
  926. *                   Wertebereich : 0 - Fensterbreite-1
  927. *                   Bedeutung    : Spalte des Fensters, in der das Zeichen
  928. *                                  ausgegeben werden soll
  929. *
  930. *                 s         :
  931. *                   Typ          : char*
  932. *                   Wertebereich : Pointer auf ASCII-Zeichen
  933. *                   Bedeutung    : auszugebendes Zeichen (s. fastzeichen())
  934. *
  935. *                 mode      :
  936. *                   Typ          : int
  937. *                   Wertebereich : INSERT,PUT
  938. *                   Bedeutung    : Gibt an, ob das Zeichen eingefuegt oder ob
  939. *                                  es an die betreffende Stelle kopiert werden
  940. *                                  soll
  941. *
  942. *  Beschreibung : Ist das Zeichen ein unterstrichenes Zeichen, so wird es
  943. *                 unterstrichen ausgegeben; ist der ASCII-Code des Zeichens
  944. *                 kleiner als 28, so wird der Zeichencode um 64 erhoeht und
  945. *                 das Zeichen invers ausgegeben.
  946. *                 Bei den Positionen wird der Rahmen beruecksichtigt, er kann
  947. *                 jedoch im Modus INSERT beschaedigt werden.
  948. *
  949. *****************************************************************************/
  950.  
  951. void fastcharout(y,x,s,mode)
  952. int y,x,mode;
  953. char *s;
  954. {
  955.   /* *** interne Daten und Initialisierung *** */
  956.   register short int c=0; /* Auszugebendes Zeichen     */
  957.   int                ib;  /* Flag, ob Zeichen im Block */
  958.   short int          rc;  /* Zeichen zum Restaurieren des Rahmens */
  959.  
  960.   ib = in_block(y+akt_winp->ws_line,x+akt_winp->ws_col);
  961.   c = add_attrs(ib,s); /* Attribute korrekt setzen */
  962.  
  963.   if(mode & INSERT)
  964.   {
  965.     if(highblockflag && (ib & B_LINE) && !(ib & B_RIGHT)) /* Falls Zeichen in */
  966.     /* einer Blockzeile vor oder im Block muss ganze Zeile neu gezeichnet     */
  967.       lineout(y);         /* werden, da sich die Markierungen verschieben     */
  968.     /* lineout ruft zwar fastcharout auf, jedoch mit dem Modus PUT, also      */
  969.     /* keine Endlos-Rekursion */
  970.     else  /* Wenn Zeichen nicht im Block, dann einfuegen und */
  971.     {     /* Rahmen reparieren */
  972.       if(y == 0)
  973.     rc = REST_ARR_UP;
  974.       else
  975.     if(y == akt_winp->dy-1)
  976.       rc = REST_ARR_DN;
  977.     else
  978.       rc = REST_CHAR;
  979.       mvwinsch(akt_winp->winp,y+1,x+1,c);
  980.       mvwaddch(akt_winp->winp,y+1,akt_winp->dx+1,rc);
  981.     }
  982.   }
  983.   else   /* Bei Modus PUT einfach anzeigen */
  984.     mvwaddch(akt_winp->winp,y+1,x+1,c);
  985. }
  986.  
  987. /*****************************************************************************
  988. *
  989. *  Funktion       aktuelle zeile ausgeben (lineout)
  990. *  --------
  991. *
  992. *  Parameter    : y         :
  993. *                   Typ          : int
  994. *                   Wertebereich : 0 - akt_winp->dy-1
  995. *                   Bedeutung    : Fensterzeile in der Text ausgegeben werden
  996. *                                  soll (Rahmen wird beruecksichtigt)
  997. *
  998. *  Beschreibung : Die aktuelle Zeile wird in dem aktuellen Fenster in Zeile
  999. *                 y ausgegeben. Hat die Zeile weniger Zeichen als das Window
  1000. *                 breit ist, so wird der Rest der Zeile geloescht.
  1001. *                 Dies geschieht, wenn fastzeichen einen Zeiger auf space
  1002. *                 zurueckliefert.
  1003. *                 Die Zeichen werden unmittelbar ins Window-Image geschrieben,
  1004. *                 wodurch erst ein Refresh die gewollten Ergebnisse
  1005. *                 liefert (zu bedenken bei Portierung!)
  1006. *                 Die anschließende Position des Cursors ist nicht definiert.
  1007. *
  1008. *****************************************************************************/
  1009.  
  1010. #ifdef CUR_DIRECT
  1011. void lineout(y)
  1012. int y;
  1013. {
  1014.   /* *** interne Daten *** */
  1015.   int           col;    /* aktuelle Fensterspalte */
  1016.   register char *s,     /* auszugebendes Zeichen  */
  1017.         *zeile; /* Aktuelles Zeichen      */
  1018.   unsigned short int *scr,   /* Puffer für anzuzeigende Zeichen */
  1019.          *scr_p,     /* Zeiger in scr */
  1020.          *scr_image, /* Zeiger ins Screen-image des Fensters */
  1021.          rc;         /* Zeichen zum Reparieren des Rahmens */
  1022.  
  1023.   /* Platz für 1 Zeile plus Rahmenzeichen besorgen */
  1024.   scr_p = scr = (short int *) malloc (sizeof (short int)*(akt_winp->dx+1));
  1025.   wmove (akt_winp->winp, y+1, 1);
  1026.   scr_image = cur_to_poi (akt_winp->winp);
  1027.   check_buff(); /* evtl. Pufferinhalt in Text uebertragen */
  1028.   zeile = fastzeichen(akt_winp->ws_col); /* Zeiger auf erstes sichtb. Z. holen */
  1029.  
  1030.   /* Solange nicht alle Bildschirmspalten angezeigt wurden oder */
  1031.   /* die anzuzeigende Zeile zu Ende ist. */
  1032.   for(s = zeile, col=0;(col < akt_winp->dx) && (s!= &space);col++)
  1033.     if (!*zeile)  /* Zeilenende ? */
  1034.     {
  1035.       s = &space; /* Dann s auf globales Space setzen */
  1036.       col--; /* Obwohl kein Zeichen ausgegeben wurde, wird col erhoeht. */
  1037.     }        /* Also muss col hier dekrementiert werden.                */
  1038.     else     /* Kein Zeilenende */
  1039.     {
  1040.       /* Testen, ob zeile nicht hinter oder vor Zeile zeigt und ob */
  1041.       /* aktuelles Zeichen unterstrichen ist. */
  1042.       if(((s = zeile) != &space)
  1043.       && *zeile++ == '_' && *zeile == '' && zeile[1])
  1044.     zeile+=2; /* Unterstrichen, dann zeile um 2 weitere Pos. erhoehen */
  1045.       /* Jetzt mit der Funktion add_attrs die erforderlichen Attribute */
  1046.       /* hinzufügen und das Zeichen anzeigen                           */
  1047.       *scr_image++ =
  1048.       *scr_p++ = add_attrs(in_block(y+akt_winp->ws_line,col+akt_winp->ws_col),s);
  1049.     }
  1050.  
  1051.   if(col < akt_winp->dx)
  1052.   /* Wenn noch nicht am Fensterrand, dann Rest der Zeile loeschen */
  1053.     for (; col<akt_winp->dx; col++)
  1054.       *scr_image++ = *scr_p++ = 256*STD_ATTR;
  1055.  
  1056.   /* Jetzt Rahmen restaurieren */
  1057.   if(y == 0)
  1058.       *scr_image++ = *scr_p++ = REST_ARR_UP;
  1059.     else
  1060.       if(y == akt_winp->dy-1)
  1061.     *scr_image++ = *scr_p++ = REST_ARR_DN;
  1062.       else
  1063.     *scr_image++ = *scr_p++ = REST_CHAR;
  1064.  
  1065.   /* Jetzt den zusammengesetzten String ausgeben */
  1066.   VioWrtCellStr (scr, sizeof(short int) * (akt_winp->dx+1),
  1067.          akt_winp->winp->_start_y+y+1,
  1068.          akt_winp->winp->_start_x+1, 0);
  1069.   free (scr);
  1070. }
  1071.  
  1072. #else
  1073.  
  1074. void lineout(y)
  1075. int y;
  1076. {
  1077.   /* *** interne Daten *** */
  1078.   int           col;    /* aktuelle Fensterspalte */
  1079.   register char *s,     /* auszugebendes Zeichen  */
  1080.         *zeile; /* Aktuelles Zeichen      */
  1081.   unsigned short int *scr,   /* Zeiger in Fenster      */
  1082.          rc;         /* Zeichen zum Reparieren des Rahmens */
  1083.  
  1084.   check_buff(); /* evtl. Pufferinhalt in Text uebertragen */
  1085.   zeile = fastzeichen(akt_winp->ws_col); /* Zeiger auf erstes sichtb. Z. holen */
  1086.   wmove(akt_winp->winp,y+1,1); /* Cursor zum Zeilenanfang bewegen */
  1087.  
  1088.   /* Solange nicht alle Bildschirmspalten angezeigt wurden oder */
  1089.   /* die anzuzeigende Zeile zu Ende ist. */
  1090.   for(s = zeile, col=0;(col < akt_winp->dx) && (s!= &space);col++)
  1091.     if (!*zeile)  /* Zeilenende ? */
  1092.     {
  1093.       s = &space; /* Dann s auf globales Space setzen */
  1094.       col--; /* Obwohl kein Zeichen ausgegeben wurde, wird col erhoeht. */
  1095.     }        /* Also muss col hier dekrementiert werden.                */
  1096.     else     /* Kein Zeilenende */
  1097.     {
  1098.       /* Testen, ob zeile nicht hinter oder vor Zeile zeigt und ob */
  1099.       /* aktuelles Zeichen unterstrichen ist. */
  1100.       if(((s = zeile) != &space)
  1101.       && *zeile++ == '_' && *zeile == '' && zeile[1])
  1102.     zeile+=2; /* Unterstrichen, dann zeile um 2 weitere Pos. erhoehen */
  1103.       /* Jetzt mit der Funktion add_attrs die erforderlichen Attribute */
  1104.       /* hinzufügen und das Zeichen anzeigen                           */
  1105.       waddch (akt_winp->winp, 
  1106.           add_attrs(in_block(y+akt_winp->ws_line,col+akt_winp->ws_col),s));
  1107.     }
  1108.  
  1109.   if(col < akt_winp->dx)
  1110.   { /* Wenn noch nicht am Fensterrand, dann Rest der Zeile loeschen */
  1111.     wmove(akt_winp->winp,y+1,col+1);
  1112.     wclrtoeol(akt_winp->winp);
  1113.   }
  1114.   if(y == 0)
  1115.       rc = REST_ARR_UP;
  1116.     else
  1117.       if(y == akt_winp->dy-1)
  1118.     rc = REST_ARR_DN;
  1119.       else
  1120.     rc = REST_CHAR;
  1121.   mvwaddch(akt_winp->winp,y+1,akt_winp->dx+1,rc); /* Rahmen reparieren */
  1122. }
  1123. #endif
  1124.  
  1125. /*****************************************************************************
  1126. *
  1127. *  Funktion       Ecken zeichnen und alte Zeichen merken (mal_und_merk)
  1128. *  --------
  1129. *
  1130. *  Parameter    : y         :
  1131. *                   Typ          : int
  1132. *                   Wertebereich : 0 - LINES-2
  1133. *                   Bedeutung    : Zeile,in der Ecke erscheinen soll
  1134. *
  1135. *                 x         :
  1136. *                   Typ          : int
  1137. *                   Wertebereich : 0 - COLS-1
  1138. *                   Bedeutung    : Spalte, in der Ecke erscheinen soll
  1139. *
  1140. *                 num       :
  1141. *                   Typ          : int
  1142. *                   Wertebereich : 0-3
  1143. *                   Bedeutung    : Nummer der Ecke
  1144. *
  1145. *  Beschreibung : Die Funktion merkt sich die Zeichen, die da stehen, wo die
  1146. *                 Ecken erscheinen sollen. Dann werden diese Zeichen durch
  1147. *                 die alten gemerkten Zeichen (anfangs '+') ersetzt.
  1148. *
  1149. *****************************************************************************/
  1150.  
  1151. void mal_und_merk(y,x,num)
  1152. int y,x,num;
  1153. {
  1154.   /* *** interne Daten und Initialisierung *** */
  1155.   static short int alt_zeich [4] = {'+','+','+','+'}; /* alte Zeichen */
  1156.   short int        hilf;   /* Zwischenspeicher fuer gelesenes Zeichen */
  1157.  
  1158.   hilf = mvinch (y,x);  /* Zeichen aus dem Bildschirm lesen */
  1159.   mvaddch (y,x,alt_zeich [num]); /* Altes Zeichen hinsetzen */
  1160.   alt_zeich [num] = hilf; /* gelesenes Zeichen als altes Zeichen merken */
  1161. }
  1162.  
  1163. /*****************************************************************************
  1164. *
  1165. *  Funktion       Fensterinhalte nach stdscr uebertragen (cpwins2stdscr)
  1166. *  --------
  1167. *
  1168. *  Beschreibung : Es werden alle Fenster ausser dem aktuellen ins stdscr-
  1169. *                 Fenster uebertragen. Dazu wird die Funktion overlay benutzt.
  1170. *
  1171. *****************************************************************************/
  1172.  
  1173. void cpwins2stdscr()
  1174. {
  1175.   /* *** interne Daten und Initialisierung *** */
  1176.   win_typ *w = akt_winp->next->next; /* Pointer fuer Windowliste */
  1177.  
  1178.   while(w != akt_winp)
  1179.   {
  1180.     overwrite(w->winp,stdscr);
  1181.     w = w->next;
  1182.   }
  1183.   refresh();
  1184. }
  1185.  
  1186. /*****************************************************************************
  1187. *
  1188. *  Funktion       Ecken zeichnen bzw. loeschen (eckenhw)
  1189. *  --------
  1190. *
  1191. *  Beschreibung : Es werden die Eckpunkte des aktuellen Fensters durch die
  1192. *                 Zeichen, die vorher dort standen (anfangs '+') ersetzt.
  1193. *
  1194. *****************************************************************************/
  1195.  
  1196. void eckenhw()
  1197. {
  1198.   mal_und_merk (akt_winp->y,akt_winp->x,0);
  1199.   mal_und_merk (akt_winp->y,akt_winp->x+akt_winp->dx+1,1);
  1200.   mal_und_merk (akt_winp->y+akt_winp->dy+1,akt_winp->x,2);
  1201.   mal_und_merk (akt_winp->y+akt_winp->dy+1,akt_winp->x+akt_winp->dx+1,3);
  1202.   refresh();
  1203. }
  1204.  
  1205. /*****************************************************************************
  1206. *
  1207. *  Funktion       Fenster nach rechts bewegen (win_right)
  1208. *  --------
  1209. *
  1210. *  Parameter    : steps     :
  1211. *                   Typ          : int
  1212. *                   Wertebereich : 0 - MAXINT
  1213. *                   Bedeutung    : Schritte, um die verschoben werden soll
  1214. *
  1215. *  Beschreibung : Funktion prueft, ob Fenster nach rechts geschoben werden
  1216. *                 kann. Wenn ja, wird Startposition x inkrementiert.
  1217. *
  1218. *****************************************************************************/
  1219.  
  1220. void win_right(steps)
  1221. int steps;
  1222. {
  1223.   if ((akt_winp->x += steps)+akt_winp->dx+1 >= COLS)
  1224.     akt_winp->x = COLS-akt_winp->dx-2;
  1225. }
  1226.  
  1227. /*****************************************************************************
  1228. *
  1229. *  Funktion       Fenster nach links verschieben (win_left)
  1230. *  --------
  1231. *
  1232. *  Parameter    : steps     :
  1233. *                   Typ          : int
  1234. *                   Wertebereich : 0 - MAXINT
  1235. *                   Bedeutung    : Schritte, um die verschoben werden soll
  1236. *
  1237. *  Beschreibung : Fall Fenster noch nicht am linken Bildschirmrand, dann
  1238. *                 Fensterstart x dekrementieren.
  1239. *
  1240. *****************************************************************************/
  1241.  
  1242. void win_left(steps)
  1243. int steps;
  1244. {
  1245.   if ((akt_winp->x -= steps) < START_X)
  1246.     akt_winp->x = START_X;
  1247. }
  1248.  
  1249. /*****************************************************************************
  1250. *
  1251. *  Funktion       Window nach oben verschieben (win_up)
  1252. *  --------
  1253. *
  1254. *  Parameter    : steps     :
  1255. *                   Typ          : int
  1256. *                   Wertebereich : 0 - MAXINT
  1257. *                   Bedeutung    : Schritte, um die verschoben werden soll
  1258. *
  1259. *  Beschreibung : Falls Fenster nicht am oberen Bildschirmrand, Startadresse
  1260. *                 y dekrementieren
  1261. *
  1262. *****************************************************************************/
  1263.  
  1264. void win_up(steps)
  1265. int steps;
  1266. {
  1267.   if ((akt_winp->y -= steps) < START_Y)
  1268.     akt_winp->y = START_Y;
  1269. }
  1270.  
  1271. /*****************************************************************************
  1272. *
  1273. *  Funktion       Fenster nach unten verschieben (win_down)
  1274. *  --------
  1275. *
  1276. *  Parameter    : steps     :
  1277. *                   Typ          : int
  1278. *                   Wertebereich : 0 - MAXINT
  1279. *                   Bedeutung    : Schritte, um die verändert werden soll
  1280. *
  1281. *  Beschreibung : Falls Fenster noch nicht am unteren Bildschirmrand, wird
  1282. *                 Fensterstartadresse y inkrementiert.
  1283. *
  1284. *****************************************************************************/
  1285.  
  1286. void win_down(steps)
  1287. int steps;
  1288. {
  1289.   if ((akt_winp->y += steps)+akt_winp->dy+2 >= LINES)
  1290.     akt_winp->y = LINES-akt_winp->dy-3;
  1291. }
  1292.  
  1293. /*****************************************************************************
  1294. *
  1295. *  Funktion       Fenster verbreitern (size_right)
  1296. *  --------
  1297. *
  1298. *  Parameter    : steps     :
  1299. *                   Typ          : int
  1300. *                   Wertebereich : 0 - MAXINT
  1301. *                   Bedeutung    : Schritte, um die verändert werden soll
  1302. *
  1303. *  Beschreibung : Falls die rechte Seite des Fensters nicht am rechten Bild-
  1304. *                 schirmrand ist, wird das Fenster um eine Position
  1305. *                 verbreitert
  1306. *
  1307. *****************************************************************************/
  1308.  
  1309. void size_right(steps)
  1310. int steps;
  1311. {
  1312.   if (akt_winp->x+(akt_winp->dx += steps)+1 >= COLS)
  1313.     akt_winp->dx = COLS-akt_winp->x-2;
  1314. }
  1315.  
  1316. /*****************************************************************************
  1317. *
  1318. *  Funktion       Fenster verschmaelern (size_left)
  1319. *  --------
  1320. *
  1321. *  Parameter    : steps     :
  1322. *                   Typ          : int
  1323. *                   Wertebereich : 0 - MAXINT
  1324. *                   Bedeutung    : Schritte, um die verändert werden soll
  1325. *
  1326. *  Beschreibung : Falls das Fenster eine Breite > 1 hat, wird es um eine
  1327. *                 Position verschmaelert.
  1328. *
  1329. *****************************************************************************/
  1330.  
  1331. void size_left(steps)
  1332. int steps;
  1333. {
  1334.   if ((akt_winp->dx -= steps) < 1)
  1335.     akt_winp->dx = 1;
  1336. }
  1337.  
  1338. /*****************************************************************************
  1339. *
  1340. *  Funktion       Unteren Fensterrand nach oben ziehen (size_up)
  1341. *  --------
  1342. *
  1343. *  Parameter    : steps     :
  1344. *                   Typ          : int
  1345. *                   Wertebereich : 0 - MAXINT
  1346. *                   Bedeutung    : Schritte, um die verändert werden soll
  1347. *
  1348. *  Beschreibung : Falls das Fenster mehr als eine Zeile hat, wird
  1349. *                 die Hoehe des Fenstern dekrementiert.
  1350. *
  1351. *****************************************************************************/
  1352.  
  1353. void size_up(steps)
  1354. int steps;
  1355. {
  1356.   if ((akt_winp->dy -= steps) < 1)
  1357.     akt_winp->dy = 1;
  1358. }
  1359.  
  1360. /*****************************************************************************
  1361. *
  1362. *  Funktion       Unteren Fensterrand nach unten schieben (size_down)
  1363. *  --------
  1364. *
  1365. *  Parameter    : steps     :
  1366. *                   Typ          : int
  1367. *                   Wertebereich : 0 - MAXINT
  1368. *                   Bedeutung    : Schritte, um die verändert werden soll
  1369. *
  1370. *  Beschreibung : Falls der untere Fensterrand nicht am unteren Bild-
  1371. *                 schirmrand ist, wird die Fensterhoehe inkrementiert.
  1372. *
  1373. *****************************************************************************/
  1374.  
  1375. void size_down(steps)
  1376. int steps;
  1377. {
  1378.   if (akt_winp->y+(akt_winp->dy += steps)+1 >= LINES-1)
  1379.     akt_winp->dy = LINES-akt_winp->y-3;
  1380. }
  1381.  
  1382. /*****************************************************************************
  1383. *
  1384. *  Funktion       Gespeicherte Groesse wird aktuelle Groesse (toggle_size)
  1385. *  --------
  1386. *
  1387. *  Beschreibung : Die gespeicherte Groesse wird mit der aktuellen vertauscht.
  1388. *                 Die aktuelle Zeile wird moeglichst in die Mitte des
  1389. *                 Fensters gesetzt, seitlich wird der Fensterinhalt moeglichst
  1390. *                 weit nach rechts geschoben.
  1391. *
  1392. *****************************************************************************/
  1393.  
  1394. void toggle_size()
  1395. {
  1396.   swap_int(&akt_winp->dx,&akt_winp->adx);
  1397.   swap_int(&akt_winp->dy,&akt_winp->ady);
  1398.   swap_int(&akt_winp->x,&akt_winp->ax);
  1399.   swap_int(&akt_winp->y,&akt_winp->ay);
  1400.  
  1401.   if ((akt_winp->ws_line = akt_winp->textline - akt_winp->dy/2) < 0)
  1402.     akt_winp->ws_line=0;
  1403.   if ((akt_winp->ws_col=akt_winp->screencol-akt_winp->dx+1)<0)
  1404.     akt_winp->ws_col = 0;
  1405.  
  1406.   werase(akt_winp->winp);   /* Fensterinhalt loeschen */
  1407.   wrefresh(akt_winp->winp);
  1408.   delwin(akt_winp->winp);   /* Fenster entfernen und neu erstellen */
  1409.   akt_winp->winp = newwin(akt_winp->dy+2,akt_winp->dx+2,akt_winp->y,akt_winp->x);
  1410.   init_win();  /* Fensterdefault mit Curses setzen */
  1411. }
  1412.  
  1413. /*****************************************************************************
  1414. *
  1415. *  Funktion       Fenster zum aktuellen Fenster machen (make_akt_win)
  1416. *  --------
  1417. *
  1418. *  Parameter    : n         :
  1419. *                   Typ          : int
  1420. *                   Wertebereich : 0-maxint
  1421. *                   Bedeutung    : Nummer des Fensters, das zum aktuellen
  1422. *                                  gemacht werden soll.
  1423. *
  1424. *  Ergebnis     :
  1425. *                   Typ          : int
  1426. *                   Wertebereich : TRUE, FALSE
  1427. *                   Bedeutung    : TRUE  : Fenster noch da
  1428. *                                  FALSE : Fenster nicht mehr da
  1429. *
  1430. *  Beschreibung : Die Liste der Fenster wird auf ein Fenster mit der Nummer
  1431. *                 n durchsucht. Wird es gefunden, so wird es zum aktuellen,
  1432. *                 und es wird TRUE zurueckgegeben. Sonst bleibt das aktuelle
  1433. *                 Fenster unveraendert und es wird FALSE zurueckgegeben.
  1434. *
  1435. *****************************************************************************/
  1436.  
  1437. int make_akt_win(n)
  1438. register int n;
  1439. {
  1440.   /* *** interne Daten *** */
  1441.   register win_typ *w,     /* Zum Durchlaufen der Fensterliste */
  1442.            *dummy; /* Zum Umhaengen der Fenster        */
  1443.  
  1444.   if(akt_winp->wini == n)       /* wieso in der Ferne schweifen... */
  1445.     return(TRUE);               /* aktuelles ist gewuenschtes Fenster */
  1446.  
  1447.   for(w=akt_winp->next->next;w != akt_winp && w->wini != n;w = w->next);
  1448.  
  1449.   if(w->wini == n)              /* gefunden? */
  1450.   {
  1451.     dummy = akt_winp->next;     /* Dann gefundenes Fenster zum aktuellen */
  1452.     akt_winp->next = w;         /* machen, indem es vor dummy einge-     */
  1453.     w->prev->next = w->next;    /* koppelt wird.                         */
  1454.     w->next->prev = w->prev;
  1455.     w->prev = akt_winp;
  1456.     w->next = dummy;
  1457.     dummy->prev = w;
  1458.     akt_winp = w;
  1459.     return(TRUE);
  1460.   }
  1461.   return(FALSE);
  1462. }
  1463.  
  1464. /*****************************************************************************
  1465. *
  1466. *  Funktion       Fenster gemaess Filename suchen (sw_name)
  1467. *  --------
  1468. *
  1469. *  Parameter    : fn        :
  1470. *                   Typ          : char*
  1471. *                   Wertebereich : Pointer auf ASCII-Zeichenkette
  1472. *                   Bedeutung    : Name des Fensters, das zum aktuellen
  1473. *                                  gemacht werden soll.
  1474. *
  1475. *  Ergebnis     :
  1476. *                   Typ          : int
  1477. *                   Wertebereich : TRUE, FALSE
  1478. *                   Bedeutung    : TRUE  : Fenster gefunden
  1479. *                                  FALSE : Fenster nicht gefunden
  1480. *
  1481. *  Beschreibung : Die Liste der Fenster wird auf ein Fenster mit dem Namen
  1482. *                 fn durchsucht. Wird es gefunden, so wird es zum aktuellen,
  1483. *                 und es wird TRUE zurueckgegeben. Sonst bleibt das aktuelle
  1484. *                 Fenster unveraendert und es wird FALSE zurueckgegeben.
  1485. *
  1486. *****************************************************************************/
  1487.  
  1488. int sw_name(fn)
  1489. register char *fn;
  1490. {
  1491.   register win_typ *w,     /* Zum Durchlaufen der Fensterliste */
  1492.            *dummy; /* Zum Umhaengen der Fenster        */
  1493.  
  1494.   for(w=akt_winp->next->next;w!=akt_winp && strcmp(w->filename,fn);w=w->next);
  1495.  
  1496.   if(w != akt_winp)                     /* gefunden? */
  1497.   {
  1498.     dummy = akt_winp->next;   /* Dann gefundenes Fenster zum aktuellen */
  1499.     akt_winp->next = w;       /* machen, indem man es vor dummy in     */
  1500.     w->prev->next = w->next;  /* die Fensterliste einhaengt.           */
  1501.     w->next->prev = w->prev;
  1502.     w->prev = akt_winp;
  1503.     w->next = dummy;
  1504.     dummy->prev = w;
  1505.     akt_winp = w;
  1506.     return(TRUE);
  1507.   }
  1508.   /* Wenn aktuelles Fenster richtig war, dann TRUE, sonst FALSE */
  1509.   if (akt_winp->filename)
  1510.     return(!strcmp(akt_winp->filename,fn));
  1511.   else
  1512.     return FALSE; /* Kein Fenster offen, dann nicht gefunden */
  1513. }
  1514.  
  1515. /******************************************************************************
  1516. *
  1517. * Funktion     : Fenster in Hintergrund schieben (push_win_back)
  1518. * --------------
  1519. *
  1520. * Beschreibung : Das aktuelle Fenster wird zum Fenster, das als erstes
  1521. *                gezeichnet wird. Dadurch erscheint es für den Benutzer
  1522. *                im Hintergrund.
  1523. *
  1524. ******************************************************************************/
  1525.  
  1526. void push_win_back()
  1527. {
  1528.   win_typ *dummy=akt_winp->next; /* Zum Umhängen der Fenster */
  1529.  
  1530.   if(akt_winp->next->next != akt_winp)
  1531.   {
  1532.     dummy->next->prev = akt_winp;
  1533.     akt_winp->next = dummy->next;
  1534.     dummy->prev = akt_winp->prev;
  1535.     dummy->prev->next = dummy;
  1536.     dummy->next = akt_winp;
  1537.     akt_winp->prev = dummy;
  1538.     akt_winp = dummy->prev;
  1539.   }
  1540. }
  1541.  
  1542. /******************************************************************************
  1543. *
  1544. * Funktion     : Um eine Zeile scrollen, falls nötig (check_and_scroll_by_one)
  1545. * --------------
  1546. *
  1547. *  Ergebnis     :
  1548. *                   Typ          : int
  1549. *                   Wertebereich : TRUE, FALSE
  1550. *                   Bedeutung    : TRUE  : Fenster gescrollt
  1551. *                                  FALSE : Fenster nicht gescrollt
  1552. *
  1553. * Beschreibung : Wenn sich der Cursor unterhalb des sichtbaren Bereichs
  1554. *                des aktuellen Fensters befindet, wird das Fenster um eine
  1555. *                Zeile nach oben gescrollt und der Cursor wieder korrekt
  1556. *                positioniert (mit setz_cursor()).
  1557. *
  1558. ******************************************************************************/
  1559.  
  1560. int check_and_scroll_by_one ()
  1561. {
  1562.   if (akt_winp->textline >= akt_winp->ws_line+akt_winp->dy)
  1563.   {
  1564.     akt_winp->ws_line++;
  1565.     text_up (0);             /* Falls nötig, scrollen */
  1566.     setz_cursor (W_AKT);
  1567.     return TRUE;
  1568.   }
  1569.   return FALSE;
  1570. }
  1571.