home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 5 Edit / 05-Edit.zip / ehp14cs.zip / cur_wfcs.c < prev    next >
C/C++ Source or Header  |  1994-07-14  |  39KB  |  1,156 lines
  1. /******************************************************************************
  2. *
  3. * Modul      : cur_wfcs.c
  4. *
  5. * Funktionen : tab_to_spc (Tab in Anzahl Blanks wandeln)
  6. *              cals_pos (Position in der Eingabezeile berechnen)
  7. *              check_special (Testen, ob Zeichen Sonderzeichen ist)
  8. *              do_special (Sonderzeichen anzeigen)
  9. *              waddch (Zeichen im Fenster anzeigen)
  10. *              winsch (Zeichen im Fenster einfügen)
  11. *              wdelch (Zeichen aus Fenster löschen)
  12. *              werase (Fensterinhalt löschen)
  13. *              wmove (Cursor im Fenster setzen)
  14. *              wclrtoeol (Rest der Zeile löschen)
  15. *              wclrtobot (Rest des Fensters löschen)
  16. *              wdeleteln (Zeile im Fenster löschen)
  17. *              winsertln (Zeile in Fenster einfügen)
  18. *              nodelay (Delay-Flag setzen/löschen)
  19. *              scrollok (Scroll-Modus setzen)
  20. *              leaveok (Cursor unsichtbar machen)
  21. *              wattrset (Attribut für anzuzeigende Zeichen setzen)
  22. *              wattron (Attribut für anzuzeigende Zeichen einschalten)
  23. *              wattroff (Attribut für anzuzeigende Zeichen ausschalten)
  24. *              waddstr (String im Fenster anzeigen)
  25. *              wgetstr (String einlesen)
  26. *              wprintw_body (Rumpf für Text formatiert im Fenster ausgeben)
  27. *              wscanw_body (Rumpf für Daten aus Fenster einlesen)
  28. *              wprintw (Text formatiert im Fenster ausgeben)
  29. *              wscanw (Daten aus Fenster einlesen)
  30. *              mvwprintw (Text formatiert an Position X/Y im Fenster ausgeben)
  31. *              mvwscanw (Daten an bestimmter Stelle im Fenster einlesen)
  32. *              box (Rahmen in Fenster zeichnen)
  33. *              winch (Zeichen aus Fenster lesen)
  34. *
  35. ******************************************************************************/
  36.  
  37. #ifdef OS2
  38. #define INCL_VIO
  39. #include <os2.h>
  40. #endif
  41.  
  42. #include "curses.h"
  43. #include <stdarg.h>
  44.  
  45. void waddch (WINDOW*, short int);
  46. void wdelch (WINDOW*);
  47.  
  48. extern char buffer[],*p_in,*p_out;
  49. extern short int *cur_to_poi();
  50. extern char rawflag,nlflag;
  51.  
  52. /******************************************************************************
  53. *
  54. * Funktion     : Tab in Anzahl Blanks wandeln (tab_to_spc)
  55. * --------------
  56. *
  57. * Parameter    : pos         :
  58. *                  Typ          : int
  59. *                  Wertebereich : 0-BUFF_SIZE
  60. *                  Bedeutung    : Position des Cursors relativ zum Beginn
  61. *                                 der Eingabe
  62. *
  63. * Ergebnis     :
  64. *                  Typ          : int
  65. *                  Wertebereich : 1-8
  66. *                  Bedeutung    : Anzahl der Blanks, die eingefügt werden
  67. *                                 müssen, um zur nächsten Tab-Grenze zu kommen
  68. *
  69. * Beschreibung : Es wird die Differenz zwischen der aktuellen relativen Po-
  70. *                sition zum Beginn der Eingabe und der nächsten Tab-Grenze
  71. *                berechnet und zurückgegeben.
  72. *
  73. ******************************************************************************/
  74.  
  75. int tab_to_spc(pos)
  76. int pos;
  77. {
  78.   return(8-(pos % 8)); /* Anzahl der Blanks, die zum Auffüllen bis */
  79. }                  /* zur nächsten Tab-Grenze erforderlich sind, zurückgeben */
  80.  
  81. /******************************************************************************
  82. *
  83. * Funktion     : Position in der Eingabezeile berechnen (calc_pos)
  84. * --------------
  85. *
  86. * Parameter    : start       :
  87. *                  Typ          : int
  88. *                  Wertebereich : 0-COLS
  89. *                  Bedeutung    : Position des Eingabestarts
  90. *
  91. * Ergebnis     :
  92. *                  Typ          : int
  93. *                  Wertebereich : 0 - BUFF_SIZE-1
  94. *                  Bedeutung    : Position des Cursors relativ zum Beginn der
  95. *                                 Eingabe
  96. *
  97. * Beschreibung : Der Eingabepuffer wird von Anfang an Zeichen für Zeichen
  98. *                durchgegangen. Dabei erhöht sich für jedes normale Zeichen
  99. *                der Rückgabewert um 1. Handelt es sich jedoch um einen Tab,
  100. *                so wird mit der Funktion tab_to_spc berechnet, wieviele Blanks
  101. *                eingefügt werden mußten und das Ergebnis um diese Anzahl er-
  102. *                höht.
  103. *
  104. ******************************************************************************/
  105.  
  106. int calc_pos(start)
  107. int start;
  108. {
  109.   int i = start;
  110.   char *hilf = buffer; /* Hilfszeiger in Puffer */
  111.  
  112.   while(hilf != p_in)
  113.   {
  114.     if(*hilf != '\t')
  115.       i++;
  116.     else
  117.       i += tab_to_spc(i);
  118.     hilf++;
  119.   }
  120.   return(i-start);
  121. }
  122.  
  123. /******************************************************************************
  124. *
  125. * Funktion     : Testen, ob Zeichen Sonderzeichen ist (check_special)
  126. * --------------
  127. *
  128. * Parameter    : c           :
  129. *                  Typ          : char
  130. *                  Wertebereich : '\0'-'\255'
  131. *                  Bedeutung    : Zu testendes Zeichen
  132. *
  133. * Ergebnis     :
  134. *                  Typ          : int
  135. *                  Wertebereich : TRUE, FALSE
  136. *                  Bedeutung    : TRUE=Sonderzeichen, FALSE=kein Sonderzeichen
  137. *
  138. * Beschreibung : Das Zeichen wird auf Newline, Backspace und Tab getestet. Ist
  139. *                es in dieser Gruppe, so wird TRUE, sonst FALSE zurückgegeben.
  140. *
  141. ******************************************************************************/
  142.  
  143. int check_special(c)
  144. char c;
  145. {
  146.   switch(c)
  147.   {
  148.     case '\n':
  149.     case '\b':
  150.     case '\t':
  151.       return(TRUE);
  152.     default:
  153.       return(FALSE);
  154.   }
  155. }
  156.  
  157. /******************************************************************************
  158. *
  159. * Funktion     : Sonderzeichen anzeigen (do_special)
  160. * --------------
  161. *
  162. * Parameter    : w           :
  163. *                  Typ          : WINDOW *
  164. *                  Wertebereich : Pointer auf WINDOW-Struktur
  165. *                  Bedeutung    : Fenster, in dem das Zeichen angezeigt werden
  166. *                                 soll
  167. *
  168. *              : c           :
  169. *                  Typ          : char
  170. *                  Wertebereich : '\0'-'\255'
  171. *                  Bedeutung    : Anzuzeigendes Zeichen
  172. *
  173. * Ergebnis     :
  174. *                  Typ          : int
  175. *                  Wertebereich : TRUE, FALSE
  176. *                  Bedeutung    : TRUE : Es handelte sich um ein Sonderzeichen
  177. *                                 FALSE: Es war ein normales Zeichen
  178. *
  179. * Beschreibung : Es wird getestet, ob das Zeichen ein Newline, ein Backspace
  180. *                oder ein Tab ist. Ist dem so, wird die entsprechende Sonder-
  181. *                behandlung vorgenommen und der Wert TRUE zurückgegeben. An-
  182. *                sonsten wird FALSE zurückgegeben.
  183. *
  184. ******************************************************************************/
  185.  
  186. int do_special(w,c)
  187. WINDOW *w;
  188. char c;
  189. {
  190.   int i;
  191.  
  192.   switch(c)
  193.   {
  194.     case '\r':          /* *** Carriage return *** */
  195.       w->_cursor_x = 0;
  196.       break;
  197.     case '\n':          /* *** newline  *** */
  198.       if(nlflag)  /* Nur X auf 0, falls \n in CR-LF umgewandelt werden soll */
  199.     w->_cursor_x = 0;
  200.       if(w->_cursor_y < w->_width_y-1)
  201.     w->_cursor_y++;
  202.       else
  203.     if(w->_scrflag)
  204.       scroll(w);
  205.       return(TRUE);
  206.     case '\b':          /* *** backspace *** */
  207.       if(w->_cursor_x)   /* Steht Cursor auch nicht in der ersten Spalte ? */
  208.       {
  209.     w->_cursor_x--;
  210.     wdelch(w);
  211.       }
  212.       else              /* Wenn Cursor doch in erster Spalte, dann, falls es */
  213.       {                 /* eine darüberliegende Zeile gibt, deren letztes    */
  214.     if(w->_cursor_y) /* Zeichen löschen */
  215.     {
  216.       w->_cursor_x = w->_width_x-1;
  217.       w->_cursor_y--;
  218.       wdelch(w);
  219.     }
  220.       }
  221.       return(TRUE);
  222.     case '\t':          /* *** tab *** */
  223.       if(w->_tabflag)
  224.       {
  225.     for(i=tab_to_spc(w->_cursor_x) ; i ; i--)
  226.       waddch(w,' ');
  227.     return(TRUE);
  228.       }
  229.       else
  230.     return(FALSE);
  231.     default:
  232.       return(FALSE);
  233.   }
  234. }
  235.  
  236. /******************************************************************************
  237. *
  238. * Funktion     : Zeichen im Fenster anzeigen (waddch)
  239. * --------------
  240. *
  241. * Parameter    : w           :
  242. *                  Typ          : WINDOW *
  243. *                  Wertebereich : Pointer auf WINDOW-Struktur
  244. *                  Bedeutung    : Fenster, in dem das Zeichen angezeigt werden
  245. *                                 soll
  246. *
  247. *              : c           :
  248. *                  Typ          : short int
  249. *                  Wertebereich : ('\0'-'\255') [ +256*<Attribut> ]
  250. *                  Bedeutung    : Anzuzeigendes Zeichen, evtl. mit Attribut
  251. *
  252. * Beschreibung : In der Funktion do_special wird getestet, ob es sich bei
  253. *                dem anzuzeigenden Zeichen um ein Sonderzeichen handelt. Falls
  254. *                ja, wird dort die Behandlung vorgenommen. Ansonsten wird das
  255. *                Zeichen ins Window-Image geschrieben und die Cursorposition
  256. *                angepasst. Nötigenfalls wird der Fensterinhalt gescrollt.
  257. *
  258. ******************************************************************************/
  259.  
  260. void waddch(WINDOW *w, short int c)
  261. {
  262.   if(!do_special(w,c & 255)) /* Testen, ob Zeichen ein Sonderzeichen war */
  263.   {
  264.     if(c>>8)  /* Attribute wurden mit dem Zeichen mitgegeben ? */
  265.     {
  266. #ifdef CUR_DIRECT
  267.       VioWrtNCell (&c, 1, w->_start_y+w->_cursor_y,
  268.            w->_start_x+w->_cursor_x, 0);
  269. #endif
  270.       *cur_to_poi(w) = c;
  271.     }
  272.     else
  273.     {
  274.       if(w->_attribs) /* Irgendwelche Attribute gesetzt ? */
  275.     c = c | (w->_attribs*256);
  276.       else
  277.     c = c | (STD_ATTR*256);
  278. #ifdef CUR_DIRECT
  279.       VioWrtNCell (&c, 1, w->_start_y+w->_cursor_y,
  280.              w->_start_x+w->_cursor_x, 0);
  281. #endif
  282.       *cur_to_poi(w) = c;
  283.     }
  284.     cur_right(w,1);
  285.   }
  286. }
  287.  
  288. /******************************************************************************
  289. *
  290. * Funktion     : Zeichen im Fenster einfügen (winsch)
  291. * --------------
  292. *
  293. * Parameter    : w           :
  294. *                  Typ          : WINDOW *
  295. *                  Wertebereich : Pointer auf WINDOW-Struktur
  296. *                  Bedeutung    : Fenster, in dem das Zeichen eingefügt werden
  297. *                                 soll
  298. *
  299. *              : c           :
  300. *                  Typ          : short int
  301. *                  Wertebereich : '\0'-'\255'
  302. *                  Bedeutung    : Anzuzeigendes Zeichen
  303. *
  304. * Beschreibung : In der aktuellen Zeile im Window-Image wird für das ein-
  305. *                zufügende Zeichen Platz geschaffen, falls es sich nicht um
  306. *                Newline oder Backspace handelt. Bei einem Tab wird die
  307. *                korrekte Anzahl bis zur nächsten Tab-Grenze eingefügt.
  308. *                Anschliessend wird die Funktion waddch aufgerufen, die
  309. *                das Zeichen einfügt, bzw. das Sonderzeichen ausführt.
  310. *
  311. ******************************************************************************/
  312.  
  313. void winsch(w,c)
  314. WINDOW *w;
  315. short int c;
  316. {
  317.   short int *s,*d,anz_copy, anz_copy_si, anz_ins=1;
  318. #ifdef CUR_DIRECT
  319.   short int *buffer;
  320. #endif
  321.  
  322.   if(!check_special(c & 255)) /* Nur Platz schaffen, falls kein Sonderzeichen */
  323.   {
  324.     if((c & 255) == '\t') /* Bei Tab müssen mehrere Zeichen eingefügt werden */
  325.       anz_ins = 8*(w->_cursor_x/8 + 1);
  326.     /* Anzahl zu kopierender Zeichen bestimmen */
  327.     anz_copy = w->_width_x - w->_cursor_x - anz_ins;
  328.     if(anz_copy_si = sizeof(short int) * anz_copy)
  329.     {
  330. #ifdef CUR_DIRECT
  331.       buffer = (short int*) malloc (anz_copy_si);
  332.       VioReadCellStr (buffer, &anz_copy_si, w->_start_y+w->_cursor_y,
  333.               w->_start_x+w->_cursor_x, 0);
  334.       VioWrtCellStr (buffer, anz_copy_si, w->_start_y+w->_cursor_y,
  335.              w->_start_x+w->_cursor_x+anz_ins, 0);
  336.       free (buffer);
  337. #endif
  338.       s = cur_to_poi(w)+anz_copy-1; /* Zeiger auf aktuelles Zeichen */
  339.       d = s+anz_ins;
  340.       while(anz_copy--)
  341.     *d-- = *s--;
  342.     }
  343.   }
  344.   waddch(w,c);
  345. }
  346.  
  347. /******************************************************************************
  348. *
  349. * Funktion     : Zeichen aus Fenster löschen (wdelch)
  350. * --------------
  351. *
  352. * Parameter    : w           :
  353. *                  Typ          : WINDOW *
  354. *                  Wertebereich : Pointer auf WINDOW-Struktur
  355. *                  Bedeutung    : Fenster, aus dem Zeichen gelöscht werden soll
  356. *
  357. * Beschreibung : Alle Zeichen, die in der Cursorzeile rechts des Cursors
  358. *                stehen, werden um 1 nach links bewegt. Anschliessend wird
  359. *                das letzte Zeichen der Zeile gelöscht.
  360. *
  361. ******************************************************************************/
  362.  
  363. void wdelch(w)
  364. WINDOW *w;
  365. {
  366.   short int *d,old_x = w->_cursor_x;
  367.   char      c=256*STD_ATTR; /* zum Löschen rechts am Rand */
  368. #ifdef CUR_DIRECT
  369.   short int *buffer;        /* Puffer für zu verschiebende Zeichen */
  370.   int       anz_copy;       /* Anzahl zu verschiebender Zeichen */
  371. #endif
  372.  
  373.   d = cur_to_poi(w); /* Zeichen, auf dem der Cursor steht, merken */
  374.   if (w->_cursor_x < w->_width_x-1) /* Steht Cursor nicht am rechten Rand ? */
  375.   {
  376. #ifdef CUR_DIRECT
  377.     anz_copy = (w->_width_x-1-w->_cursor_x)*sizeof (short int);
  378.     buffer = (short int*) malloc (anz_copy*sizeof(short int));
  379.     VioReadCellStr (buffer, &anz_copy, w->_start_y+w->_cursor_y,
  380.             w->_start_x+w->_cursor_x+1, 0);
  381.     VioWrtCellStr (buffer, anz_copy, w->_start_y+w->_cursor_y,
  382.            w->_start_x+w->_cursor_x, 0);
  383.     free (buffer);
  384. #endif
  385.     memcpy(d,d+1,(w->_width_x - w->_cursor_x - 1)*sizeof(short int));
  386.   }
  387.   w->_cursor_x = w->_width_x-1;
  388. #ifdef CUR_DIRECT
  389.   VioWrtNCell (&c, 1, w->_start_y+w->_cursor_y,
  390.            w->_start_x+w->_cursor_x, 0);
  391. #endif
  392.   *cur_to_poi(w) = c; /* Letztes Zeichen in der Zeile löschen */
  393.   w->_cursor_x = old_x;
  394. }
  395.  
  396. /******************************************************************************
  397. *
  398. * Funktion     : Fensterinhalt löschen (werase)
  399. * --------------
  400. *
  401. * Parameter    : w           :
  402. *                  Typ          : WINDOW *
  403. *                  Wertebereich : Pointer auf WINDOW-Struktur
  404. *                  Bedeutung    : Fenster, dessen Inhalt gelöscht werden soll
  405. *
  406. * Beschreibung : Der Inhalt des Window-Images des angegebenen Fensters wird
  407. *                mit dem Standardattribut überschrieben, also gelöscht.
  408. *
  409. ******************************************************************************/
  410.  
  411. void werase(w)
  412. WINDOW *w;
  413. {
  414.   short int *d,i;
  415. #ifdef CUR_DIRECT
  416.   short int c = STD_ATTR*256;
  417.   int   line;
  418.  
  419.   for (line=w->_start_y; line < w->_start_y+w->_width_y; line++)
  420.     VioWrtNCell (&c, w->_width_x, line, w->_start_x, 0);
  421. #endif
  422.   for (d = w->_image , i=w->_width_y*w->_width_x ; i ; i-- , d++)
  423.     *d = STD_ATTR*256;   /* Bildschirm löschen */
  424. }
  425.  
  426. /******************************************************************************
  427. *
  428. * Funktion     : Cursor im Fenster setzen (wmove)
  429. * --------------
  430. *
  431. * Parameter    : w           :
  432. *                  Typ          : WINDOW *
  433. *                  Wertebereich : Pointer auf WINDOW-Struktur
  434. *                  Bedeutung    : Fenster, dessen Cursor gesetzt werden soll
  435. *
  436. *              : y           :
  437. *                  Typ          : short int
  438. *                  Wertebereich : 0 - w->_width_y-1
  439. *                  Bedeutung    : Neue Y-Position des Cursors
  440. *
  441. *              : x           :
  442. *                  Typ          : short int
  443. *                  Wertebereich : 0 - w->_width_x-1
  444. *                  Bedeutung    : Neue X-Position der Cursors
  445. *
  446. * Beschreibung : Falls die Angegebenen Koordinaten innerhalb des Fenster
  447. *                liegen, werden wie Werte cursor_x und cursor_y angepasst.
  448. *
  449. ******************************************************************************/
  450.  
  451. void wmove(w,y,x)
  452. WINDOW *w;
  453. short int y,x;
  454. {
  455.   if(y>=0 && y<w->_width_y && x>=0 && x<w->_width_x)
  456.   {
  457.     w->_cursor_x = x;
  458.     w->_cursor_y = y;
  459.   }
  460. }
  461.  
  462. /******************************************************************************
  463. *
  464. * Funktion     : Rest der Zeile löschen (wclrtoeol)
  465. * --------------
  466. *
  467. * Parameter    : w           :
  468. *                  Typ          : WINDOW *
  469. *                  Wertebereich : Pointer auf WINDOW-Struktur
  470. *                  Bedeutung    : Fenster, in dem Rest der Cursorzeile
  471. *                                 gelöscht werden soll.
  472. *
  473. * Beschreibung : Ab der Cursorposition bis zum Zeilenende wird alles mit
  474. *                dem Standardattribut besetzt, also gelöscht.
  475. *
  476. ******************************************************************************/
  477.  
  478. void wclrtoeol(w)
  479. WINDOW *w;
  480. {
  481.   short int *p,i;
  482. #ifdef CUR_DIRECT
  483.   short int c = 256*STD_ATTR;
  484.  
  485.   VioWrtNCell (&c, w->_width_x-w->_cursor_x, w->_start_y+w->_cursor_y,
  486.            w->_start_x+w->_cursor_x, 0);
  487. #endif
  488.   for(p=cur_to_poi(w) , i=w->_width_x-w->_cursor_x ; i ; p++ , i--)
  489.     *p = STD_ATTR*256;
  490. }
  491.  
  492. /******************************************************************************
  493. *
  494. * Funktion     : Rest der Fensters löschen (wclrtobot)
  495. * --------------
  496. *
  497. * Parameter    : w           :
  498. *                  Typ          : WINDOW *
  499. *                  Wertebereich : Pointer auf WINDOW-Struktur
  500. *                  Bedeutung    : Fenster, in dem Rest ab Cursorposition
  501. *                                 gelöscht werden soll.
  502. *
  503. * Beschreibung : Ab der Cursorposition bis zum Zeilenende und in allen Zeilen
  504. *                unter der aktuellen Cursorzeile wird alles mit
  505. *                dem Standardattribut besetzt, also gelöscht.
  506. *
  507. ******************************************************************************/
  508.  
  509. void wclrtobot(w)
  510. WINDOW *w;
  511. {
  512.   short int *p, *end=w->_image+w->_width_x*w->_width_y;
  513. #ifdef CUR_DIRECT
  514.   short int c = STD_ATTR*256;
  515.   int   line;
  516.  
  517.   wclrtoeol(w);
  518.   for (line=w->_start_y+w->_cursor_y+1; line < w->_start_y+w->_width_y; line++)
  519.     VioWrtNCell (&c, w->_width_x, line, w->_start_x, 0);
  520. #endif
  521.   for(p=cur_to_poi(w) ; p < end ; p++)
  522.     *p = STD_ATTR*256;
  523. }
  524.  
  525. /******************************************************************************
  526. *
  527. * Funktion     : Zeile im Fenster löschen (wdeleteln)
  528. * --------------
  529. *
  530. * Parameter    : w           :
  531. *                  Typ          : WINDOW *
  532. *                  Wertebereich : Pointer auf WINDOW-Struktur
  533. *                  Bedeutung    : Fenster, in dem Zeile gelöscht werden soll
  534. *
  535. * Beschreibung : Alle Zeilen hinter der, in der der Cursor steht, werden um
  536. *                eine Zeile nach oben kopiert. Die letzte Zeile des Fensters
  537. *                wird mit dem Standard-Attribut besetzt, also gelöscht.
  538. *
  539. ******************************************************************************/
  540.  
  541. void wdeleteln(w)
  542. WINDOW *w;
  543. {
  544.   short int i,*d = w->_image + w->_width_x*w->_cursor_y;
  545. #ifdef CUR_DIRECT
  546.   short int c = 256*STD_ATTR;
  547. #endif
  548.  
  549.   if(w->_cursor_y < w->_width_y-1) /* Cursor vor letzter Zeile ? */
  550.   {
  551. #ifdef CUR_DIRECT
  552.     VioScrollUp (w->_start_y+w->_cursor_y, w->_start_x,
  553.          w->_start_y+w->_width_y-1, w->_start_x+w->_width_x-1,
  554.          1, &c, 0);
  555. #endif
  556.     memcpy(d,d+w->_width_x,w->_width_x*(w->_width_y-w->_cursor_y-1)*sizeof(short int));
  557.   }
  558.   for(d=w->_image+w->_width_x*(w->_width_y-1) , i=w->_width_x ; i ; i-- , d++)
  559.     *d = STD_ATTR*256; /* letzte Zeile löschen */
  560. }
  561.  
  562. /******************************************************************************
  563. *
  564. * Funktion     : Zeile in Fenster einfügen (winsertln)
  565. * --------------
  566. *
  567. * Parameter    : w           :
  568. *                  Typ          : WINDOW *
  569. *                  Wertebereich : Pointer auf WINDOW-Struktur
  570. *                  Bedeutung    : Fenster, in dem eine Zeile eingefügt wird
  571. *
  572. * Beschreibung : Alle Zeilen inklusive der aktuellen werden um eine Zeile nach
  573. *                unten kopiert. Anschließend wird die aktuelle Zeile gelöscht.
  574. *
  575. ******************************************************************************/
  576.  
  577. void winsertln(w)
  578. WINDOW *w;
  579. {
  580.   short int i,*d,*s,n;
  581. #ifdef CUR_DIRECT
  582.   short int c = 256*STD_ATTR;
  583. #endif
  584.  
  585.   if(w->_cursor_y < w->_width_y-1) /* Cursor nicht vor letzter Zeile ? */
  586.   {
  587. #ifdef CUR_DIRECT
  588.     VioScrollDn (w->_start_y+w->_cursor_y, w->_start_x,
  589.          w->_start_y+w->_width_y-1, w->_start_x+w->_width_x-1,
  590.          1, &c, 0);
  591. #endif
  592.     n = w->_width_x*(w->_width_y-w->_cursor_y-1); /* Anzahl short ints */
  593.     d = w->_image + w->_width_x * (w->_cursor_y+1) + n; /* Destination */
  594.     s = w->_image + w->_width_x * w->_cursor_y + n; /* Source */
  595.     while(n--)
  596.       *--d = *--s; /* Zeilen kopieren */
  597.   }
  598.   for(d=w->_image+w->_width_x*w->_cursor_y , i=w->_width_x ; i ; i-- , d++)
  599.     *d = STD_ATTR*256; /* aktuelle Zeile löschen */
  600. }
  601.  
  602. /******************************************************************************
  603. *
  604. * Funktion     : Delay-Flag setzen (nodelay)
  605. * --------------
  606. *
  607. * Parameter    : w           :
  608. *                  Typ          : WINDOW *
  609. *                  Wertebereich : Pointer auf WINDOW-Struktur
  610. *                  Bedeutung    : Fenster, für das das delay-Flag manipuliert
  611. *                                 werden soll
  612. *
  613. *              : d           :
  614. *                  Typ          : char
  615. *                  Wertebereich : TRUE, FALSE
  616. *                  Bedeutung    : Gewünschter Zustand des delay-Flags
  617. *
  618. * Beschreibung : dlyflag wird auf d gesetzt.
  619. *
  620. ******************************************************************************/
  621.  
  622. void nodelay(w,d)
  623. WINDOW *w;
  624. char d;
  625. {
  626.   w->_dlyflag = !d;
  627. }
  628.  
  629. /******************************************************************************
  630. *
  631. * Funktion     : Scroll-Modus setzen (scrollok)
  632. * --------------
  633. *
  634. * Parameter    : w           :
  635. *                  Typ          : WINDOW *
  636. *                  Wertebereich : Pointer auf WINDOW-Struktur
  637. *                  Bedeutung    : Fenster, für das der scroll-mode manipuliert
  638. *                                 werden soll
  639. *
  640. *              : s           :
  641. *                  Typ          : char
  642. *                  Wertebereich : TRUE, FALSE
  643. *                  Bedeutung    : Gewünschter Zustand des scroll-Flags
  644. *
  645. * Beschreibung : Das scroll-Flag wird auf s gesetzt.
  646. *
  647. ******************************************************************************/
  648.  
  649. void scrollok(w,s)
  650. WINDOW *w;
  651. char s;
  652. {
  653.   w->_scrflag = s;
  654. }
  655.  
  656. /******************************************************************************
  657. *
  658. * Funktion     : Leavok-Modus setzen (leaveok)
  659. * --------------
  660. *
  661. * Parameter    : w           :
  662. *                  Typ          : WINDOW *
  663. *                  Wertebereich : Pointer auf WINDOW-Struktur
  664. *                  Bedeutung    : Fenster, für das der leaveok-mode manipuliert
  665. *                                 werden soll
  666. *
  667. *              : f           :
  668. *                  Typ          : char
  669. *                  Wertebereich : TRUE, FALSE
  670. *                  Bedeutung    : Gewünschter Zustand des leaveok-Flags
  671. *
  672. * Beschreibung : Das leaveok-Flag wird auf s gesetzt.
  673. *
  674. ******************************************************************************/
  675.  
  676. void leaveok(w,f)
  677. WINDOW *w;
  678. char f;
  679. {
  680.   w->_lvokflag = f;
  681. }
  682.  
  683. /******************************************************************************
  684. *
  685. * Funktion     : Attribut für anzuzeigende Zeichen setzen (wattrset)
  686. * --------------
  687. *
  688. * Parameter    : w           :
  689. *                  Typ          : WINDOW *
  690. *                  Wertebereich : Pointer auf WINDOW-Struktur
  691. *                  Bedeutung    : Fenster, für das Attribute manipuliert
  692. *                                 werden sollen
  693. *
  694. *              : a           :
  695. *                  Typ          : short int
  696. *                  Wertebereich : 256 * (0 - 255)
  697. *                  Bedeutung    : Neues Attribut
  698. *
  699. * Beschreibung : Die Attribute fuer Fenster w werden auf a gesetzt.
  700. *
  701. ******************************************************************************/
  702.  
  703. void wattrset(w,a)
  704. WINDOW *w;
  705. short int a;
  706. {
  707.   w->_attribs = a;
  708. }
  709.  
  710. /******************************************************************************
  711. *
  712. * Funktion     : Attribut für anzuzeigende Zeichen einschalten (wattron)
  713. * --------------
  714. *
  715. * Parameter    : w           :
  716. *                  Typ          : WINDOW *
  717. *                  Wertebereich : Pointer auf WINDOW-Struktur
  718. *                  Bedeutung    : Fenster, für das Attribute manipuliert
  719. *                                 werden sollen
  720. *
  721. *              : a           :
  722. *                  Typ          : short int
  723. *                  Wertebereich : 256 * (0 - 255)
  724. *                  Bedeutung    : einzuschaltendes Attribut
  725. *
  726. * Beschreibung : Zum attribs des Fensters w wird a dazugeodert.
  727. *
  728. ******************************************************************************/
  729.  
  730. void wattron(w,a)
  731. WINDOW *w;
  732. short int a;
  733. {
  734.   w->_attribs |= a;
  735. }
  736.  
  737. /******************************************************************************
  738. *
  739. * Funktion     : Attribut für anzuzeigende Zeichen ausschalten (wattroff)
  740. * --------------
  741. *
  742. * Parameter    : w           :
  743. *                  Typ          : WINDOW *
  744. *                  Wertebereich : Pointer auf WINDOW-Struktur
  745. *                  Bedeutung    : Fenster, für das Attribute manipuliert
  746. *                                 werden sollen
  747. *
  748. *              : a           :
  749. *                  Typ          : short int
  750. *                  Wertebereich : 256 * (0 - 255)
  751. *                  Bedeutung    : auszuschaltendes Attribut
  752. *
  753. * Beschreibung : Vom attribs des Fensters w wird a weggeandet.
  754. *
  755. ******************************************************************************/
  756.  
  757. void wattroff(w,a)
  758. WINDOW *w;
  759. short int a;
  760. {
  761.   w->_attribs &= ~a;
  762. }
  763.  
  764. /******************************************************************************
  765. *
  766. * Funktion     : String im Fenster anzeigen (waddstr)
  767. * --------------
  768. *
  769. * Parameter    : w           :
  770. *                  Typ          : WINDOW *
  771. *                  Wertebereich : Pointer auf WINDOW-Struktur
  772. *                  Bedeutung    : Fenster, in dem der String angeiezgt werden
  773. *                                 soll
  774. *
  775. *              : s           :
  776. *                  Typ          : char *
  777. *                  Wertebereich : Zeiger auf ASCII-Zeichenkette
  778. *                  Bedeutung    : Anzuzeigender String
  779. *
  780. * Beschreibung : Jedes Zeichen des String wird der Funktion waddch übergeben
  781. *
  782. ******************************************************************************/
  783.  
  784. void waddstr(w,s)
  785. WINDOW *w;
  786. char *s;
  787. {
  788.   if(s)
  789.     while(*s)
  790.       waddch(w,(unsigned short int) *s++);
  791. }
  792.  
  793. /******************************************************************************
  794. *
  795. * Funktion     : String einlesen (wgetstr)
  796. * --------------
  797. *
  798. * Parameter    : w           :
  799. *                  Typ          : WINDOW *
  800. *                  Wertebereich : Pointer auf WINDOW-Struktur
  801. *                  Bedeutung    : Fenster, in dem eingelesene Zeichen evtl.
  802. *                                 angezeigt werden sollen
  803. *
  804. *              : s           :
  805. *                  Typ          : char *
  806. *                  Wertebereich : Pointer auf reservierten Speicherbereich
  807. *                  Bedeutung    : Platz, wohin der String gelesen werden soll
  808. *
  809. * Ergebnis     :
  810. *                  Typ          : char *
  811. *                  Wertebereich : Pointer auf ASCII-Zeichenkette
  812. *                  Bedeutung    : Eingelesener String, identisch mit s
  813. *
  814. * Beschreibung : Es wird wgetch aufgerufen und das eingelesene Zeichen an den
  815. *                bisher eingelesenen String angehängt. Ist das Zeichen '\n',
  816. *                so bricht die Schleife ab, das '\n' wird durch '\0' ersetzt.
  817. *                Der Pointer auf den Anfang des eingelesenen Strings wird
  818. *                zurückgegeben.
  819. *
  820. ******************************************************************************/
  821.  
  822. char *wgetstr(w,s)
  823. WINDOW *w;
  824. char *s;
  825. {
  826.   char *c = s,old_raw = rawflag;
  827.  
  828.   rawflag = FALSE; /* Strings werden stets im cooked-Mode eingelesen */
  829.   do
  830.     *c++ = (char) wgetch(w);
  831.   while((c[-1] != '\n' && nlflag) || (c[-1] != '\r' && !nlflag));
  832.   *(--c) = '\0'; /* Newline durch NULL-Charakter ersetzen */
  833.   rawflag = old_raw;
  834.   return(s);
  835. }
  836.  
  837. /******************************************************************************
  838. *
  839. * Funktion     : Rumpf für Text formatiert im Fenster ausgeben (wprintw_body)
  840. * --------------
  841. *
  842. * Parameter    : w           :
  843. *                  Typ          : WINDOW *
  844. *                  Wertebereich : Pointer auf WINDOW-Struktur
  845. *                  Bedeutung    : Fenster, in das Text kommen soll
  846. *
  847. *              : format      :
  848. *                  Typ          : char *
  849. *                  Wertebereich : Pointer auf ASCII-Zeichenkette
  850. *                  Bedeutung    : Formatstring (wie bei printf)
  851. *
  852. *              : param       :
  853. *                  Typ          : va_list
  854. *                  Wertebereich : Pointer auf Parameter
  855. *                  Bedeutung    : Liste auszugebender Werte
  856. *
  857. * Beschreibung : Der Formatstring wird zusammen mit dem Pointer auf die
  858. *                Parameterliste an vsprintf übergeben. Der mit vsprintf
  859. *                erzeugte String wird mit waddstr in das gewünschte
  860. *                Fenster ausgegeben.
  861. *
  862. ******************************************************************************/
  863.  
  864. void wprintw_body(w,format,param)
  865. WINDOW *w;
  866. char *format;
  867. va_list param;
  868. {
  869.   char buff[BUFF_SIZE+1];
  870.  
  871.   vsprintf(buff,format,param);
  872.   waddstr(w,buff);
  873. }
  874.  
  875. /******************************************************************************
  876. *
  877. * Funktion     : Rumpf für Daten aus Fenster einlesen (wscanw_body)
  878. * --------------
  879. *
  880. * Parameter    : w           :
  881. *                  Typ          : WINDOW *
  882. *                  Wertebereich : Pointer auf WINDOW-Struktur
  883. *                  Bedeutung    : Fenster, in das Text kommen soll
  884. *
  885. *              : format      :
  886. *                  Typ          : char *
  887. *                  Wertebereich : Pointer auf ASCII-Zeichenkette
  888. *                  Bedeutung    : Formatstring (wie bei scanf)
  889. *
  890. *              : param       :
  891. *                  Typ          : va_list
  892. *                  Wertebereich : Pointer auf Parameter
  893. *                  Bedeutung    : Adressen einzulesender Variablen
  894. *
  895. * Beschreibung : Mit wgetstr wird ein String eingelesen. Anschließend werden
  896. *                Über die Funktion vsscanf die Variablen richtig besetzt.
  897. *
  898. ******************************************************************************/
  899.  
  900. void wscanw_body(w,format,param)
  901. WINDOW *w;
  902. char *format;
  903. va_list param;
  904. {
  905.   char buff[BUFF_SIZE+1];
  906.  
  907.   wgetstr(w,buff);
  908.   vsscanf(buff,format,param);
  909. }
  910.  
  911. /******************************************************************************
  912. *
  913. * Funktion     : Text formatiert im Fenster ausgeben (wprintw)
  914. * --------------
  915. *
  916. * Parameter    : w           :
  917. *                  Typ          : WINDOW *
  918. *                  Wertebereich : Pointer auf WINDOW-Struktur
  919. *                  Bedeutung    : Fenster, in das Text kommen soll
  920. *
  921. *              : format      :
  922. *                  Typ          : char *
  923. *                  Wertebereich : Pointer auf ASCII-Zeichenkette
  924. *                  Bedeutung    : Formatstring (wie bei printf)
  925. *
  926. *              : ...         :
  927. *                  Typ          : Parameterliste
  928. *                  Wertebereich : ???
  929. *                  Bedeutung    : Liste auszugebender Werte
  930. *
  931. * Beschreibung : Über va_start wird der Pointer auf den ersten Parameter
  932. *                ermittelt. Dann wird wprintw_body aufgerufen.
  933. *
  934. ******************************************************************************/
  935.  
  936. void wprintw(WINDOW *w, char *format, ...)
  937. {
  938.   va_list param;
  939.  
  940.   va_start(param,format);
  941.   wprintw_body(w,format,param);
  942.   va_end(param);
  943. }
  944.  
  945. /******************************************************************************
  946. *
  947. * Funktion     : Daten aus Fenster einlesen (wscanw)
  948. * --------------
  949. *
  950. * Parameter    : w           :
  951. *                  Typ          : WINDOW *
  952. *                  Wertebereich : Pointer auf WINDOW-Struktur
  953. *                  Bedeutung    : Fenster, in das Text kommen soll
  954. *
  955. *              : format      :
  956. *                  Typ          : char *
  957. *                  Wertebereich : Pointer auf ASCII-Zeichenkette
  958. *                  Bedeutung    : Formatstring (wie bei scanf)
  959. *
  960. *              : ...         :
  961. *                  Typ          : Parameterliste
  962. *                  Wertebereich : ???
  963. *                  Bedeutung    : Adressen einzulesender Variablen
  964. *
  965. * Beschreibung : Der Anfang der Variablenliste wird mit va_start ermittelt.
  966. *                Dann wird wscanw_body aufgerufen.
  967. *
  968. ******************************************************************************/
  969.  
  970. void wscanw(WINDOW *w, char *format, ...)
  971. {
  972.   va_list param;
  973.  
  974.   va_start(param,format);
  975.   wscanw_body(w,format,param);
  976.   va_end(param);
  977. }
  978.  
  979. /******************************************************************************
  980. *
  981. * Funktion     : Text formatiert an Position X/Y im Fenster ausgeben(mvwprintw)
  982. * --------------
  983. *
  984. * Parameter    : w           :
  985. *                  Typ          : WINDOW *
  986. *                  Wertebereich : Pointer auf WINDOW-Struktur
  987. *                  Bedeutung    : Fenster, in das Text kommen soll
  988. *
  989. *              : y           :
  990. *                  Typ          : short int
  991. *                  Wertebereich : 0-LINES
  992. *                  Bedeutung    : Startposition für Ausgabe Y
  993. *
  994. *              : x           :
  995. *                  Typ          : short int
  996. *                  Wertebereich : 0-COLS
  997. *                  Bedeutung    : Startposition für Ausgabe X
  998. *
  999. *              : format      :
  1000. *                  Typ          : char *
  1001. *                  Wertebereich : Pointer auf ASCII-Zeichenkette
  1002. *                  Bedeutung    : Formatstring (wie bei printf)
  1003. *
  1004. *              : ...         :
  1005. *                  Typ          : Parameterliste
  1006. *                  Wertebereich : ???
  1007. *                  Bedeutung    : Liste auszugebender Werte
  1008. *
  1009. * Beschreibung : Über va_start wird der Pointer auf den ersten Parameter
  1010. *                ermittelt. Anschließend wird der Cursor an die gewünschte
  1011. *                Stelle bewegt. Dann wird wprintw_body aufgerufen.
  1012. *
  1013. ******************************************************************************/
  1014.  
  1015. void mvwprintw(WINDOW *w, short int y, short int x, char *format, ...)
  1016. {
  1017.   va_list param;
  1018.  
  1019.   va_start(param,format);
  1020.   wmove(w,y,x);
  1021.   wprintw_body(w,format,param);
  1022.   va_end(param);
  1023. }
  1024.  
  1025. /******************************************************************************
  1026. *
  1027. * Funktion     : Daten an bestimmter Stelle im Fenster einlesen (mvwscanw)
  1028. * --------------
  1029. *
  1030. * Parameter    : w           :
  1031. *                  Typ          : WINDOW *
  1032. *                  Wertebereich : Pointer auf WINDOW-Struktur
  1033. *                  Bedeutung    : Fenster, in das Text kommen soll
  1034. *
  1035. *              : y           :
  1036. *                  Typ          : short int
  1037. *                  Wertebereich : 0-LINES
  1038. *                  Bedeutung    : Startposition für Eingabe Y
  1039. *
  1040. *              : x           :
  1041. *                  Typ          : short int
  1042. *                  Wertebereich : 0-COLS
  1043. *                  Bedeutung    : Startposition für Eingabe X
  1044. *
  1045. *              : format      :
  1046. *                  Typ          : char *
  1047. *                  Wertebereich : Pointer auf ASCII-Zeichenkette
  1048. *                  Bedeutung    : Formatstring (wie bei scanf)
  1049. *
  1050. *              : ...         :
  1051. *                  Typ          : Parameterliste
  1052. *                  Wertebereich : ???
  1053. *                  Bedeutung    : Adressen einzulesender Variablen
  1054. *
  1055. * Beschreibung : Der Anfang der Variablenliste wird mit va_start ermittelt.
  1056. *                Dann wird der Cursor an die richtige Stelle bewegt.
  1057. *                Dann wird wscanw_body aufgerufen.
  1058. *
  1059. ******************************************************************************/
  1060.  
  1061. void mvwscanw(WINDOW *w, short int y, short int x, char *format, ...)
  1062. {
  1063.   va_list param;
  1064.  
  1065.   va_start(param,format);
  1066.   wmove(w,y,x);
  1067.   wscanw_body(w,format,param);
  1068.   va_end(param);
  1069. }
  1070.  
  1071. /******************************************************************************
  1072. *
  1073. * Funktion     : Rahmen in Fenster zeichnen (box)
  1074. * --------------
  1075. *
  1076. * Parameter    : w           :
  1077. *                  Typ          : WINDOW *
  1078. *                  Wertebereich : Pointer auf WINDOW-Struktur
  1079. *                  Bedeutung    : Fenster, in dem Rahmen erscheinen soll
  1080. *
  1081. *              : sr          :
  1082. *                  Typ          : char
  1083. *                  Wertebereich : '\0'-'\255'
  1084. *                  Bedeutung    : Zeichen für senkrechte Ränder
  1085. *
  1086. *              : wr          :
  1087. *                  Typ          : char
  1088. *                  Wertebereich : '\0'-'\255'
  1089. *                  Bedeutung    : Zeichen für waagerechte Ränder
  1090. *
  1091. * Beschreibung : In das angegebene Fenster wird ein Rahmen eingezeichnet.
  1092. *                Es wird kein Refresh vorgenommen.
  1093. *
  1094. ******************************************************************************/
  1095.  
  1096. void box(w,sr,wr)
  1097. WINDOW *w;
  1098. char sr,wr;
  1099. {
  1100.   int i;
  1101.   char old_scroll = w->_scrflag;
  1102.  
  1103.   w->_scrflag = FALSE; /* Fenster soll nicht scrollen, wenn unten rechts die */
  1104.   wmove(w,0,0);      /* Ecke eingezeichnet wird. */
  1105.   waddch(w,'┌');
  1106.   wmove(w,0,w->_width_x-1);
  1107.   waddch(w,'┐');
  1108.   wmove(w,w->_width_y-1,0);
  1109.   waddch(w,'└');
  1110.   wmove(w,w->_width_y-1,w->_width_x-1);
  1111.   waddch(w,'┘');
  1112.   for(i=1 ; i < w->_width_x-1 ; i++)
  1113.   {
  1114.     wmove(w,0,i);    /* Rand oben */
  1115.     waddch(w,wr);
  1116.     wmove(w,w->_width_y-1,i);
  1117.     waddch(w,wr);   /* Rand unten */
  1118.   }
  1119.   for(i=1 ; i < w->_width_y-1 ; i++)
  1120.   {
  1121.     wmove(w,i,0);    /* Rand links */
  1122.     waddch(w,sr);
  1123.     wmove(w,i,w->_width_x-1);
  1124.     waddch(w,sr);   /* Rand rechts */
  1125.   }
  1126.   w->_scrflag = old_scroll;
  1127. }
  1128.  
  1129. /******************************************************************************
  1130. *
  1131. * Funktion     : Zeichen aus Fenster lesen (winch)
  1132. * --------------
  1133. *
  1134. * Parameter    : w           :
  1135. *                  Typ          : WINDOW *
  1136. *                  Wertebereich : Pointer auf WINDOW-Struktur
  1137. *                  Bedeutung    : Fenster, aus dem gelesen werden soll
  1138. *
  1139. * Ergebnis     :
  1140. *                  Typ          : short int
  1141. *                  Wertebereich : '\0' - MAXINT
  1142. *                  Bedeutung    : Zeichen samt Attributen, das an der
  1143. *                                 angegebenen Position steht
  1144. *
  1145. * Beschreibung : Im gewünschten Fenster wird an der aktuellen Position
  1146. *                mit cur_to_poi das dort befindliche Zeichen samt Attributen
  1147. *                ermittelt und zurückgegeben.
  1148. *
  1149. ******************************************************************************/
  1150.  
  1151. short int winch(w)
  1152. WINDOW *w;
  1153. {
  1154.   return(*cur_to_poi(w));
  1155. }
  1156.