home *** CD-ROM | disk | FTP | other *** search
/ Mega Top 1 / os2_top1.zip / os2_top1 / APPS / EDITORS / EHP12 / CUR_MAIN.C < prev    next >
C/C++ Source or Header  |  1993-10-27  |  46KB  |  1,324 lines
  1. /******************************************************************************
  2. *
  3. * Modul      : cur_main.c
  4. *
  5. * Funktionen : fatal (Fatale Fehlermeldung ausgeben)
  6. *              beep (Beep auf Lautsprecher ausgeben)
  7. *              flash (Bildschirmrahmen aufblinken lassen)
  8. *              napms (Programm für bestimmte Zeit anhalten)
  9. *              _gyx (Cursor auf Position y/x setzen)
  10. *              show_cursor (Cursor sichtbar machen)
  11. *              hide_cursor (Cursor unsichtbar machen)
  12. *              place_cursor (Cursor im Fenster plazieren)
  13. *              cur_left (Cursor nach links bewegen)
  14. *              cur_right (Cursor nach rechts bewegen)
  15. *              newwin (Neues Fenster anlegen)
  16. *              delwin (Fenster freigeben)
  17. *              mvwin (Fenster bewegen)
  18. *              in_win (Test, ob Punkt in Fenster liegt)
  19. *              calc_overlap (Überlappungsbereich berechnen)
  20. *              overlay (Fensterinhalt für Überlappung ohne Blanks kopieren)
  21. *              overwrite (Fensterinhalt für Überlappung mit Blanks kopieren)
  22. *              mvcur (Cursor an absolute Position bewegen)
  23. *              set_videomode (Anpassung des bildschirmmodus)
  24. *              initscr (Curses initialisieren)
  25. *              endwin (Curses beenden)
  26. *              wnoutrefresh (Window-Image ins VSI kopieren)
  27. *              doupdate (VSI in physikalischen Schirm kopieren)
  28. *              wrefresh (Window-Image ins VSI und VSI auf Schirm kopieren)
  29. *              cur_to_poi (Cursoradresse in Pointer umrechnen)
  30. *              poi_to_cur (Pointer in Cursorposition wandeln)
  31. *              scroll (Fensterinhalt um eine Zeile nach oben bewegen)
  32. *              printw (Text formatiert im Standardfenster ausgeben)
  33. *              scanw (Text formatiert aus Standardfenster einlesen)
  34. *              mvprintw (Text an Position X/Y im Standard-Fenster ausgeben)
  35. *              mvscanw (Daten an bestimmter Stelle im Std.-Fenster einlesen)
  36. *              main (Hauptprogramm)
  37. *
  38. ******************************************************************************/
  39.  
  40. #define cur_main    /* Damit stdscr etc. nicht als extern deklariert werden */
  41.  
  42. #ifdef OS2
  43. #define INCL_DOSPROCESS
  44. #define INCL_VIO
  45. #include <os2.h>
  46. #else
  47. #include <dos.h>
  48. #include <process.h>
  49. #endif
  50. #include <stdarg.h>
  51.  
  52. #include "curses.h"
  53.  
  54. void scroll (WINDOW*);
  55.  
  56. struct VioMode { short int length;
  57.          char      mode,
  58.                colours;
  59.          short int x_size_text,
  60.                y_size_text,
  61.                x_size_graph,
  62.                y_size_graph,
  63.                reserved [18]; };
  64.  
  65.  
  66. extern char *reserve_mem();
  67.  
  68. WINDOW *stdscr,           /* Bildschirmgroßes Standardfenster */
  69.        *curscr,           /* Aktueller Bildschirminhalt */
  70.        *last_win;         /* Zuletzt refreshtes Window */
  71. short  int *vsi,          /* Virtueller Bildschirminhalt */
  72.        *PH_SC,            /* Startadresse des Bildschirmram */
  73.        LINES=25,          /* Anzahl der sichbaren Bildschirmzeilen */
  74.        COLS=80;           /* Anzahl der sichbaren Bildschirmspalten */
  75. #ifdef OS2
  76. struct VioMode old_videomode; /* Videomodus beim Aufruf des Editors */
  77. #else
  78. short  old_videomode;
  79. #endif
  80. char   rawflag=FALSE,     /* Flag, ob Eingabe ungepuffert ist */
  81.        echoflag=TRUE,     /* Flag, ob Eingabe angezeigt wird */
  82.        nlflag=TRUE,       /* Flag, ob \r in \n umgewandelt wertden soll */
  83.        start_scan,        /* Cursor Start- und */
  84.        end_scan;          /* Endsscan */
  85.  
  86. /******************************************************************************
  87. *
  88. * Funktion    : Fatale Fehlermeldung ausgeben (fatal)
  89. * -------------
  90. *
  91. * Parameter   : s           :
  92. *                 Typ          : char *
  93. *                 Wertebereich : Pointer auf ASCII-Zeichenkette
  94. *                 Bedeutung    : Auszugebende Fehlermeldung
  95. *
  96. * Bescheibung : Der übergene String s wird ausgegeben, das Programm mit dem
  97. *               Fehlercode 1 abgebrochen.
  98. *
  99. ******************************************************************************/
  100.  
  101. void fatal(s)
  102. char *s;
  103. {
  104.   printf("\nFATAL: %s\nProgramm wird abgebrochen\n",s);
  105.   exit(1);
  106. }
  107.  
  108. /******************************************************************************
  109. *
  110. * Funktion     : Beep auf Lautsprecher ausgeben (beep)
  111. * --------------
  112. *
  113. * Beschreibung : Es werden zwei geschachtelte Schleifen gestartet, in denen
  114. *                ständig das Bit 1 des Port B getoggled wird. Dadurch wird
  115. *                ein Ton erzeugt. Die innere Schleife spezifiziert die
  116. *                Frequenz, die äußere die Dauer des Tones.
  117. *
  118. ******************************************************************************/
  119.  
  120. void beep()
  121. {
  122. #ifdef OS2
  123.   DosBeep (1000, 200);
  124. #else
  125.   char old_portb = inportb(0x61);
  126.   int  i;
  127.  
  128.   outportb(0x61,old_portb | 3); /* GATE 2 setzen */
  129.   outportb(0x43,0xB6);      /* Signal: Counter 2 setzen */
  130.   outportb(0x42,0);         /* Reziprokwert der Frequenz lo */
  131.   outportb(0x42,4);         /*  -------------"---------  hi */
  132.   for (i=0;i<32767;i++);
  133.   outportb(0x61,old_portb);
  134. #endif
  135. }
  136.  
  137. /******************************************************************************
  138. *
  139. * Funktion     : Bildschirmrahmen kurz blinken lassen (flash)
  140. * --------------
  141. *
  142. * Beschreibung : Die Rahmenfarbe wird komplementiert und für kurze Zeit
  143. *                angezeigt. Danach wird wieder die ursprüngliche Farbe
  144. *                restauriert.
  145. *
  146. ******************************************************************************/
  147.  
  148. void flash()
  149. {
  150. #ifdef OS2
  151.   struct VioState { short int length, func, colour; } vs;
  152.   vs.length = 6;
  153.   vs.func   = 1;  /* Funktion Rahmenfarbe ermitteln */
  154.   VioGetState (&vs, 0);
  155.   vs.colour = 255 - vs.colour; /* Farbe invertieren */
  156.   VioSetState (&vs, 0);
  157.   DosSleep (10);
  158.   vs.colour = 255 - vs.colour; /* Alte Farbe wiederherstellen */
  159.   VioSetState (&vs, 0);
  160. #else
  161.   long i;
  162.  
  163.   outportb(0x3D9,15);
  164.   for(i=1;i<8000;i++);
  165.   outportb(0x3D9,0);
  166. #endif
  167. }
  168.  
  169. /******************************************************************************
  170. *
  171. * Funktion     : Programm für bestimmte Zeit anhalten (napms)
  172. * --------------
  173. *
  174. * Parameter    : ms          :
  175. *                  Typ          : int
  176. *                  Wertebereich : 0-32767
  177. *                  Bedeutung    : Zeit in Millisekunden
  178. *
  179. * Ergebnis     :
  180. *                  Typ          : int
  181. *                  Wertebereich : OK
  182. *                  Bedeutung    : Immer OK
  183. *
  184. * Beschreibung : Zwei geschachtelte Schleifen laufen über die angegebene Zeit.
  185. *
  186. ******************************************************************************/
  187.  
  188. int napms(ms)
  189. int ms;
  190. {
  191. #ifdef OS2
  192.   DosSleep (ms);
  193. #else
  194.   int i;
  195.  
  196.   while(ms--)
  197.     for(i=0;i<300;i++);
  198.   return(OK);
  199. #endif
  200. }
  201.  
  202. /******************************************************************************
  203. *
  204. * Funktion     : Cursor auf Position y/x setzen (_gyx)
  205. * --------------
  206. *
  207. * Parameter    : y           :
  208. *                  Typ          : short int
  209. *                  Wertebereich : 0-32767
  210. *                  Bedeutung    : Neue Y-Cursorkoordinate
  211. *
  212. *              : x           :
  213. *                  Typ          : short int
  214. *                  Wertebereich : 0-32767
  215. *                  Bedeutung    : Neue X-Cursorkoordinate
  216. *
  217. * Beschreibung : Der Cursor wird mit dem Interrupt 16 auf die richtige
  218. *                Position gesetzt. Bei OS/2 wird VioSetCurPos verwendet.
  219. *
  220. ******************************************************************************/
  221.  
  222. void _gyx(y,x)
  223. short int y,x;
  224. {
  225. #ifdef OS2
  226.   VioSetCurPos (y, x, 0);
  227. #else
  228.   union REGS r;
  229.  
  230.   r.h.ah = 2;
  231.   r.h.bh = 0;
  232.   r.h.dl = x;
  233.   r.h.dh = y;
  234.   int86(16,&r,&r);
  235. #endif
  236. }
  237.  
  238. /******************************************************************************
  239. *
  240. * Funktion     : Cursor sichtbar machen (show_cursor)
  241. * --------------
  242. *
  243. * Beschreibung : Der Cursor wird mit dem BIOS-Interrupt 16 sichtbar gemacht.
  244. *                Bei OS/2 wird VioGet/SetCurType verwendet.
  245. *
  246. ******************************************************************************/
  247.  
  248. void show_cursor()
  249. {
  250. #ifdef OS2
  251.   struct CurType { short int start_y, end_y, size_x, attrs; } ct;
  252.  
  253.   VioGetCurType (&ct, 0);
  254.   ct.attrs = 0;
  255.   VioSetCurType (&ct, 0);
  256. #else
  257.   union REGS  r;
  258.  
  259.   r.h.ah = 1;
  260.   r.h.ch = start_scan;
  261.   r.h.cl = end_scan;
  262.   int86(16,&r,&r);
  263. #endif
  264. }
  265.  
  266. /******************************************************************************
  267. *
  268. * Funktion     : Cursor unsichtbar machen (hide_cursor)
  269. * --------------
  270. *
  271. * Beschreibung : Der Cursor wird mit dem BIOS-Interrupt 16 unsichtbar gemacht.
  272. *
  273. ******************************************************************************/
  274.  
  275. void hide_cursor()
  276. {
  277. #ifdef OS2
  278.   struct CurType { short int start_y, end_y, size_x, attrs; } ct;
  279.  
  280.   VioGetCurType (&ct, 0);
  281.   ct.attrs = 1;
  282.   VioSetCurType (&ct, 0);
  283. #else
  284.   union REGS r;
  285.  
  286.   r.h.ah = 1;
  287.   r.h.ch = 31;
  288.   int86(16,&r,&r);
  289. #endif
  290. }
  291.  
  292. /******************************************************************************
  293. *
  294. * Funktion     : Cursor im Fenster plazieren (place_cursor)
  295. * --------------
  296. *
  297. * Parameter    : w           :
  298. *                  Typ          : WINDOW *
  299. *                  Wertebereich : Pointer auf WINDOW-Struktur
  300. *                  Bedeutung    : Fenster, in dem der Cursor stehen soll
  301. *
  302. * Beschreibung : Gemäß der in der WINDOW-Struktur gesetzten Cursor-Koordina-
  303. *                ten und Fensterposition wird der Cursor über die Funktion
  304. *                _gyx an die richtige Stelle gesetzt.
  305. *
  306. ******************************************************************************/
  307.  
  308. void place_cursor(w)
  309. WINDOW *w;
  310. {
  311.   _gyx(w->_start_y+w->_cursor_y,w->_start_x+w->_cursor_x);
  312.   show_cursor();
  313. }
  314.  
  315. /******************************************************************************
  316. *
  317. * Funktion     : Cursor nach links bewegen (cur_left)
  318. * --------------
  319. *
  320. * Parameter    : w           :
  321. *                  Typ          : WINDOW *
  322. *                  Wertebereich : Pointer auf WINDOW-Struktur
  323. *                  Bedeutung    : Fenster, dessen Cursor nach links bewegt
  324. *                                 werden soll
  325. *
  326. * Parameter    : anz         :
  327. *                  Typ          : int
  328. *                  Wertebereich : 0-MAXINT
  329. *                  Bedeutung    : Anzahl der Zeichen, um die der Cursor
  330. *                                 nach links bewegt werden soll
  331. *
  332. * Beschreibung : Der Cursor wird anz mal nach links bewegt. Ist er am linken
  333. *                Rand angelangt, so wird er ans Ende der darüberliegenden
  334. *                Zeile gestellt. Ist der Cursor in der oberen linken Fenster-
  335. *                ecke angelangt, so passiert nichts mehr.
  336. *
  337. ******************************************************************************/
  338.  
  339. void cur_left(w,anz)
  340. WINDOW *w;
  341. int anz;
  342. {
  343.   while(anz--)
  344.   {
  345.     if(w->_cursor_x)
  346.       w->_cursor_x--;
  347.     else
  348.       if(w->_cursor_y)
  349.       {
  350.     w->_cursor_x = w->_width_x-1;
  351.     w->_cursor_y--;
  352.       }
  353.   }
  354. }
  355.  
  356. /******************************************************************************
  357. *
  358. * Funktion     : Cursor nach rechts bewegen (cur_right)
  359. * --------------
  360. *
  361. * Parameter    : w           :
  362. *                  Typ          : WINDOW *
  363. *                  Wertebereich : Pointer auf WINDOW-Struktur
  364. *                  Bedeutung    : Fenster, dessen Cursor nach links bewegt
  365. *                                 werden soll
  366. *
  367. * Parameter    : anz         :
  368. *                  Typ          : int
  369. *                  Wertebereich : 0-MAXINT
  370. *                  Bedeutung    : Anzahl der Zeichen, um die der Cursor
  371. *                                 nach rechts bewegt werden soll
  372. *
  373. * Beschreibung : Der Cursor wird anz mal nach rechts bewegt. Ist er am rechten
  374. *                Rand angelangt, so wird er an den Anfang der darunterliegenden
  375. *                Zeile gestellt. Ist der Cursor in der unteren rechten Fenster-
  376. *                ecke angelangt, so wird, falls scroll gesetzt ist, das Fenster
  377. *                gescrollt, ansonsten wird er einfach an den Anfang der
  378. *                letzten Zeile gestellt.
  379. *
  380. ******************************************************************************/
  381.  
  382. void cur_right(w,anz)
  383. WINDOW *w;
  384. int anz;
  385. {
  386.   while(anz--)
  387.   {
  388.     if(w->_cursor_x < w->_width_x-1)
  389.       w->_cursor_x++;
  390.     else
  391.     {
  392.       w->_cursor_x = 0;
  393.       if(w->_cursor_y < w->_width_y-1)
  394.     w->_cursor_y++;
  395.       else
  396.     if(w->_scrflag)
  397.       scroll(w);
  398.     }
  399.   }
  400. }
  401.  
  402. /******************************************************************************
  403. *
  404. * Funktion     : Neues Fenster anlegen (newwin)
  405. * --------------
  406. *
  407. * Parameter    : dy          :
  408. *                  Typ          : short int
  409. *                  Wertebereich : 0-32767
  410. *                  Bedeutung    : Y-Größe des Fensters
  411. *
  412. *              : dx          :
  413. *                  Typ          : short int
  414. *                  Wertebereich : 0-32767
  415. *                  Bedeutung    : X-Größe des Fensters
  416. *
  417. *              : sy          :
  418. *                  Typ          : short int
  419. *                  Wertebereich : 0-32767
  420. *                  Bedeutung    : Y-Startkoordinate des Fensters
  421. *
  422. *              : sx          :
  423. *                  Typ          : short int
  424. *                  Wertebereich : 0-32767
  425. *                  Bedeutung    : X-Startkoordinate des Fensters
  426. *
  427. * Ergebnis     :
  428. *                  Typ          : WINDOW *
  429. *                  Wertebereich : Pointer auf WINDOW-Struktur
  430. *                  Bedeutung    : Pointer auf neu erzeugte WINDOW-Struktur
  431. *
  432. * Beschreibung : Es wird Speicherplatz für eine neue WINDOW-Struktur ange-
  433. *                fordert. Dort werden die Parameter als Position und Größe
  434. *                eingetragen. Es wird Speicherplatz für das Window-Image
  435. *                angefordert. Dieser wird mit dem Standard-Attribut besetzt.
  436. *                Dann werden die Flags (scroll etc.) initialisiert.
  437. *                Der Pointer auf diese Fensterstruktur wird zurückgegeben.
  438. *                Wird bei der Fenstergröße 0 angegeben, so wird der Wert auf
  439. *                das Maximum gesetzt (LINES-sy bzw. COLS-sx).
  440. *
  441. ******************************************************************************/
  442.  
  443. WINDOW *newwin(dy,dx,sy,sx)
  444. short int sx,sy,dx,dy;
  445. {
  446.   WINDOW *w;
  447.  
  448.   w = (WINDOW *) reserve_mem(sizeof(WINDOW));
  449.   if(sx < 0)        sx = 0;
  450.   if(sx > COLS-1)   sx = COLS-1;
  451.   if(sy < 0)        sy = 0;
  452.   if(sy > LINES-1)  sy = LINES-1;
  453.   if(dx < 1)        dx = COLS-sx;
  454.   if(dy < 1)        dy = LINES-sy;
  455.   if(sx+dx > COLS)  dx = COLS-sx;
  456.   if(sy+dy > LINES) dy = LINES-sy;
  457.   w->_start_x = sx;
  458.   w->_start_y = sy;
  459.   w->_width_x = dx;
  460.   w->_width_y = dy;
  461.   w->_cursor_x = w->_cursor_y = 0;
  462.   w->_image = (short int *) reserve_mem(w->_width_y * w->_width_x * sizeof(short int)); /* Speicher für Fensterinhalt */
  463.   werase(w);
  464.   w->_scrflag  = TRUE;  /* Standardmäßig wird das Fenster gescrollt */
  465.   w->_lvokflag = FALSE; /* Cursor ist sichtbar */
  466.   w->_dlyflag  = TRUE;  /* wgetch wartet auf Zeichen */
  467.   w->_tabflag  = TRUE;  /* Tabs werden zu Spaces expandiert */
  468.   w->_attribs  = STD_ATTR; /* Standardattribute für neues Fenster */
  469.   return(w);
  470. }
  471.  
  472. /******************************************************************************
  473. *
  474. * Funktion     : Fenster freigeben (delwin)
  475. * --------------
  476. *
  477. * Parameter    : w           :
  478. *                  Typ          : WINDOW *
  479. *                  Wertebereich : Pointer auf WINDOW-Struktur
  480. *                  Bedeutung    : Freizugebendes Fenster
  481. *
  482. * Beschreibung : Der für das Window-Image und die Window-Struktur reservierte
  483. *                Speicherplatz werden freigegeben.
  484. *
  485. ******************************************************************************/
  486.  
  487. void delwin(w)
  488. WINDOW *w;
  489. {
  490.   if(w)
  491.   {
  492.     free(w->_image);
  493.     free(w);
  494.   }
  495. }
  496.  
  497. /******************************************************************************
  498. *
  499. * Funktion     : Fenster verschieben (mvwin)
  500. * --------------
  501. *
  502. * Parameter    : w           :
  503. *                  Typ          : WINDOW *
  504. *                  Wertebereich : Zeiger auf WINDOW-Struktur
  505. *                  Bedeutung    : Zu verschiebendes Fenster
  506. *
  507. *              : ny          :
  508. *                  Typ          : short int
  509. *                  Wertebereich : 0-32767
  510. *                  Bedeutung    : Neue Y-Startkoordinate des Fensters
  511. *
  512. *              : nx          :
  513. *                  Typ          : short int
  514. *                  Wertebereich : 0-32767
  515. *                  Bedeutung    : Neue X-Startkoordinate des Fensters
  516. *
  517. * Beschreibung : Falls das Fenster an der neuen Position komplett innerhalb
  518. *                des Bildschirms liegt, werden die Startkoordinaten auf
  519. *                die uebergebenen Werte gesetzt.                
  520. *
  521. ******************************************************************************/
  522.  
  523. void mvwin(w,ny,nx)
  524. WINDOW *w;
  525. short int ny,nx;
  526. {
  527.   if(nx >= 0 && ny >= 0
  528.   && nx+w->_width_x <= COLS && ny+w->_width_y <= LINES)
  529.   {
  530.     w->_start_x = nx;
  531.     w->_start_y = ny;
  532.   }
  533. }
  534.  
  535. /******************************************************************************
  536. *
  537. * Funktion     : Testen, ob Punkt in Fenster liegt (in_win)
  538. * --------------
  539. *
  540. * Parameter    : w           :
  541. *                  Typ          : WINDOW *
  542. *                  Wertebereich : Zeiger auf Window-Struktur
  543. *                  Bedeutung    : Fenster, in dem evtl. y/x liegen soll
  544. *
  545. *              : y           :
  546. *                  Typ          : short int
  547. *                  Wertebereich : 0-MAXINT
  548. *                  Bedeutung    : Y-Koordinate des zu testenden Punktes
  549. *
  550. *              : x           :
  551. *                  Typ          : short int
  552. *                  Wertebereich : 0-MAXINT
  553. *                  Bedeutung    : X-Koordinate des zu testenden Punktes
  554. *
  555. * Ergebnis     :
  556. *                  Typ          : int
  557. *                  Wertebereich : TRUE, FALSE
  558. *                  Bedeutung    : TRUE: Punkt innerhalb; FALSE: Punkt außerhalb
  559. *
  560. * Beschreibung : Es wird getestet, ob der Punkt mit den absoluten Koordinaten
  561. *                y und x im Fenster w liegt. Dazu werden die Fenstereckpunkte
  562. *                absolut berechnet.
  563. *
  564. ******************************************************************************/
  565.  
  566. int in_win(w,y,x)
  567. WINDOW *w;
  568. short int y,x;
  569. {
  570.   return (y >= w->_start_y && y < w->_start_y+w->_width_y
  571.        && x >= w->_start_x && x < w->_start_x+w->_width_x);
  572. }
  573.  
  574. /******************************************************************************
  575. *
  576. * Funktion     : Überlappungsbereich zweier Fenster berechnen (calc_overlap)
  577. * --------------
  578. *
  579. * Parameter    : w1          :
  580. *                  Typ          : WINDOW *
  581. *                  Wertebereich : Zeiger auf Window-Struktur
  582. *                  Bedeutung    : 1. Fenster für evtl. Überlappung
  583. *
  584. *              : w2          :
  585. *                  Typ          : WINDOW *
  586. *                  Wertebereich : Zeiger auf Window-Struktur
  587. *                  Bedeutung    : 2. Fenster für evtl. Überlappung
  588. *
  589. *              : l           :
  590. *                  Typ          : short int *
  591. *                  Wertebereich : Pointer auf short int
  592. *                  Bedeutung    : Linker Rand der Überlappung
  593. *
  594. *              : r           :
  595. *                  Typ          : short int *
  596. *                  Wertebereich : Pointer auf short int
  597. *                  Bedeutung    : Rechter Rand der Überlappung
  598. *
  599. *              : o           :
  600. *                  Typ          : short int *
  601. *                  Wertebereich : Pointer auf short int
  602. *                  Bedeutung    : Oberer Rand der Überlappung
  603. *
  604. *              : u           :
  605. *                  Typ          : short int *
  606. *                  Wertebereich : Pointer auf short int
  607. *                  Bedeutung    : Unterer Rand der Überlappung
  608. *
  609. * Ergebnis     :
  610. *                  Typ          : int
  611. *                  Wertebereich : TRUE, FALSE
  612. *                  Bedeutung    : TRUE: Überlappung; FALSE: Keine Übrlp.
  613. *
  614. * Beschreibung : Mit der Funktion in_win wird für jede Ecke der beiden
  615. *                übergebenen Fenster w1 und w2 getestet, ob sie im jeweils
  616. *                anderen Fenster liegen. Falls ja, werden die entsprechenden
  617. *                Eckpunkte gesetzt.
  618. *                Beispiel: Liegt die linke obere Ecke von w2 in w1, dann
  619. *                wird l auf den linken, o auf den oberen Rand von w2 gesetzt.
  620. *
  621. ******************************************************************************/
  622.  
  623. int calc_overlap(w1,w2,l,r,o,u)
  624. WINDOW *w1,*w2;
  625. short int *l,*r,*o,*u;
  626. {
  627.   int ret = FALSE;
  628.  
  629.   /* Zuerst checken, welche Ecken von w1 in w2 liegen */
  630.   if(in_win(w2,w1->_start_y,w1->_start_x))
  631.   { *l = w1->_start_x; *o = w1->_start_y; ret = TRUE; }
  632.   if(in_win(w2,w1->_start_y+w1->_width_y-1,w1->_start_x))
  633.   { *l = w1->_start_x; *u = w1->_start_y+w1->_width_y-1; ret = TRUE; }
  634.   if(in_win(w2,w1->_start_y,w1->_start_x+w1->_width_x-1))
  635.   { *r = w1->_start_x+w1->_width_x-1; *o = w1->_start_y; ret = TRUE; }
  636.   if(in_win(w2,w1->_start_y+w1->_width_y-1,w1->_start_x+w1->_width_x-1))
  637.   { *r = w1->_start_x+w1->_width_x-1; *u = w1->_start_y+w1->_width_y-1; ret = TRUE; }
  638.  
  639.   /* Dann checken, welche Ecken von w2 in w1 liegen */
  640.   if(in_win(w1,w2->_start_y,w2->_start_x))
  641.   { *l = w2->_start_x; *o = w2->_start_y; ret = TRUE; }
  642.   if(in_win(w1,w2->_start_y+w2->_width_y-1,w2->_start_x))
  643.   { *l = w2->_start_x; *u = w2->_start_y+w2->_width_y-1; ret = TRUE; }
  644.   if(in_win(w1,w2->_start_y,w2->_start_x+w2->_width_x-1))
  645.   { *r = w2->_start_x+w2->_width_x-1; *o = w2->_start_y; ret = TRUE; }
  646.   if(in_win(w1,w2->_start_y+w2->_width_y-1,w2->_start_x+w2->_width_x-1))
  647.   { *r = w2->_start_x+w2->_width_x-1; *u = w2->_start_y+w2->_width_y-1; ret = TRUE; }
  648.   return(ret);
  649. }
  650.  
  651. /******************************************************************************
  652. *
  653. * Funktion     : Überlappungsbereich ohne Blanks kopieren (overlay)
  654. * --------------
  655. *
  656. * Parameter    : w1          :
  657. *                  Typ          : WINDOW *
  658. *                  Wertebereich : Zeiger auf WINDOW-Struktur
  659. *                  Bedeutung    : Fenster aus dem kopiert werden soll
  660. *
  661. *              : w2          :
  662. *                  Typ          : WINDOW *
  663. *                  Wertebereich : Zeiger auf WINDOW-Struktur
  664. *                  Bedeutung    : Fennster in das kopiert werden soll
  665. *
  666. * Beschreibung : Zunächst wird mit der Funktion calc_overlap der Überlappungs-
  667. *                bereich berechnet. Ist dieser existent, werden alle Zeichen
  668. *                des Überlappungsbereichs die kein Blank sind, aus Fenster w1
  669. *                nach Fenster w2 kopiert.
  670. *
  671. ******************************************************************************/
  672.  
  673. void overlay(w1,w2)
  674. WINDOW *w1,*w2;
  675. {
  676.   short int l=0,r=0,o=0,u=0, /* Eckpunkte des Überlappungsbereichs */
  677.         zl,              /* Zähler für Durchlaufen des ÜB */
  678.         sk1,sk2,         /* Wie weit Pointer nach Zeilenende
  679.                 erhöht werden müssen */
  680.         *z1,*z2;         /* Pointer in Images */
  681.   char      inhalt;          /* Zu kopierendes Zeichen */
  682.  
  683.   if(calc_overlap(w1,w2,&l,&r,&o,&u)) /* Überlappungsbereich berechnen */
  684.   {
  685.     zl = l;
  686.     /* Skipweite: <Fensterbreite> - <Breite des ÜB> */
  687.     sk1 = w1->_width_x-(r-l)-1;
  688.     sk2 = w2->_width_x-(r-l)-1;
  689.     z1 = w1->_image + w1->_width_x*(o-w1->_start_y) + l-w1->_start_x;
  690.     z2 = w2->_image + w2->_width_x*(o-w2->_start_y) + l-w2->_start_x;
  691.     while (o <= u)
  692.     {
  693.       while (zl <= r)
  694.       {
  695.     if((inhalt = *z1 & 255) != ' ' && inhalt != '\0' && inhalt != '\377')
  696.       *z2++ = *z1++; /* Fensterinhalt von w1 nach w2 kopieren, */
  697.     else             /* falls kein ' ' */
  698.     {
  699.       z1++;   /* Sonst nur die Zeiger erhöhen */
  700.       z2++;
  701.     }
  702.     zl++;         /* Ein Zeichen weiter nach rechts */
  703.       }
  704.       z1 += sk1; /* Alles was nicht zum ÜB gehört überspringen */
  705.       z2 += sk2;
  706.       zl=l; /* An den Anfang der nächsten Zeile des */
  707.       o++; /* Überlappungsbereiches gehen. */
  708.     }
  709.   } /* ende if Überlappung */
  710. }
  711.  
  712. /******************************************************************************
  713. *
  714. * Funktion     : Überlappungsbereich mit Blanks kopieren (overwrite)
  715. * --------------
  716. *
  717. * Parameter    : w1          :
  718. *                  Typ          : WINDOW *
  719. *                  Wertebereich : Zeiger auf WINDOW-Struktur
  720. *                  Bedeutung    : Fenster aus dem kopiert werden soll
  721. *
  722. *              : w2          :
  723. *                  Typ          : WINDOW *
  724. *                  Wertebereich : Zeiger auf WINDOW-Struktur
  725. *                  Bedeutung    : Fennster in das kopiert werden soll
  726. *
  727. * Beschreibung : Zunächst wird mit der Funktion calc_overlap der Überlappungs-
  728. *                bereich berechnet. Ist dieser existent, werden alle Zeichen
  729. *                des Überlappungsbereichs aus Fenster w1 nach Fenster w2
  730. *                kopiert.
  731. *
  732. ******************************************************************************/
  733.  
  734. void overwrite(w1,w2)
  735. WINDOW *w1,*w2;
  736. {
  737.   short int l=0,r=0,o=0,u=0, /* Eckpunkte des Überlappungsbereichs */
  738.         zl,              /* Zähler für Durchlaufen des ÜB */
  739.         sk1,sk2,         /* Wie weit Pointer nach Zeilenende
  740.                 erhöht werden müssen */
  741.         *z1,*z2;         /* Pointer in Images */
  742.  
  743.   if(calc_overlap(w1,w2,&l,&r,&o,&u)) /* Überlappungsbereich berechnen */
  744.   {
  745.     zl = l;
  746.     /* Skipweite: <Fensterbreite> - <Breite des ÜB> */
  747.     sk1 = w1->_width_x-(r-l)-1;
  748.     sk2 = w2->_width_x-(r-l)-1;
  749.     z1 = w1->_image + w1->_width_x*(o-w1->_start_y) + l-w1->_start_x;
  750.     z2 = w2->_image + w2->_width_x*(o-w2->_start_y) + l-w2->_start_x;
  751.     while (o <= u)
  752.     {
  753.       while (zl <= r)
  754.       {
  755.     *z2++ = *z1++; /* Fensterinhalt von w1 nach w2 kopieren, */
  756.     zl++;         /* Ein Zeichen weiter nach rechts */
  757.       }
  758.       z1 += sk1; /* Alles was nicht zum ÜB gehört überspringen */
  759.       z2 += sk2;
  760.       zl=l; /* An den Anfang der nächsten Zeile des */
  761.       o++; /* Überlappungsbereiches gehen. */
  762.     }
  763.   } /* ende if Überlappung */
  764. }
  765.  
  766. /******************************************************************************
  767. *
  768. * Funktion     : Cursor absolut bewegen (mvcur)
  769. * --------------
  770. *
  771. * Parameter    : oy          :
  772. *                  Typ          : short int
  773. *                  Wertebereich : 0-32767
  774. *                  Bedeutung    : Alte Y-Koordinate, wird allerdings
  775. *                                 ignoriert.
  776. *
  777. *              : ox          :
  778. *                  Typ          : short int
  779. *                  Wertebereich : 0-32767
  780. *                  Bedeutung    : Alte X-Koordinate, wird allerdings
  781. *                                 ignoriert
  782. *
  783. *              : ny          :
  784. *                  Typ          : short int
  785. *                  Wertebereich : 0-32767
  786. *                  Bedeutung    : Neue Y-Koordinate
  787. *
  788. *              : nx          :
  789. *                  Typ          : short int
  790. *                  Wertebereich : 0-32767
  791. *                  Bedeutung    : Neue X-Koordinate
  792. *
  793. * Beschreibung : Die Funktion setzt den Hardwarecursor mit der Funktion
  794. *                _gyx auf die gewünschte Position, wobei dazu der
  795. *                Interrupt 16 benutzt wird.
  796. *
  797. ******************************************************************************/
  798.  
  799. void mvcur(oy,ox,ny,nx)
  800. short int oy,ox,ny,nx;
  801. {
  802.   _gyx(ny,nx);
  803. }
  804.  
  805. /******************************************************************************
  806. *
  807. * Funktion     : Videomodus setzen (set_videomode)
  808. * --------------
  809. *
  810. * Beschreibung : Anhand der Werte der beiden Variablen LINES und COLS
  811. *                wird die Nummer des Bildschirmmodus aus einer Tabelle
  812. *                ermittelt. Anschließend wird dieser Modus aktiviert.
  813. *                Die Korrektheit der Koordinaten wird bereits bei der
  814. *                Analyse der Umgebungsvariablen geprüft.
  815. *
  816. ******************************************************************************/
  817.  
  818. void set_videomode()
  819. {
  820. #ifdef OS2
  821.   struct VioMode vm;
  822.  
  823.   vm.length = sizeof (struct VioMode);
  824.   VioGetMode (&vm, 0);
  825.   vm.x_size_text = COLS;
  826.   vm.y_size_text = LINES;
  827.   VioSetMode (&vm, 0);
  828.   VioGetMode (&vm, 0);
  829.   COLS  = vm.x_size_text; /* Falls nicht umgeschaltet werden konnte, */
  830.   LINES = vm.y_size_text; /* aktuelle Fenstergröße ermitteln         */
  831. #else
  832.   int tabelle[9][3] = { { 40,25, 0},   /* Tabelle enthält die Spalten- */
  833.             { 80,25, 2},   /* und die Zeilenzahl sowie     */
  834.             { 80,30,80},   /* die Nummer der unterstützten */
  835.             { 80,43,81},   /* Textmodi.                    */
  836.             { 80,60,82},
  837.             {132,25,87},
  838.             {132,30,88},
  839.             {132,43,89},
  840.             {132,60,90} },
  841.       mode;                     /* Der zu aktivierende Bildschirmmodus */
  842.   union REGS r;               /* Prozessorregister für Video-Interrupt */
  843.  
  844.   for(mode=0;mode<10;mode++)
  845.     if(tabelle[mode][0] == COLS && tabelle[mode][1] == LINES)
  846.     {
  847.       mode = tabelle[mode][2];
  848.       break;
  849.     }
  850.   r.h.ah = 0; /* Funktion setze Video-Modus */
  851.   r.h.al = mode;
  852.   int86(16,&r,&r);  /* Modus mit dem BIOS-Int 16 setzen */
  853. #endif
  854. }
  855.  
  856. #ifdef OS2
  857. /******************************************************************************
  858. *
  859. * Funktion     : Tastatur in Raw-Mode versetzen (set_os2_raw)
  860. * --------------
  861. *
  862. * Beschreibung : Es wird mittels der OS/2 Kernel-Aufrufe KbdGetStatus
  863. *                und KbdSetStatus die Tastatur in den Raw-Mode versetzt.
  864. *                Dadurch können mittels KbdCharIn auch <CTRL>-S und <CTRL>-C
  865. *                erkannt werden.
  866. *
  867. ******************************************************************************/
  868.  
  869. void set_os2_raw (char raw_on)
  870. {
  871.   struct KbdState { unsigned short int length,
  872.                        state,
  873.                        lineend,
  874.                        nls,
  875.                        shift;   } kbst;
  876.  
  877.   KbdGetStatus (&kbst, 0);
  878.   if (raw_on)
  879.     kbst.state = (kbst.state | 4) & ~8;
  880.   else
  881.     kbst.state = (kbst.state | 8) & ~4;
  882.   KbdSetStatus (&kbst, 0);
  883. }
  884.  
  885. void show_kbd_mode()
  886. {
  887.   struct KbdState { unsigned short int length,
  888.                        state,
  889.                        lineend,
  890.                        nls,
  891.                        shift;   } kbst;
  892.  
  893.   KbdGetStatus (&kbst, 0);
  894.   printf("KbdStatus ist %d\n", kbst.state & 12);
  895. }
  896. #endif
  897.  
  898. /******************************************************************************
  899. *
  900. * Funktion     : Curses initialisieren (initscr)
  901. * --------------
  902. *
  903. * Beschreibung : Es wird die Cursorgröße ermittelt und in den globalen
  904. *                Variablen start_scan und end_scan abgelegt. Falls sich
  905. *                die Bildschirmkarte nicht im Monochrommodus befindet,
  906. *                wird der Videomodus an LINES und COLS angepaßt. Sonst wird
  907. *                LINES und COLS an die Größe des monochromen Schirms
  908. *                angepasst.
  909. *                Der Speicherplatz für den Standardbildschirm wird angefor-
  910. *                dert und mit dem Standardattribut besetzt (über die Funktion
  911. *                newwin). Anschließend werden blinkende Zeichen zugelassen.
  912. *
  913. ******************************************************************************/
  914.  
  915. void initscr()
  916. {
  917. #ifdef OS2
  918.   struct VioMode  vm;
  919.   struct VioState { short int length, func, blink; } vs;
  920.  
  921.   vm.length = sizeof (struct VioMode);
  922.   VioGetMode (&vm, 0);
  923.   old_videomode = vm;
  924. #else
  925.   union REGS  r;
  926.  
  927.   r.h.ah = 15; /* Video-Funktion <Get Current VDU Parameters> */
  928.   int86(16,&r,&r);
  929.   old_videomode = r.h.al; /* Aktuellen Video-Modus in old_videomode merken */
  930.   r.h.ah = 3; /* Funktion 3: Cursorpos. und Scan-Start/-Ende ermitteln */
  931.   r.h.bh = 0; /* Page 0 */
  932.   int86(16,&r,&r);
  933.   start_scan = r.h.ch; /* Cursor Start- und Endscan merken */
  934.   end_scan   = r.h.cl;
  935. #endif
  936.   set_videomode(); /* Abhängig von LINES und COLS den Videomodus anpassen */
  937.   last_win = curscr = newwin(LINES,COLS,0,0);
  938.   vsi = curscr->_image;
  939.   stdscr = newwin(LINES,COLS,0,0);
  940. #ifdef OS2
  941.   /* Bildschirm löschen */
  942.   VioWrtNCell ("\0", COLS*LINES, 0, 0, 0);
  943.   vs.func   = 2;
  944.   vs.length = 6;
  945.   vs.blink  = 0; /* Blinkende Zeichen zulassen */
  946.   VioSetState (&vs, 0);
  947. #else
  948.   PH_SC = (old_videomode == 7) ? /* Monochrom-Modus ? Dann VDU-RAM ab B000 */
  949.       (short int*) 0xB0000000 : (short int*) 0xB8000000;
  950.   memcpy(PH_SC,vsi,COLS*LINES*sizeof(short int)); /* Physikalischen Bildschirm löschen */
  951.   outportb(0x3D8,41);  /* Blinkende Zeichen zulassen */
  952. #endif
  953. }
  954.  
  955. /******************************************************************************
  956. *
  957. * Funktion     : Curses beenden (endwin)
  958. * --------------
  959. *
  960. * Beschreibung : Der physikalische Bildschirm wird gelöscht, das stdscr-
  961. *                Fenster wird mit der Funmtion delwin freigegeben.
  962. *                Anschließend wird der Video-Modus aktiviert, der beim Aufruf
  963. *                des Editors aktiv war.
  964. *
  965. ******************************************************************************/
  966.  
  967. void endwin()
  968. {
  969. #ifdef OS2
  970.   /* Bildschirm löschen */
  971.   VioWrtNCell ("\0", COLS*LINES, 0, 0, 0);
  972.   set_os2_raw (FALSE);
  973. #else
  974.   short int  *d;
  975.   int        i;
  976.   union REGS r;
  977.  
  978.   for (d = PH_SC , i=COLS*LINES; i ; i-- , d++)
  979.     *d = STD_ATTR*256; /* Bildschirm löschen */
  980. #endif
  981.   delwin(stdscr);     /* stdscr freigeben */
  982.   delwin(curscr);     /* curscr freigeben */
  983. #ifdef OS2
  984.   VioSetMode (&old_videomode, 0);   /* Videomodus restaurieren */
  985. #else
  986.   r.h.ah = 0; /* Funktion setze Video-Modus */
  987.   r.h.al = old_videomode;
  988.   int86(16,&r,&r);  /* Modus mit dem BIOS-Int 16 setzen */
  989. #endif
  990. }
  991.  
  992. /******************************************************************************
  993. *
  994. * Funktion     : Window-Image ins VSI kopieren (wnoutrefresh)
  995. * --------------
  996. *
  997. * Parameter    : w           :
  998. *                  Typ          : WINDOW *
  999. *                  Wertebereich : Pointer auf WINDOW-Struktur
  1000. *                  Bedeutung    : Fenster, dessen Inhalt ins VSI kopiert
  1001. *                                 werden soll.
  1002. *
  1003. * Beschreibung : Der Inhalt des Window-Images wird an der richtigen Stelle
  1004. *                in das virtuelle Screen-Image (VSI) kopiert.
  1005. *
  1006. ******************************************************************************/
  1007.  
  1008. void wnoutrefresh(w)
  1009. WINDOW *w;
  1010. {
  1011.   short int *p_vsi = vsi + COLS*w->_start_y + w->_start_x;
  1012.   short int *p_win = w->_image,y;
  1013.  
  1014.   for(y = w->_width_y;y;y--)
  1015.   {
  1016.     memcpy(p_vsi,p_win,w->_width_x*sizeof(short int)); /* Eine Zeile aus dem Fenster in den virtuellen Bildschirm kopieren */
  1017.     p_vsi += COLS; /* Eine Zeile im virtuellen Schirm nach unten */
  1018.     p_win += w->_width_x; /* Eine Zeile im Fenster nach unten */
  1019.   }
  1020. }
  1021.  
  1022. /******************************************************************************
  1023. *
  1024. * Funktion     : VSI in physikalischen Schirm kopieren (doupdate)
  1025. * --------------
  1026. *
  1027. * Beschreibung : Mit der Funktion memcpy wird das VSI ins physikalische
  1028. *                Bildschirmram kopiert. Anschließend wird der Cursor in das
  1029. *                zuletzt refreshte Fenster gesetzt (last_win).
  1030. *
  1031. ******************************************************************************/
  1032.  
  1033. void doupdate()
  1034. {
  1035. #ifdef OS2
  1036.   VioWrtCellStr (vsi, SZ_SC, 0, 0, 0);
  1037. #else
  1038.   memcpy(PH_SC,vsi,SZ_SC); /* VSI in physikalischen Schirm kopieren */
  1039. #endif
  1040.   if(last_win->_lvokflag)
  1041.     hide_cursor();
  1042.   else
  1043.     place_cursor(last_win);
  1044. }
  1045.  
  1046. /******************************************************************************
  1047. *
  1048. * Funktion     : Window-Image ins VSI und VSI auf Schirm kopieren (wrefresh)
  1049. * --------------
  1050. *
  1051. * Parameter    : w           :
  1052. *                  Typ          : WINDOW *
  1053. *                  Wertebereich : Pointer auf WINDOW-Struktur
  1054. *                  Bedeutung    : Fenster, dessen Inhalt ins VSI soll.
  1055. *
  1056. * Beschreibung : Die globale Variable last_win wird auf w gesetzt. Anschlies-
  1057. *                send wird mit der Funktion wnoutrefresh der Fensterinhalt
  1058. *                in das virtuelle Screen-Image kopiert, danach wird das mo-
  1059. *                difizierte VSI in den Bilschirmspeicher kopiert. Dazu wird
  1060. *                die Funktion doupdate verwendet.
  1061. *
  1062. ******************************************************************************/
  1063.  
  1064. void wrefresh(w)
  1065. WINDOW *w;
  1066. {
  1067. #ifdef CUR_DIRECT
  1068.   WINDOW *old_last_win = last_win;
  1069. #endif
  1070.  
  1071.   last_win = w; /* Dieses Fenster ist das, in dem der Cursor angezeigt wird */
  1072.   wnoutrefresh(w);
  1073. #ifdef CUR_DIRECT
  1074.   if (old_last_win != last_win) /* Muß Fenster erst "nach vorne" gebracht
  1075.                    werden? Dann auch doupdate() aufrufen. */
  1076. #endif
  1077.     doupdate();
  1078. #ifdef CUR_DIRECT
  1079.   else
  1080.     if(last_win->_lvokflag)    /* Cursor hier setzen, da doupdate() */
  1081.       hide_cursor();           /* nicht aufgerufen wurde.           */
  1082.     else
  1083.       place_cursor(last_win);
  1084. #endif
  1085. }
  1086.  
  1087. /******************************************************************************
  1088. *
  1089. * Funktion     : Cursoradresse in Pointer umrechnen (cur_to_poi)
  1090. * --------------
  1091. *
  1092. * Parameter    : w           :
  1093. *                  Typ          : WINDOW *
  1094. *                  Wertebereich : Pointer auf WINDOW-Struktur
  1095. *                  Bedeutung    : Fenster, aus dessen Cursoradresse und
  1096. *                                 Window-Image-Pointer ein Pointer berechnet
  1097. *                                 werden soll, der auf das Zeichen zeigt, auf
  1098. *                                 dem der Cursor steht.
  1099. *
  1100. * Ergebnis     :
  1101. *                  Typ          : short int *
  1102. *                  Wertebereich : Zeiger auf Zeichen im Window-Image
  1103. *                  Bedeutung    : Zeigt auf das Zeichen im Window-Image, auf
  1104. *                                 dem der Cursor des Fensters w steht.
  1105. *
  1106. * Beschreibung : Aus der Startadresse des Window-Images des Fensters w und
  1107. *                der Cursorposition wird die Adresse des Zeichens im WI be-
  1108. *                rechnet, auf dem der Cursor steht. Dieser Zeiger wird
  1109. *                zurückgegeben.
  1110. *
  1111. ******************************************************************************/
  1112.  
  1113. short int *cur_to_poi(w)
  1114. WINDOW *w;
  1115. {
  1116.   return(w->_image + w->_width_x*w->_cursor_y + w->_cursor_x);
  1117. }
  1118.  
  1119. /******************************************************************************
  1120. *
  1121. * Funktion     : Pointer in Cursorposition wandeln (poi_to_cur)
  1122. * --------------
  1123. *
  1124. * Parameter    : w           :
  1125. *                  Typ          : WINDOW *
  1126. *                  Wertebereich : Pointer auf WINDOW-Struktur
  1127. *                  Bedeutung    : Fenster, dessen Cursorkoordinaten angepasst
  1128. *                                 werden sollen und in dessen Window-Image
  1129. *                                 der übergebene Pointer zeigt.
  1130. *
  1131. *              : poi         :
  1132. *                  Typ          : short int *
  1133. *                  Wertebereich : Pointer in Window-Image des Fensters *w
  1134. *                  Bedeutung    : Pointer, der in Cursorkoordinaten umgewan-
  1135. *                                 delt werden soll.
  1136. *
  1137. * Beschreibung : Es werden die Cursorkoordinaten des Fensters w so gesetzt,
  1138. *                daß die korrespondierende Speicherstelle im Window-Image die
  1139. *                ist, auf die der übergebene Pointer zeigt.
  1140. *
  1141. ******************************************************************************/
  1142.  
  1143. void poi_to_cur(w,poi)
  1144. WINDOW *w;
  1145. short int *poi;
  1146. {
  1147.   int diff = poi - w->_image;
  1148.  
  1149.   w->_cursor_y = diff / w->_width_x;
  1150.   w->_cursor_x = diff % w->_width_x;
  1151. }
  1152.  
  1153. /******************************************************************************
  1154. *
  1155. * Funktion     : Fensterinhalt um eine Zeile nach oben bewegen (scroll)
  1156. * --------------
  1157. *
  1158. * Parameter    : w           :
  1159. *                  Typ          : WINDOW *
  1160. *                  Wertebereich : Pointer auf WINDOW-Struktur
  1161. *                  Bedeutung    : Fenster, dessen Inhalt bewegt werden soll
  1162. *
  1163. * Beschreibung : Der Cursor wird in die oberste Zeile des Fensters bewegt.
  1164. *                Dann wird die Funktion wdeleteln aufgerufen, die die oberste
  1165. *                Zeile löscht. Dadurch rücken die darunter gelegenen Zeilen je
  1166. *                um eine Zeile nach oben. Anschliessend wird der Cursor wieder
  1167. *                in seine alte Zeile gesetzt.
  1168. *
  1169. ******************************************************************************/
  1170.  
  1171. void scroll(w)
  1172. WINDOW *w;
  1173. {
  1174.   short int old_y = w->_cursor_y;
  1175.  
  1176.   w->_cursor_y = 0;
  1177.   wdeleteln(w);
  1178.   w->_cursor_y = old_y;
  1179. }
  1180.  
  1181. /******************************************************************************
  1182. *
  1183. * Funktion     : Text formatiert im Standardfenster ausgeben (printw)
  1184. * --------------
  1185. *
  1186. * Parameter    : format      :
  1187. *                  Typ          : char *
  1188. *                  Wertebereich : Pointer auf ASCII-Zeichenkette
  1189. *                  Bedeutung    : Formatstring (wie bei printf)
  1190. *
  1191. *              : ...         :
  1192. *                  Typ          : Parameterliste
  1193. *                  Wertebereich : ???
  1194. *                  Bedeutung    : Liste auszugebender Werte
  1195. *
  1196. * Beschreibung : Über die Funktion va_start wird ein Zeiger auf die Parame-
  1197. *                terliste gewonnen, der zusammen mit dem Formatstring an
  1198. *                wprintw_body übergeben werden kann. Dort wird der String
  1199. *                "zusammengebastelt" und ausgegeben.
  1200. *
  1201. ******************************************************************************/
  1202.  
  1203. void printw(char *format, ...)
  1204. {
  1205.   va_list param;
  1206.  
  1207.   va_start(param,format);
  1208.   wprintw_body(stdscr,format,param);
  1209.   va_end(param);
  1210. }
  1211.  
  1212. /******************************************************************************
  1213. *
  1214. * Funktion     : Text formatiert aus Standardfenster einlesen (scanw)
  1215. * --------------
  1216. *
  1217. * Parameter    : format      :
  1218. *                  Typ          : char *
  1219. *                  Wertebereich : Pointer auf ASCII-Zeichenkette
  1220. *                  Bedeutung    : Formatstring (wie bei printf)
  1221. *
  1222. *              : ...         :
  1223. *                  Typ          : Parameterliste
  1224. *                  Wertebereich : ???
  1225. *                  Bedeutung    : Liste zu belegender Variablen
  1226. *
  1227. * Beschreibung : Es wird Über die Funktion va_start ein Zeiger auf die Parame-
  1228. *                terliste gewonnen, der zusammen mit dem Formatstring an
  1229. *                wscanw_body übergeben werden kann.
  1230. *                wscanw_body besetzt die Variablen korrekt.
  1231. *
  1232. ******************************************************************************/
  1233.  
  1234. void scanw(char *format, ...)
  1235. {
  1236.   va_list param;
  1237.  
  1238.   va_start(param,format);
  1239.   wscanw_body(stdscr,format,param);
  1240.   va_end(param);
  1241. }
  1242.  
  1243. /******************************************************************************
  1244. *
  1245. * Funktion     : Text an Position X/Y im Standard-Fenster ausgeben (mvprintw)
  1246. * --------------
  1247. *
  1248. * Parameter    : y           :
  1249. *                  Typ          : short int
  1250. *                  Wertebereich : 0-LINES
  1251. *                  Bedeutung    : Startposition für Ausgabe Y
  1252. *
  1253. *              : x           :
  1254. *                  Typ          : short int
  1255. *                  Wertebereich : 0-COLS
  1256. *                  Bedeutung    : Startposition für Ausgabe X
  1257. *
  1258. *              : format      :
  1259. *                  Typ          : char *
  1260. *                  Wertebereich : Pointer auf ASCII-Zeichenkette
  1261. *                  Bedeutung    : Formatstring (wie bei printf)
  1262. *
  1263. *              : ...         :
  1264. *                  Typ          : Parameterliste
  1265. *                  Wertebereich : ???
  1266. *                  Bedeutung    : Liste auszugebender Werte
  1267. *
  1268. * Beschreibung : Über va_start wird der Pointer auf den ersten Parameter
  1269. *                ermittelt. Anschließend wird der Cursor an die gewünschte
  1270. *                Stelle bewegt. Dann wird wprintw_body aufgerufen.
  1271. *
  1272. ******************************************************************************/
  1273.  
  1274. void mvprintw(short int y, short int x, char *format, ...)
  1275. {
  1276.   va_list param;
  1277.  
  1278.   va_start(param,format);
  1279.   wmove(stdscr,y,x);
  1280.   wprintw_body(stdscr,format,param);
  1281.   va_end(param);
  1282. }
  1283.  
  1284. /******************************************************************************
  1285. *
  1286. * Funktion     : Daten an bestimmter Stelle im Std.-Fenster einlesen (mvscanw)
  1287. * --------------
  1288. *
  1289. * Parameter    : y           :
  1290. *                  Typ          : short int
  1291. *                  Wertebereich : 0-LINES
  1292. *                  Bedeutung    : Startposition für Eingabe Y
  1293. *
  1294. *              : x           :
  1295. *                  Typ          : short int
  1296. *                  Wertebereich : 0-COLS
  1297. *                  Bedeutung    : Startposition für Eingabe X
  1298. *
  1299. *              : format      :
  1300. *                  Typ          : char *
  1301. *                  Wertebereich : Pointer auf ASCII-Zeichenkette
  1302. *                  Bedeutung    : Formatstring (wie bei scanf)
  1303. *
  1304. *              : ...         :
  1305. *                  Typ          : Parameterliste
  1306. *                  Wertebereich : ???
  1307. *                  Bedeutung    : Adressen einzulesender Variablen
  1308. *
  1309. * Beschreibung : Der Anfang der Variablenliste wird mit va_start ermittelt.
  1310. *                Dann wird der Cursor an die richtige Stelle bewegt.
  1311. *                Dann wird wscanw_body aufgerufen.
  1312. *
  1313. ******************************************************************************/
  1314.  
  1315. void mvscanw(short int y, short int x, char *format, ...)
  1316. {
  1317.   va_list param;
  1318.  
  1319.   va_start(param,format);
  1320.   wmove(stdscr,y,x);
  1321.   wscanw_body(stdscr,format,param);
  1322.   va_end(param);
  1323. }
  1324.