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