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