home *** CD-ROM | disk | FTP | other *** search
/ Mega Top 1 / os2_top1.zip / os2_top1 / APPS / EDITORS / EHP12 / CUR_WGET.C < prev    next >
C/C++ Source or Header  |  1993-10-27  |  47KB  |  1,105 lines
  1. /******************************************************************************
  2. *
  3. * Modul      : cur_wget.c
  4. *
  5. * Funktionen : getch (Zeichen ungepuffert von Tastatur lesen)
  6. *              edit_left (Cursor in Eingabe nach links)
  7. *              edit_right (Cursor in Eingabe nach rechts)
  8. *              edit_del (Zeichen in Eingabe löschen)
  9. *              wort_ende (Testen, ob Zeichen Worttrenner)
  10. *              edit_ctrlright (Cursor in Eingabe ein Wort nach rechts)
  11. *              edit_ctrlleft (Cursor in Eingabe ein Wort nach links)
  12. *              edit_home (Cursor an Eingabeanfang)
  13. *              edit_end (Cursor an Eingabeende)
  14. *              treat_edit_keys (Edit-Tasten behandeln)
  15. *              inp_out (Eingabe ausgeben)
  16. *              treat_backspace (Backspace beim Edieren behandeln)
  17. *              buf_insert (Ein Zeichen in Puffer einfügen)
  18. *              getch_cooked (Zeichen gepuffet einlesen)
  19. *              wgetch (Zeichen einlesen)
  20. *
  21. ******************************************************************************/
  22.  
  23. #include "curses.h"
  24. #include "keys.h"
  25. #undef getch()   /* Damit C-getch aufgerufen werden kann */
  26.  
  27. void inp_out(WINDOW*, short int**, char**, short int**);
  28.  
  29. extern short int *cur_to_poi();
  30. extern char rawflag,echoflag,nlflag;
  31.  
  32. char buffer[BUFF_SIZE+1],*p_in=buffer,*p_out=buffer; /* Zeichenpuffer für wgetch */
  33.  
  34. #ifdef OS2
  35. #define INCL_KBD
  36. #include <os2.h>
  37.  
  38. /******************************************************************************
  39. *
  40. * Funktion     : Zeichen ungepuffert von Tastatur lesen (getch)
  41. * --------------
  42. *
  43. * Parameter    : wait        :
  44. *                  Typ          : char
  45. *                  Wertebereich : TRUE, FALSE
  46. *                  Bedeutung    : Gibt an, ob auf das Eingabezeichen gewartet
  47. *                                 werden soll.
  48. *
  49. * Ergebnis     :
  50. *                  Typ          : short int
  51. *                  Wertebereich : Ein Tastaturcode, der OS/2-spezifisch sein kann
  52. *                                 Low-Byte=0 bedeutet Sondertaste (F, Ctrl-rechts o.ä.)
  53. *                                 oder "kein Zeichen vorhanden". In letzterem Fall
  54. *                                 ist der komplette Rückgabewert jedoch 0.
  55. *                  Bedeutung    : Das eingelesene Zeichen, oder 0, falls nicht
  56. *                                 auf ein Zeichen gewartet werden sollte (wait==FALSE)
  57. *                                 und kein Zeichen anlag.
  58. *
  59. * Beschreibung : Mittels des OS/2 Systemaufrufs KbdCharIn wird
  60. *                ein Zeichen von der Tastatur gelesen und decodiert.
  61. *                Wenn sich die Tastatur im Raw-Mode befindet, können
  62. *                auch <CTRL>-S und <CTRL>-C erkannt werden.
  63. *
  64. ******************************************************************************/
  65.  
  66. short int getch (char wait)
  67. {
  68.   struct CharInBuffer { unsigned  char ascii,
  69.                   scan_code,
  70.                   status,
  71.                   reserved;
  72.             short int shifts;
  73.             long  int time_stamp; } cib;
  74.  
  75.   KbdCharIn (&cib, (short) !wait, 0);
  76.   if (!wait) /* Wenn nicht gewartet werden sollte, dann prüfen, */
  77.     if (!(cib.status & 64)) /* ob ein Zeichen gelesen werden konnte. */
  78.       return 0;
  79.   if (cib.ascii == (unsigned char) 0xE0)
  80.      cib.ascii = 0;
  81.   if (cib.ascii != 0)
  82.     cib.scan_code = 0;
  83.   return (short int) cib.ascii + 256 * (short int) cib.scan_code;
  84. }
  85. #endif
  86.  
  87. /******************************************************************************
  88. *
  89. * Funktion     : Cursor in Eingabe nach links (edit_left)
  90. * --------------
  91. *
  92. * Parameter    : w           :
  93. *                  Typ          : WINDOW *
  94. *                  Wertebereich : Pointer auf WINDOW-Struktur
  95. *                  Bedeutung    : Fenster, in dem evtl. Cursor bewegt werden
  96. *                                 soll
  97. *
  98. *              : buff_first  :
  99. *                  Typ          : char **
  100. *                  Wertebereich : Doppelpointer auf Zeichen in buffer
  101. *                  Bedeutung    : Erstes sichtbares Zeichen in buffer
  102. *
  103. *              : buff_last   :
  104. *                  Typ          : char **
  105. *                  Wertebereich : Doppelpointer auf Zeichen in buffer
  106. *                  Bedeutung    : Letztes sichtbares Zeichen in buffer
  107. *
  108. *              : pos_first   :
  109. *                  Typ          : short int **
  110. *                  Wertebereich : Doppelpointer in Window-Image
  111. *                  Bedeutung    : Zeigt auf die Stelle im Window-Image, wo
  112. *                                 theoretisch das erste Zeichen der Eingabe
  113. *                                 stehen würde (kann kleiner als image sein)
  114. *
  115. *              : pos_last    :
  116. *                  Typ          : short int **
  117. *                  Wertebereich : Doppelpointer in Window-Image
  118. *                  Bedeutung    : Zeigt auf die Stelle im Window-Image, wo
  119. *                                 theoretisch das letzte Zeichen der Eingabe
  120. *                                 stehen würde (kann hinters image zeigen)
  121. *
  122. *              : pos_lasts   :
  123. *                  Typ          : short int **
  124. *                  Wertebereich : Doppelpointer in Window-Image
  125. *                  Bedeutung    : Zeigt auf die Stelle im Window-Image, wo
  126. *                                 das letzte sichtbare Zeichen der Eingabe
  127. *                                 steht.
  128. *
  129. *              : old_pos     :
  130. *                  Typ          : short int **
  131. *                  Wertebereich : Doppelpointer in Window-Image
  132. *                  Bedeutung    : Zeigt auf die Stelle im Window-Image, bis wo
  133. *                                 vor der letzten Ausgabe der Eingabe der
  134. *                                 Text auf dem Bildschirm ging.
  135. *
  136. * Beschreibung : Falls eingegebene Zeichen angezeigt werden (echo), so wird
  137. *                zunächst getestet, ob der Cursor noch eins nach links bewegt
  138. *                werden kann. Falls nein, wird gar nichts gemacht. Sonst wird
  139. *                der Zeiger in den Puffer dekrementiert. Ist man dadurch links
  140. *                oben aus dem Schirm gelaufen, so wird der korrekte Teil der
  141. *                Eingabe nochmal angezeigt und die nötigen Variablen werden
  142. *                angepasst (pos_first, pos_last etc.)
  143. *
  144. ******************************************************************************/
  145.  
  146. void edit_left(w,buff_first,buff_last,pos_first,pos_last,pos_lasts,old_pos)
  147. WINDOW *w;
  148. char   **buff_first,**buff_last;
  149. short int  **pos_first, **pos_last, **pos_lasts, **old_pos;
  150. {
  151.   int i,pos;
  152.  
  153.   if(p_in > buffer)
  154.   {
  155.     p_in--;
  156.     if(echoflag)
  157.     {
  158.       if(p_in < *buff_first)  /* Links vom ersten sichtbaren Zeichen ? */
  159.       {
  160.     (*pos_first)++;
  161.     (*pos_last)++;
  162.     (*buff_first)--;
  163.     inp_out(w,old_pos,buff_last,pos_lasts);
  164.     wrefresh(w);
  165.       }
  166.       else
  167.       {
  168.     cur_left(w,1);
  169.     place_cursor(w);
  170.       }
  171.     }
  172.   }
  173. }
  174.  
  175. /******************************************************************************
  176. *
  177. * Funktion     : Cursor in Eingabe nach rechts (edit_right)
  178. * --------------
  179. *
  180. * Parameter    : w           :
  181. *                  Typ          : WINDOW *
  182. *                  Wertebereich : Pointer auf WINDOW-Struktur
  183. *                  Bedeutung    : Fenster, in dem evtl. Cursor bewegt werden
  184. *                                 soll
  185. *
  186. *              : buff_first  :
  187. *                  Typ          : char **
  188. *                  Wertebereich : Doppelpointer auf Zeichen in buffer
  189. *                  Bedeutung    : Erstes sichtbares Zeichen in buffer
  190. *
  191. *              : buff_last   :
  192. *                  Typ          : char **
  193. *                  Wertebereich : Doppelpointer auf Zeichen in buffer
  194. *                  Bedeutung    : Letztes sichtbares Zeichen in buffer
  195. *
  196. *              : pos_first   :
  197. *                  Typ          : short int **
  198. *                  Wertebereich : Doppelpointer in Window-Image
  199. *                  Bedeutung    : Zeigt auf die Stelle im Window-Image, wo
  200. *                                 theoretisch das erste Zeichen der Eingabe
  201. *                                 stehen würde (kann kleiner als image sein)
  202. *
  203. *              : pos_firsts  :
  204. *                  Typ          : short int **
  205. *                  Wertebereich : Doppelpointer in Window-Image
  206. *                  Bedeutung    : Zeigt auf die Stelle im Window-Image, wo
  207. *                                 das letzte sichtbare Zeichen der Eingabe
  208. *                                 steht.
  209. *
  210. *              : pos_last    :
  211. *                  Typ          : short int **
  212. *                  Wertebereich : Doppelpointer in Window-Image
  213. *                  Bedeutung    : Zeigt auf die Stelle im Window-Image, wo
  214. *                                 theoretisch das letzte Zeichen der Eingabe
  215. *                                 stehen würde (kann hinters image zeigen)
  216. *
  217. *              : pos_lasts   :
  218. *                  Typ          : short int **
  219. *                  Wertebereich : Doppelpointer in Window-Image
  220. *                  Bedeutung    : Zeigt auf die Stelle im Window-Image, wo
  221. *                                 das letzte sichtbare Zeichen der Eingabe
  222. *                                 steht.
  223. *
  224. *              : old_pos     :
  225. *                  Typ          : short int **
  226. *                  Wertebereich : Doppelpointer in Window-Image
  227. *                  Bedeutung    : Zeigt auf die Stelle im Window-Image, bis wo
  228. *                                 vor der letzten Ausgabe der Eingabe der
  229. *                                 Text auf dem Bildschirm ging.
  230. *
  231. * Beschreibung : Es wird zunächst getestet, ob sich der Cursor nicht am Ende
  232. *                des bisher eingegebenen Strings befindet. Ist dem so, dann
  233. *                geschieht nichts. Sonst wird, falls echoflag gesetzt ist, der
  234. *                Cursor um 1 nach rechts bewegt. Anschliessend wird p_in
  235. *                angepasst. Wurde durch die Cursorbewegung gescrollt, wird
  236. *                die nächste Zeile der Eingabe angezeigt und die Variablen
  237. *                buff_first etc. angepasst.
  238. *
  239. ******************************************************************************/
  240.  
  241. void edit_right(w,buff_first,buff_last,pos_first,pos_firsts,pos_last,pos_lasts,old_pos)
  242. WINDOW *w;
  243. char   **buff_first,**buff_last;
  244. short int **pos_first, **pos_firsts, **pos_last, **pos_lasts, **old_pos;
  245. {
  246.   short int old_y;
  247.  
  248.   if(*p_in)  /* Geht nur, falls man nicht am Ende steht */
  249.   {
  250.     p_in++;
  251.     if(echoflag)
  252.     {
  253.       old_y = w->_cursor_y;
  254.       cur_right(w,1);   /* Cursor um 1 nach rechts */
  255.       if(!w->_cursor_x && old_y == w->_width_y-1)  /* Wenn gescrollt wurde, dann in letzter Zeile */
  256.       {                 /* korrekten Teil der Eingabe anzeigen         */
  257.     *pos_first -= w->_width_x;  /* Erstes Zeichen eine Zeile weiter oben */
  258.     *pos_last  -= w->_width_x;
  259.     if(*pos_firsts > w->_image) /* Wo steht nun das erste sichtbare */
  260.     {                         /* Zeichen der Eingabe ?            */
  261.       *pos_firsts -= w->_width_x;
  262.       if(*pos_firsts < w->_image)
  263.         *pos_firsts = w->_image;
  264.     }
  265.     *buff_first = buffer + (*pos_firsts - *pos_first);
  266.     inp_out(w,old_pos,buff_last,pos_lasts);
  267.     wrefresh(w);
  268.       }
  269.       else
  270.     place_cursor(w);
  271.     }
  272.   }
  273. }
  274.  
  275. /******************************************************************************
  276. *
  277. * Funktion     : Zeichen in Eingabe löschen (edit_del)
  278. * --------------
  279. *
  280. * Parameter    : w           :
  281. *                  Typ          : WINDOW *
  282. *                  Wertebereich : Pointer auf WINDOW-Struktur
  283. *                  Bedeutung    : Fenster, in dem evtl. Cursor bewegt werden
  284. *                                 soll
  285. *
  286. *              : buff_last   :
  287. *                  Typ          : char **
  288. *                  Wertebereich : Doppelpointer auf Zeichen in buffer
  289. *                  Bedeutung    : Letztes sichtbares Zeichen in buffer
  290. *
  291. *              : pos_last    :
  292. *                  Typ          : short int **
  293. *                  Wertebereich : Doppelpointer in Window-Image
  294. *                  Bedeutung    : Zeigt auf die Stelle im Window-Image, wo
  295. *                                 theoretisch das letzte Zeichen der Eingabe
  296. *                                 stehen würde (kann hinters image zeigen)
  297. *
  298. *              : pos_lasts   :
  299. *                  Typ          : short int **
  300. *                  Wertebereich : Doppelpointer in Window-Image
  301. *                  Bedeutung    : Zeigt auf die Stelle im Window-Image, wo
  302. *                                 das letzte sichtbare Zeichen der Eingabe
  303. *                                 steht.
  304. *
  305. *              : old_pos     :
  306. *                  Typ          : short int **
  307. *                  Wertebereich : Doppelpointer in Window-Image
  308. *                  Bedeutung    : Zeigt auf die Stelle im Window-Image, bis wo
  309. *                                 vor der letzten Ausgabe der Eingabe der
  310. *                                 Text auf dem Bildschirm ging.
  311. *
  312. * Beschreibung : Es wird zunächst getestet, ob sich der Cursor nicht am Ende
  313. *                des bisher eingegebenen Strings befindet. Ist dem so, dann
  314. *                geschieht nichts. Sonst wird, falls echoflag gesetzt ist, der
  315. *                Cursor um 1 nach rechts bewegt. Anschliessend wird p_in
  316. *                angepasst. Wurde durch die Cursorbewegung gescrollt, wird
  317. *                die nächste Zeile der Eingabe angezeigt und die Variablen
  318. *                buff_first etc. angepasst.
  319. *
  320. ******************************************************************************/
  321.  
  322. void edit_del(w,buff_last,pos_last,pos_lasts,old_pos)
  323. WINDOW *w;
  324. char **buff_last;
  325. short int **pos_last, **pos_lasts, **old_pos;
  326. {
  327.   if(*p_in) /* DEL geht nur, wenn man nicht hinter Eingabeende steht */
  328.   {
  329.     strcpy(p_in,p_in+1); /* Reststring 1 ranziehen */
  330.     if(echoflag)
  331.     {
  332.       (*pos_last)--;
  333.       inp_out(w,old_pos,buff_last,pos_lasts);
  334.       wrefresh(w);
  335.     }
  336.   }
  337. }
  338.  
  339. /******************************************************************************
  340. *
  341. * Funktion     : Testen ob Zeichen Worttrenner (wort_ende)
  342. * --------------
  343. *
  344. * Parameter    : c           :
  345. *                  Typ          : char
  346. *                  Wertebereich : '\0' - '\255'
  347. *                  Bedeutung    : zu testendes Zeichen
  348. *
  349. * Ergebnis     :
  350. *                  Typ          : char *
  351. *                  Wertebereich : NULL, ungleich NULL
  352. *                  Bedeutung    : NULL: Kein Worttrenner; ungleich NULL: Wort-
  353. *                                 trenner
  354. *
  355. * Beschreibung : Es wird mit der Funktion strchr getestet, ob sich das über-
  356. *                gebene Zeichen in dem String der Worttrenner befindet. Ist
  357. *                dem so, wird ein Pointer auf die entsprechende Stelle im
  358. *                String der Worttrenner zurückgegeben, sonst wird NULL zurück-
  359. *                gegeben.
  360. *
  361. ******************************************************************************/
  362.  
  363. char wort_ende(c)
  364. char c;
  365. {
  366.   return(strchr(" ,.;:#+-*[]{}|!$%&/\\()=?'`^\"",c));
  367. }
  368.  
  369. /******************************************************************************
  370. *
  371. * Funktion     : Cursor in Eingabe ein Wort nach rechts (edit_ctrlright)
  372. * --------------
  373. *
  374. * Parameter    : w           :
  375. *                  Typ          : WINDOW *
  376. *                  Wertebereich : Pointer auf WINDOW-Struktur
  377. *                  Bedeutung    : Fenster, in dem evtl. Cursor bewegt werden
  378. *                                 soll
  379. *
  380. *              : buff_first  :
  381. *                  Typ          : char **
  382. *                  Wertebereich : Doppelpointer auf Zeichen in buffer
  383. *                  Bedeutung    : Erstes sichtbares Zeichen in buffer
  384. *
  385. *              : buff_last   :
  386. *                  Typ          : char **
  387. *                  Wertebereich : Doppelpointer auf Zeichen in buffer
  388. *                  Bedeutung    : Letztes sichtbares Zeichen in buffer
  389. *
  390. *              : pos_first   :
  391. *                  Typ          : short int **
  392. *                  Wertebereich : Doppelpointer in Window-Image
  393. *                  Bedeutung    : Zeigt auf die Stelle im Window-Image, wo
  394. *                                 theoretisch das erste Zeichen der Eingabe
  395. *                                 stehen würde (kann kleiner als image sein)
  396. *
  397. *              : pos_firsts  :
  398. *                  Typ          : short int **
  399. *                  Wertebereich : Doppelpointer in Window-Image
  400. *                  Bedeutung    : Zeigt auf die Stelle im Window-Image, wo
  401. *                                 das letzte sichtbare Zeichen der Eingabe
  402. *                                 steht.
  403. *
  404. *              : pos_lasts   :
  405. *                  Typ          : short int **
  406. *                  Wertebereich : Doppelpointer in Window-Image
  407. *                  Bedeutung    : Zeigt auf die Stelle im Window-Image, wo
  408. *                                 das letzte sichtbare Zeichen der Eingabe
  409. *                                 steht.
  410. *
  411. *              : old_pos     :
  412. *                  Typ          : short int **
  413. *                  Wertebereich : Doppelpointer in Window-Image
  414. *                  Bedeutung    : Zeigt auf die Stelle im Window-Image, bis wo
  415. *                                 vor der letzten Ausgabe der Eingabe der
  416. *                                 Text auf dem Bildschirm ging.
  417. *
  418. * Beschreibung : Es wird zunächst getestet, ob sich der Cursor nicht am Ende
  419. *                des bisher eingegebenen Strings befindet. Ist dem so, dann
  420. *                geschieht nichts. Sonst wird der Cursor mit der Funktion
  421. *                edit_right in der Eingabe um 1 nach rechts bewegt, wobei
  422. *                der Bildschirm und alle nötigen Variablen korrekt angepasst
  423. *                werden. Das wird sooft wiederholt, bis das Zeichen links
  424. *                vom Cursor ein Worttrenner ist.
  425. *
  426. ******************************************************************************/
  427.  
  428. void edit_ctrlright(w,buff_first,buff_last,pos_first,pos_firsts,pos_last,pos_lasts,old_pos)
  429. WINDOW *w;
  430. char **buff_first,**buff_last;
  431. short int **pos_first, **pos_firsts, **pos_last, **pos_lasts, **old_pos;
  432. {
  433.   if(*p_in)
  434.     do
  435.       edit_right(w,buff_first,buff_last,pos_first,pos_firsts,pos_last,pos_lasts,old_pos);
  436.     while(*p_in && !wort_ende(p_in[-1]));
  437. }
  438.  
  439. /******************************************************************************
  440. *
  441. * Funktion     : Cursor in Eingabe ein Wort nach links (edit_ctrlleft)
  442. * --------------
  443. *
  444. * Parameter    : w           :
  445. *                  Typ          : WINDOW *
  446. *                  Wertebereich : Pointer auf WINDOW-Struktur
  447. *                  Bedeutung    : Fenster, in dem evtl. Cursor bewegt werden
  448. *                                 soll
  449. *
  450. *              : buff_first  :
  451. *                  Typ          : char **
  452. *                  Wertebereich : Doppelpointer auf Zeichen in buffer
  453. *                  Bedeutung    : Erstes sichtbares Zeichen in buffer
  454. *
  455. *              : buff_last   :
  456. *                  Typ          : char **
  457. *                  Wertebereich : Doppelpointer auf Zeichen in buffer
  458. *                  Bedeutung    : Letztes sichtbares Zeichen in buffer
  459. *
  460. *              : pos_first   :
  461. *                  Typ          : short int **
  462. *                  Wertebereich : Doppelpointer in Window-Image
  463. *                  Bedeutung    : Zeigt auf die Stelle im Window-Image, wo
  464. *                                 theoretisch das erste Zeichen der Eingabe
  465. *                                 stehen würde (kann kleiner als image sein)
  466. *
  467. *              : pos_last    :
  468. *                  Typ          : short int **
  469. *                  Wertebereich : Doppelpointer in Window-Image
  470. *                  Bedeutung    : Zeigt auf die Stelle im Window-Image, wo
  471. *                                 theoretisch das letzte Zeichen der Eingabe
  472. *                                 stehen würde (kann hinters image zeigen)
  473. *
  474. *              : pos_lasts   :
  475. *                  Typ          : short int **
  476. *                  Wertebereich : Doppelpointer in Window-Image
  477. *                  Bedeutung    : Zeigt auf die Stelle im Window-Image, wo
  478. *                                 das letzte sichtbare Zeichen der Eingabe
  479. *                                 steht.
  480. *
  481. *              : old_pos     :
  482. *                  Typ          : short int **
  483. *                  Wertebereich : Doppelpointer in Window-Image
  484. *                  Bedeutung    : Zeigt auf die Stelle im Window-Image, bis wo
  485. *                                 vor der letzten Ausgabe der Eingabe der
  486. *                                 Text auf dem Bildschirm ging.
  487. *
  488. * Beschreibung : Es wird zunächst getestet, ob man nicht schon am Anfang der
  489. *                Eingabe steht. Ist dem so, geschieht nichts. Sonst wird über
  490. *                die Funktion edit_left der Cursor so oft (mindestens 1 mal)
  491. *                nach links bewegt, bis das Zeichen links vom Cursor ein
  492. *                Worttrenner ist. Dabei werden alle wichtigen Variablen und
  493. *                der Bildschirm von der Funktion edit_left korrekt angepasst.
  494. *
  495. ******************************************************************************/
  496.  
  497. void edit_ctrlleft(w,buff_first,buff_last,pos_first,pos_last,pos_lasts,old_pos)
  498. WINDOW *w;
  499. char **buff_first,**buff_last;
  500. short int **pos_first, **pos_last, **pos_lasts, **old_pos;
  501. {
  502.   if(p_in > buffer)
  503.     do
  504.       edit_left(w,buff_first,buff_last,pos_first,pos_last,pos_lasts,old_pos);
  505.     while(p_in > buffer && !wort_ende(p_in[-1]));
  506. }
  507.  
  508. /******************************************************************************
  509. *
  510. * Funktion     : Cursor an Eingabeanfang (edit_home)
  511. * --------------
  512. *
  513. * Parameter    : w           :
  514. *                  Typ          : WINDOW *
  515. *                  Wertebereich : Pointer auf WINDOW-Struktur
  516. *                  Bedeutung    : Fenster, in dem evtl. Cursor bewegt werden
  517. *                                 soll
  518. *
  519. *              : buff_first  :
  520. *                  Typ          : char **
  521. *                  Wertebereich : Doppelpointer auf Zeichen in buffer
  522. *                  Bedeutung    : Erstes sichtbares Zeichen in buffer
  523. *
  524. *              : buff_last   :
  525. *                  Typ          : char **
  526. *                  Wertebereich : Doppelpointer auf Zeichen in buffer
  527. *                  Bedeutung    : Letztes sichtbares Zeichen in buffer
  528. *
  529. *              : pos_first   :
  530. *                  Typ          : short int **
  531. *                  Wertebereich : Doppelpointer in Window-Image
  532. *                  Bedeutung    : Zeigt auf die Stelle im Window-Image, wo
  533. *                                 theoretisch das erste Zeichen der Eingabe
  534. *                                 stehen würde (kann kleiner als image sein)
  535. *
  536. *              : pos_firsts  :
  537. *                  Typ          : short int **
  538. *                  Wertebereich : Doppelpointer in Window-Image
  539. *                  Bedeutung    : Zeigt auf die Stelle im Window-Image, wo
  540. *                                 das letzte sichtbare Zeichen der Eingabe
  541. *                                 steht.
  542. *
  543. *              : pos_last    :
  544. *                  Typ          : short int **
  545. *                  Wertebereich : Doppelpointer in Window-Image
  546. *                  Bedeutung    : Zeigt auf die Stelle im Window-Image, wo
  547. *                                 theoretisch das letzte Zeichen der Eingabe
  548. *                                 stehen würde (kann hinters image zeigen)
  549. *
  550. *              : pos_lasts   :
  551. *                  Typ          : short int **
  552. *                  Wertebereich : Doppelpointer in Window-Image
  553. *                  Bedeutung    : Zeigt auf die Stelle im Window-Image, wo
  554. *                                 das letzte sichtbare Zeichen der Eingabe
  555. *                                 steht.
  556. *
  557. *              : old_pos     :
  558. *                  Typ          : short int **
  559. *                  Wertebereich : Doppelpointer in Window-Image
  560. *                  Bedeutung    : Zeigt auf die Stelle im Window-Image, bis wo
  561. *                                 vor der letzten Ausgabe der Eingabe der
  562. *                                 Text auf dem Bildschirm ging.
  563. *
  564. * Beschreibung : Die Variable p_in wird auf buffer gesetzt. Liegt das erste
  565. *                Zeichen der Eingabe momentan auaerhalb des Bildschirms, so
  566. *                wird der String ab der linken oberen Bildschirmecke erneut
  567. *                angezeigt und die Variablen buff_first etc. werden angepasst.
  568. *
  569. ******************************************************************************/
  570.  
  571. void edit_home(w,buff_first,buff_last,pos_first,pos_firsts,pos_last,pos_lasts,old_pos)
  572. WINDOW *w;
  573. char **buff_first,**buff_last;
  574. short int  **pos_first, **pos_firsts, **pos_last, **pos_lasts, **old_pos;
  575. {
  576.   p_in = buffer;
  577.   if(echoflag)
  578.   {
  579.     if(*pos_first < *pos_firsts)
  580.     {
  581.       *pos_first = *pos_firsts = w->_image;
  582.       *pos_last = *pos_first + strlen(buffer);
  583.       *buff_first = buffer;
  584.       wmove(w,0,0);
  585.       inp_out(w,old_pos,buff_last,pos_lasts);
  586.       wrefresh(w);
  587.     }
  588.     else
  589.     {
  590.       poi_to_cur(w,*pos_first);
  591.       place_cursor(w);
  592.     }
  593.   }
  594. }
  595.  
  596. /******************************************************************************
  597. *
  598. * Funktion     : Cursor an Eingabeende (edit_end)
  599. * --------------
  600. *
  601. * Parameter    : w           :
  602. *                  Typ          : WINDOW *
  603. *                  Wertebereich : Pointer auf WINDOW-Struktur
  604. *                  Bedeutung    : Fenster, in dem evtl. Cursor bewegt werden
  605. *                                 soll
  606. *
  607. *              : buff_first  :
  608. *                  Typ          : char **
  609. *                  Wertebereich : Doppelpointer auf Zeichen in buffer
  610. *                  Bedeutung    : Erstes sichtbares Zeichen in buffer
  611. *
  612. *              : buff_last   :
  613. *                  Typ          : char **
  614. *                  Wertebereich : Doppelpointer auf Zeichen in buffer
  615. *                  Bedeutung    : Letztes sichtbares Zeichen in buffer
  616. *
  617. *              : pos_first   :
  618. *                  Typ          : short int **
  619. *                  Wertebereich : Doppelpointer in Window-Image
  620. *                  Bedeutung    : Zeigt auf die Stelle im Window-Image, wo
  621. *                                 theoretisch das erste Zeichen der Eingabe
  622. *                                 stehen würde (kann kleiner als image sein)
  623. *
  624. *              : pos_firsts  :
  625. *                  Typ          : short int **
  626. *                  Wertebereich : Doppelpointer in Window-Image
  627. *                  Bedeutung    : Zeigt auf die Stelle im Window-Image, wo
  628. *                                 das letzte sichtbare Zeichen der Eingabe
  629. *                                 steht.
  630. *
  631. *              : pos_last    :
  632. *                  Typ          : short int **
  633. *                  Wertebereich : Doppelpointer in Window-Image
  634. *                  Bedeutung    : Zeigt auf die Stelle im Window-Image, wo
  635. *                                 theoretisch das letzte Zeichen der Eingabe
  636. *                                 stehen würde (kann hinters image zeigen)
  637. *
  638. *              : pos_lasts   :
  639. *                  Typ          : short int **
  640. *                  Wertebereich : Doppelpointer in Window-Image
  641. *                  Bedeutung    : Zeigt auf die Stelle im Window-Image, wo
  642. *                                 das letzte sichtbare Zeichen der Eingabe
  643. *                                 steht.
  644. *
  645. * Beschreibung : Falls eingegebene Zeichen angezeigt werden, wird der String
  646. *                ab der Position, wo der Cursor steht, angezeigt. Dadurch
  647. *                steht danach auf dem Bildschirm der Cursor schon an der
  648. *                richtigen Stelle. Alle Variablen (pos_first etc.) werden
  649. *                angepasst. p_in wird an das Ende des in buffer enthaltenen
  650. *                Strings gesetzt.
  651. *
  652. ******************************************************************************/
  653.  
  654. void edit_end(w,buff_first,buff_last,pos_first,pos_firsts,pos_last,pos_lasts)
  655. WINDOW *w;
  656. char **buff_first,**buff_last;
  657. short int  **pos_first, **pos_firsts, **pos_last, **pos_lasts;
  658. {
  659.   int len = strlen(buffer);
  660.  
  661.   if(echoflag)
  662.   {
  663.     waddstr(w,p_in);
  664.     wrefresh(w);
  665.     *pos_last = *pos_lasts = cur_to_poi(w);
  666.     *pos_first = *pos_firsts = *pos_last-len;
  667.     if(*pos_firsts < w->_image)
  668.       *pos_firsts = w->_image;
  669.     *buff_first = buffer + (*pos_firsts - *pos_first);
  670.   }
  671.   *buff_last = p_in = buffer + len; /* p_in auf terminierende 0 setzen */
  672. }
  673.  
  674. /******************************************************************************
  675. *
  676. * Funktion     : Edit-Tasten behandeln (treat_edit_keys)
  677. * --------------
  678. *
  679. * Parameter    : w           :
  680. *                  Typ          : WINDOW *
  681. *                  Wertebereich : Pointer auf WINDOW-Struktur
  682. *                  Bedeutung    : Fenster, in dem evtl. Cursor bewegt werden
  683. *                                 soll
  684. *
  685. *              : insert      :
  686. *                  Typ          : char *
  687. *                  Wertebereich : Pointer auf Character-Variable
  688. *                  Bedeutung    : Insert-Modus
  689. *
  690. *              : buff_first  :
  691. *                  Typ          : char **
  692. *                  Wertebereich : Doppelpointer auf Zeichen in buffer
  693. *                  Bedeutung    : Erstes sichtbares Zeichen in buffer
  694. *
  695. *              : buff_last   :
  696. *                  Typ          : char **
  697. *                  Wertebereich : Doppelpointer auf Zeichen in buffer
  698. *                  Bedeutung    : Letztes sichtbares Zeichen in buffer
  699. *
  700. *              : pos_first   :
  701. *                  Typ          : short int **
  702. *                  Wertebereich : Doppelpointer in Window-Image
  703. *                  Bedeutung    : Zeigt auf die Stelle im Window-Image, wo
  704. *                                 theoretisch das erste Zeichen der Eingabe
  705. *                                 stehen würde (kann kleiner als image sein)
  706. *
  707. *              : pos_firsts  :
  708. *                  Typ          : short int **
  709. *                  Wertebereich : Doppelpointer in Window-Image
  710. *                  Bedeutung    : Zeigt auf die Stelle im Window-Image, wo
  711. *                                 das letzte sichtbare Zeichen der Eingabe
  712. *                                 steht.
  713. *
  714. *              : pos_last    :
  715. *                  Typ          : short int **
  716. *                  Wertebereich : Doppelpointer in Window-Image
  717. *                  Bedeutung    : Zeigt auf die Stelle im Window-Image, wo
  718. *                                 theoretisch das letzte Zeichen der Eingabe
  719. *                                 stehen würde (kann hinters image zeigen)
  720. *
  721. *              : pos_lasts   :
  722. *                  Typ          : short int **
  723. *                  Wertebereich : Doppelpointer in Window-Image
  724. *                  Bedeutung    : Zeigt auf die Stelle im Window-Image, wo
  725. *                                 das letzte sichtbare Zeichen der Eingabe
  726. *                                 steht.
  727. *
  728. *              : old_pos     :
  729. *                  Typ          : short int **
  730. *                  Wertebereich : Doppelpointer in Window-Image
  731. *                  Bedeutung    : Zeigt auf die Stelle im Window-Image, bis wo
  732. *                                 vor der letzten Ausgabe der Eingabe der
  733. *                                 Text auf dem Bildschirm ging.
  734. *
  735. * Beschreibung : Diese Funktion wird von getch_cooked aufgerufen, wenn dort
  736. *                '\0' eingelesen wurde. Hier wird dann das folgende Zeichen
  737. *                eingelesen. Daraus ergibt sich normal eine Kontroll-Kombina-
  738. *                tion. Ist das der Fall, so wird eine Funktion aufgerufen,
  739. *                die die Kombination auswertet.
  740. *
  741. ******************************************************************************/
  742.  
  743. void treat_edit_keys(c,w,insert,buff_first,buff_last,pos_first,pos_firsts,pos_last,pos_lasts,old_pos)
  744. short int c;
  745. WINDOW *w;
  746. char   *insert,**buff_first,**buff_last;
  747. short int  **pos_first, **pos_firsts, **pos_last, **pos_lasts, **old_pos;
  748. {
  749.   int *pos; /* eee nur damit Syntax in Ordnung ist */
  750.  
  751. #ifdef OS2
  752.   switch(c)
  753. #else
  754.   switch(getch(TRUE)) /* warte auf Zeichen => TRUE */
  755. #endif
  756.   {
  757.     case KEY_LEFT : edit_left(w,buff_first,buff_last,pos_first,pos_last,pos_lasts,old_pos); break; /* Pfeil links */
  758.     case KEY_RIGHT: edit_right(w,buff_first,buff_last,pos_first,pos_firsts,pos_last,pos_lasts,old_pos); break; /* Pfeil rechts */
  759.     case KEY_INS  : *insert ^= TRUE;       break; /* Insert togglen */
  760.     case KEY_DEL  : edit_del(w,buff_last,pos_last,pos_lasts,old_pos); break; /* DEL */
  761.     case KEY_WORDL: edit_ctrlleft(w,buff_first,buff_last,pos_first,pos_last,pos_lasts,old_pos);  break; /* CTRL-Pfeil links */
  762.     case KEY_WORDR: edit_ctrlright(w,buff_first,buff_last,pos_first,pos_firsts,pos_last,pos_lasts,old_pos); break; /* CTRL-Pfeil rechts */
  763.     case KEY_HOME : edit_home(w,buff_first,buff_last,pos_first,pos_firsts,pos_last,pos_lasts,old_pos); break; /* HOME */
  764.     case KEY_END  : edit_end(w,buff_first,buff_last,pos_first,pos_firsts,pos_last,pos_lasts); break; /* END */
  765.   }
  766. }
  767.  
  768. /******************************************************************************
  769. *
  770. * Funktion     : Eingabe ausgeben (inp_out)
  771. * --------------
  772. *
  773. * Parameter    : w           :
  774. *                  Typ          : WINDOW *
  775. *                  Wertebereich : Pointer auf WINDOW-Struktur
  776. *                  Bedeutung    : Fenster, in dem Eingabe angezeigt werden
  777. *                                 soll
  778. *
  779. *              : old_pos     :
  780. *                  Typ          : short int **
  781. *                  Wertebereich : Pointer auf Pointer auf short int
  782. *                  Bedeutung    : Zeigt auf den Zeiger, der hinter das letzte
  783. *                                 Zeichen der Eingabe auf dem Bildschirm
  784. *                                 zeigt.
  785. *
  786. *              : buff_last   :
  787. *                  Typ          : char **
  788. *                  Wertebereich : Doppelpointer auf Zeichen in buffer
  789. *                  Bedeutung    : Letztes sichtbares Zeichen in buffer
  790. *
  791. *              : pos_lasts   :
  792. *                  Typ          : short int **
  793. *                  Wertebereich : Doppelpointer in Window-Image
  794. *                  Bedeutung    : Zeigt auf die Stelle im Window-Image, wo
  795. *                                 das letzte sichtbare Zeichen der Eingabe
  796. *                                 steht.
  797. *
  798. * Beschreibung : Die Eingabe wird ab der Position, an der der Cursor steht
  799. *                (p_in) ausgegeben. Sollte die auszugebende Eingabe über das
  800. *                Fensterende hinausgehen, so bricht die Ausgabe bei vollem
  801. *                Fenster ab.
  802. *                Falls dann der Cursor vor dem alten Ende der
  803. *                Eingabe steht, die Eingabe also kürzer geworden
  804. *                ist, wird der Rest der alten Eingabe auf dem Bildschirm
  805. *                gelöscht. Anschliessend wird der Cursor wieder auf seine
  806. *                alte Position gestellt. In der Variablen, auf die buff_last
  807. *                zeigt, wird vermerkt, wo das letzte angezeigte Zeichen im
  808. *                Eingabepuffer steht. In der Variablen, auf die pos_lasts
  809. *                zeigt, wird eingetragen, wo das letzte angezeigte Zeichen
  810. *                auf dem Bildschirm steht.
  811. *
  812. ******************************************************************************/
  813.  
  814. void inp_out(w,old_pos,buff_last,pos_lasts)
  815. WINDOW *w;
  816. short int  **old_pos, **pos_lasts;
  817. char **buff_last;
  818. {
  819.   short int  *help_pos, *new_pos;
  820.   int       old_x = w->_cursor_x,old_y = w->_cursor_y;
  821.   char      old_scroll = w->_scrflag,*p_in1 = p_in;
  822.  
  823.   w->_scrflag = FALSE; /* Kein Scrolling, damit letzte Zeile ganz genutzt wird */
  824.   while(*p_in1 && (w->_cursor_y < w->_width_y-1 || w->_cursor_x < w->_width_x-1))
  825.     waddch(w,*p_in1++);
  826.   *buff_last = p_in1-1;
  827.   *pos_lasts = cur_to_poi(w)-1;
  828.   if(*p_in1)         /* Brach WHILE ab, weil Fenster voll ? */
  829.   {
  830.     *old_pos = cur_to_poi(w)+1;
  831.     (*buff_last)++;
  832.     (*pos_lasts)++;
  833.     waddch(w,*p_in1); /* Ja, dann letztes Zeichen anzeigen   */
  834.   }
  835.   else
  836.   {
  837.     /* Falls neue Eingabe kürzer, Rest der alten löschen */
  838.     for(help_pos = new_pos = cur_to_poi(w) ; help_pos < *old_pos ; help_pos++)
  839.       *help_pos = STD_ATTR*256;
  840.     *old_pos = new_pos;
  841.   }
  842.   wmove(w,old_y,old_x);
  843.   w->_scrflag = old_scroll;
  844. }
  845.  
  846. /******************************************************************************
  847. *
  848. * Funktion     : Backspace beim Edieren behandeln (treat_backspace)
  849. * --------------
  850. *
  851. * Parameter    : w           :
  852. *                  Typ          : WINDOW *
  853. *                  Wertebereich : Pointer auf WINDOW-Struktur
  854. *                  Bedeutung    : Fenster, in dem evtl. Cursor bewegt werden
  855. *                                 soll
  856. *
  857. *              : buff_first  :
  858. *                  Typ          : char **
  859. *                  Wertebereich : Doppelpointer auf Zeichen in buffer
  860. *                  Bedeutung    : Erstes sichtbares Zeichen in buffer
  861. *
  862. *              : buff_last   :
  863. *                  Typ          : char **
  864. *                  Wertebereich : Doppelpointer auf Zeichen in buffer
  865. *                  Bedeutung    : Letztes sichtbares Zeichen in buffer
  866. *
  867. *              : pos_first   :
  868. *                  Typ          : short int **
  869. *                  Wertebereich : Doppelpointer in Window-Image
  870. *                  Bedeutung    : Zeigt auf die Stelle im Window-Image, wo
  871. *                                 theoretisch das erste Zeichen der Eingabe
  872. *                                 stehen würde (kann kleiner als image sein)
  873. *
  874. *              : pos_last    :
  875. *                  Typ          : short int **
  876. *                  Wertebereich : Doppelpointer in Window-Image
  877. *                  Bedeutung    : Zeigt auf die Stelle im Window-Image, wo
  878. *                                 theoretisch das letzte Zeichen der Eingabe
  879. *                                 stehen würde (kann hinters image zeigen)
  880. *
  881. *              : pos_lasts   :
  882. *                  Typ          : short int **
  883. *                  Wertebereich : Doppelpointer in Window-Image
  884. *                  Bedeutung    : Zeigt auf die Stelle im Window-Image, wo
  885. *                                 das letzte sichtbare Zeichen der Eingabe
  886. *                                 steht.
  887. *
  888. *              : old_pos     :
  889. *                  Typ          : short int **
  890. *                  Wertebereich : Doppelpointer in Window-Image
  891. *                  Bedeutung    : Zeigt auf die Stelle im Window-Image, bis wo
  892. *                                 vor der letzten Ausgabe der Eingabe der
  893. *                                 Text auf dem Bildschirm ging.
  894. *
  895. * Beschreibung : Falls möglich, werden alle Zeichen ab der Cursorposition
  896. *                um eine Position im Eingabepuffer nach vorne gezogen. p_in
  897. *                wird dekrementiert. Im Normalfall wird dann über waddch das
  898. *                Backspace ausgegeben, und anschlieaend der Reststring aus-
  899. *                gegeben. Wurde jedoch ein nicht auf dem Bildschirm stehendes
  900. *                Zeichen gelöscht, werden nur buff_first und pos_first ange-
  901. *                passt.
  902. *
  903. ******************************************************************************/
  904.  
  905. void treat_backspace(w,buff_first,buff_last,pos_first,pos_last,pos_lasts,old_pos)
  906. WINDOW *w;
  907. char **buff_first,**buff_last;
  908. short int  **pos_first, **pos_last, **pos_lasts, **old_pos;
  909. {
  910.   if(p_in > buffer)  /* Falls noch ein Zeichen im Puffer, dieses löschen */
  911.   {
  912.     strcpy(p_in-1,p_in); /* Reststring 1 ranziehen */
  913.     p_in--;
  914.     if(echoflag) /* Falls echo gesetzt, Zeichen auch auf dem Bildschirm löschen */
  915.       if(p_in>=*buff_first) /* Falls nicht vor erstem sichtbaren Zeichen gelöscht wurde */
  916.       {
  917.     waddch(w,'\b'); /* ein Zeichen löschen */
  918.     (*pos_last)--;
  919.     inp_out(w,old_pos,buff_last,pos_lasts);
  920.     wrefresh(w);
  921.       }
  922.       else
  923.       {
  924.     *buff_first = p_in; /* Jetzt kann man schon ein früheres Zeichen sehen */
  925.     (*pos_first)++;     /* Stringanfang rückt eins auf */
  926.       }
  927.   }
  928. }
  929.  
  930. /******************************************************************************
  931. *
  932. * Funktion     : Ein Zeichen in Puffer einfügen (buf_insert)
  933. * --------------
  934. *
  935. * Beschreibung : In buffer werden alle Zeichen ab p_in um eins nach rechts
  936. *                geschoben, falls dafür noch Platz ist.
  937. *
  938. ******************************************************************************/
  939.  
  940. void buf_insert()
  941. {
  942.   char buff[BUFF_SIZE+1];
  943.  
  944.   if(strlen(buffer) == BUFF_SIZE)
  945.     fatal("Eingabepuffer voll, kann kein Zeichen mehr einfügen");
  946.   strcpy(buff,p_in);
  947.   strcpy(p_in+1,buff);
  948. }
  949.  
  950. /******************************************************************************
  951. *
  952. * Funktion     : Zeichen gepuffert einlesen (getch_cooked)
  953. * --------------
  954. *
  955. * Parameter    : w           :
  956. *                  Typ          : WINDOW *
  957. *                  Wertebereich : Pointer auf WINDOW-Struktur
  958. *                  Bedeutung    : Fenster, in dem gelesene Zeichen evtl. an-
  959. *                                 gezeigt werden sollen.
  960. *
  961. * Ergebnis     :
  962. *                  Typ          : char
  963. *                  Wertebereich : '\0' - '\255'
  964. *                  Bedeutung    : Eingelesenes Zeichen
  965. *
  966. * Beschreibung : Falls noch ein Zeichen im Eingabepuffer ist, wird es direkt
  967. *                zurückgegeben. Sonst wird eine Zeile eingelesen, die mit
  968. *                RETURN abgeschlossen werden mua. Die Zeile darf ediert werden.
  969. *                Alle eingelesenen Zeichen werden in einen Puffer geschrieben,
  970. *                aus dem sie hinterher in der Reihenfolge ihrer Eingabe wieder
  971. *                ausgelesen werden können. Es wird dann das erste Zeichen des
  972. *                Puffers zurückgegeben.
  973. *
  974. ******************************************************************************/
  975.  
  976. char getch_cooked(w)
  977. WINDOW *w;
  978. {
  979.   short int c,old_tab = w->_tabflag,insert=FALSE;
  980.   char *buff_first,*buff_last;
  981.   short int  *pos_first, *pos_last, *pos_firsts, *pos_lasts;
  982.   int  i;
  983.   short int old_y,*old_pos;
  984.  
  985.   if(p_in != p_out) /* Falls noch ein Zeichen im Puffer, dieses zurückgeben */
  986.     return(*p_out++);
  987.   p_in = p_out = buff_first = buff_last = buffer; /* p_in statt auf Pufferende jetzt wieder auf Pufferanfang */
  988.   pos_first = pos_last = pos_firsts = pos_lasts = old_pos = cur_to_poi(w);
  989.   for(i=0 ; i<BUFF_SIZE ; i++)
  990.     buffer[i]='\0';   /* Dadurch kann String-Ende leicht gefunden werden */
  991.   w->_tabflag = FALSE; /* Tabs nicht zu Spaces expandieren */
  992.   do
  993.   {
  994.     c = getch(TRUE); /* Warte auf Zeichen => TRUE */
  995.     switch(c % 256) /* Low-Byte des gelesenen Zeichens betrachten */
  996.     {
  997.       case '\0':    /* Sonderfunktion, dann ist Low-Byte 0 */
  998.     treat_edit_keys(c,w,&insert,&buff_first,&buff_last,&pos_first,&pos_firsts,&pos_last,&pos_lasts,&old_pos); /* Sondertaste lesen und evtl. ausführen */
  999.     break;
  1000.       case '\b':           /* Backspace */
  1001.     treat_backspace(w,&buff_first,&buff_last,&pos_first,&pos_last,&pos_lasts,&old_pos);
  1002.     break;
  1003.       case '\r':           /* CR als CR-LF anzeigen aber als CR eintragen */
  1004.     if(echoflag)       /* Wird dann evtl. von wgetch in NL umgewandelt */
  1005.       waddstr(w,p_in); /* Cursor an Eingabeende bringen */
  1006.     p_in = buffer+strlen(buffer); /* '\r' immer am Ende anhängen */
  1007.     *p_in++ = (char) (c % 256); /* Zeichen aus dem Tastaturcode extrahieren */
  1008.     if(echoflag)
  1009.     {
  1010.       waddstr(w,"\n\r");
  1011.       wrefresh(w);
  1012.     }
  1013.     break;
  1014.       default:             /* Jedes andere Zeichen */
  1015.     if(insert)
  1016.     {
  1017.       buf_insert();    /* Evtl. ein Zeichen in Puffer einfügen */
  1018.       pos_last++;
  1019.     }
  1020.     *p_in++ = (char) (c % 256);       /* in Puffer eintragen */
  1021.     if(echoflag)
  1022.     {
  1023.       old_y = w->_cursor_y;
  1024.       waddch(w,c % 256);     /* Zeichen falls echo gesetzt ist auf dem Bildschirm anzeigen */
  1025.       if(!w->_cursor_x && old_y == w->_width_y-1) /* Wurde gescrollt ? */
  1026.       {
  1027.         pos_first -= w->_width_x; /* Erstes Zeichen eine Zeile weiter oben */
  1028.         if(pos_firsts > w->_image) /* Wo steht nun das erste sichtbare */
  1029.         {                         /* Zeichen der Eingabe ?            */
  1030.           pos_firsts -= w->_width_x;
  1031.           if(pos_firsts < w->_image)
  1032.         pos_firsts = w->_image;
  1033.         }
  1034.         buff_first = buffer + (pos_firsts - pos_first);
  1035.       }
  1036.       inp_out(w,&old_pos,&buff_last,&pos_lasts); /* Rest der Eingabe anzeigen */
  1037.       wrefresh(w);
  1038.     }
  1039.     }
  1040.   } while (c != '\r' && p_in < buffer+BUFF_SIZE);
  1041.   w->_tabflag = old_tab;
  1042.   if(p_in >= buffer+BUFF_SIZE)
  1043.     fatal("Eingabepuffer voll!");
  1044.   return(*p_out++);     /* Erstes Zeichen aus dem Puffer zurückgeben */
  1045. }
  1046.  
  1047. /******************************************************************************
  1048. *
  1049. * Funktion     : Zeichen einlesen (wgetch)
  1050. * --------------
  1051. *
  1052. * Parameter    : w           :
  1053. *                  Typ          : WINDOW *
  1054. *                  Wertebereich : Pointer auf WINDOW-Struktur
  1055. *                  Bedeutung    : Fenster, in dem eingelesenes Zeichen evtl.
  1056. *                                 angezeigt werden soll.
  1057. *
  1058. * Ergebnis     :
  1059. *                  Typ          : short int
  1060. *                  Wertebereich : '\0' - '\255'
  1061. *                  Bedeutung    : Eingelesenes Zeichen
  1062. *
  1063. * Beschreibung : Falls delay FALSE ist, wird zunächst getestet, ob ein
  1064. *                Zeichen eingegeben wurde oder noch eins im Puffer steht.
  1065. *                Wenn nein, wird -1 zurückgegeben.
  1066. *                Sonst wird, auch wenn delay TRUE ist, ein Zeichen gelesen,
  1067. *                abhängig von raw entweder mit der Funktion getch oder
  1068. *                getch_cooked. Ist echo und raw gesetzt, wird
  1069. *                anschliessend das eingelesene Zeichen mit waddch angezeigt.
  1070. *                getch_cooked zeigt die Zeichen bei gesetztem echo selber an.
  1071. *
  1072. ******************************************************************************/
  1073.  
  1074. short int wgetch(w)
  1075. WINDOW *w;
  1076. {
  1077.   short int c = '\0';
  1078.  
  1079.   /* Aufruf von getch: warte nicht auf Zeichen => FALSE */
  1080.   if(!w->_dlyflag && p_in==p_out &&
  1081. #ifdef OS2
  1082.      !(c = getch (FALSE)))
  1083. #else
  1084.      !kbhit())
  1085. #endif
  1086.     return(-1);
  1087.   else
  1088.   {
  1089.     if(p_in != p_out) /* Falls noch ein Zeichen im Puffer, dieses zurückgeben */
  1090.       return(*p_out++);
  1091.     if(echoflag)  /* Falls eingegebene Zeichen angezeigt werden sollen, */
  1092.       place_cursor(w); /* Cursor an die richtige Stelle plazieren */
  1093.     if (!c) /* Wurde bei Test, ob Zeichen im Puffer, schon eins gelesen ? */
  1094.       c = rawflag ? getch(TRUE) : (short int) getch_cooked(w);
  1095.     if(c=='\r' && nlflag) /* Falls getch '\r' zurückliefert und das */
  1096.       c = '\n'; /* nlflag gesetzt ist, so soll doch '\n' zurückgegeben werden */
  1097.     if(echoflag && rawflag)
  1098.     {
  1099.       waddch(w,c);
  1100.       wrefresh(w);
  1101.     }
  1102.   }
  1103.   return(c);
  1104. }
  1105.