home *** CD-ROM | disk | FTP | other *** search
/ M.u.C.S. Disc 2000 / MUCS2000.iso / anwend / qed453 / src / tasten.c < prev    next >
Encoding:
C/C++ Source or Header  |  1998-06-13  |  23.9 KB  |  1,096 lines
  1. #include "global.h"
  2. #include "ausgabe.h"
  3. #include "block.h"
  4. #include "clipbrd.h"
  5. #include "edit.h"
  6. #include "find.h"
  7. #include "icon.h"
  8. #include "kurzel.h"
  9. #include "makro.h"
  10. #include "memory.h"
  11. #include "options.h"
  12. #include "rsc.h"
  13. #include "set.h"
  14. #include "text.h"
  15. #include "umbruch.h"
  16. #include "window.h"
  17. #include "tasten.h"
  18.  
  19. /* Modi für deselect_block() */
  20. #define UP        1
  21. #define DOWN    2
  22. #define LEFT    3
  23. #define RIGHT    4
  24.  
  25. /* lokale Prototypen */
  26. static void text_end(TEXTP t_ptr);
  27. static void text_start(TEXTP t_ptr);
  28.  
  29. static void line_up(TEXTP t_ptr);
  30. static void page_up(TEXTP t_ptr);
  31.  
  32. static void line_down(TEXTP t_ptr);
  33. static void page_down(TEXTP t_ptr);
  34.  
  35. static void char_right(TEXTP t_ptr);
  36.  
  37. static void word_left(TEXTP t_ptr);
  38. static void word_right(TEXTP t_ptr);
  39.  
  40. static void line_end(TEXTP t_ptr);
  41. static void line_start(TEXTP t_ptr);
  42.  
  43. static void tabulator(TEXTP t_ptr);
  44.  
  45. static void ctrl_y(TEXTP t_ptr);
  46. static void char_delete(TEXTP t_ptr);
  47.  
  48. static void word_delete(TEXTP t_ptr);
  49. static void word_bs(TEXTP t_ptr);
  50.  
  51. static char    alt_str[3];
  52. static int    alt_cnt = -1;
  53.  
  54. static bool pos_move(TEXTP t_ptr, long delta)
  55. {
  56.     ZEILEP lauf;
  57.  
  58.     lauf = t_ptr->cursor_line;
  59.     if (!t_ptr->up_down)
  60.     {
  61.         t_ptr->desire_x = bild_pos(t_ptr->xpos,lauf,t_ptr->loc_opt->tab,t_ptr->loc_opt->tabsize);
  62.         t_ptr->up_down = TRUE;
  63.     }
  64.     if (delta < 0) /* rauf */
  65.     {
  66.         if (t_ptr->ypos==0) return FALSE;
  67.         delta = -delta;
  68.         if (delta > t_ptr->ypos)
  69.             delta = t_ptr->ypos;
  70.         t_ptr->ypos -= delta;
  71.         while (--delta>=0) VORG(lauf);
  72.         t_ptr->cursor_line = lauf;
  73.         t_ptr->xpos = inter_pos(t_ptr->desire_x,lauf,t_ptr->loc_opt->tab,t_ptr->loc_opt->tabsize);
  74.         return TRUE;
  75.     }
  76.     else if (delta>0) /* runter */
  77.     {
  78.         long rest = t_ptr->text.lines-t_ptr->ypos-1;
  79.  
  80.         if (rest==0) return FALSE;
  81.         if (delta>rest) delta = (int)rest;
  82.         t_ptr->ypos += delta;
  83.         while (--delta>=0)    NEXT(lauf);
  84.         t_ptr->cursor_line = lauf;
  85.         t_ptr->xpos = inter_pos(t_ptr->desire_x,lauf,t_ptr->loc_opt->tab,t_ptr->loc_opt->tabsize);
  86.         return TRUE;
  87.     }
  88.     return FALSE;
  89. }
  90.  
  91.  
  92. /*
  93.  * Bewegen im Text
  94. */
  95. static void text_start(TEXTP t_ptr)
  96. {
  97.     t_ptr->up_down = FALSE;
  98.     t_ptr->cursor_line = FIRST(&t_ptr->text);
  99.     t_ptr->xpos = 0;
  100.     t_ptr->ypos = 0;
  101.     make_chg(t_ptr->link,POS_CHANGE,0);
  102. }
  103.  
  104. static void text_end(TEXTP t_ptr)
  105. {
  106.     t_ptr->up_down = FALSE;
  107.     t_ptr->cursor_line = LAST(&t_ptr->text);
  108.     t_ptr->xpos = 0;
  109.     t_ptr->ypos = t_ptr->text.lines-1;
  110.     make_chg(t_ptr->link,POS_CHANGE,0);
  111. }
  112.  
  113. static void page_up(TEXTP t_ptr)
  114. {
  115.     WINDOWP window = get_window(t_ptr->link);
  116.  
  117.     if (pos_move(t_ptr, - window->w_height))
  118.     {
  119.         make_chg(t_ptr->link,MOVE_DOWN,window->w_height);
  120.         make_chg(t_ptr->link,POS_CHANGE,0);
  121.     }
  122.     else
  123.         end_play();
  124. }
  125.  
  126. static void line_up(TEXTP t_ptr)
  127. {
  128.     ZEILEP lauf = t_ptr->cursor_line;
  129.     if (!t_ptr->up_down)
  130.     {
  131.         t_ptr->desire_x = bild_pos(t_ptr->xpos,lauf,t_ptr->loc_opt->tab,t_ptr->loc_opt->tabsize);
  132.         t_ptr->up_down = TRUE;
  133.     }
  134.     if (t_ptr->ypos)
  135.     {
  136.         VORG(lauf);
  137.         t_ptr->cursor_line = lauf;
  138.         t_ptr->xpos = inter_pos(t_ptr->desire_x,lauf,t_ptr->loc_opt->tab,t_ptr->loc_opt->tabsize);
  139.         t_ptr->ypos--;
  140.         make_chg(t_ptr->link,POS_CHANGE,0);
  141.     }
  142.     else
  143.         end_play();
  144. }
  145.  
  146. static void page_down(TEXTP t_ptr)
  147. {
  148.     WINDOWP window = get_window(t_ptr->link);
  149.  
  150.     if (pos_move(t_ptr, window->w_height))
  151.     {
  152.         make_chg(t_ptr->link,MOVE_UP,window->w_height);
  153.         make_chg(t_ptr->link,POS_CHANGE,0);
  154.     }
  155.     else
  156.         end_play();
  157. }
  158.  
  159. static void line_down(TEXTP t_ptr)
  160. {
  161.     ZEILEP lauf = t_ptr->cursor_line;
  162.  
  163.     if (!t_ptr->up_down)
  164.     {
  165.         t_ptr->desire_x = bild_pos(t_ptr->xpos,lauf,t_ptr->loc_opt->tab,t_ptr->loc_opt->tabsize);
  166.         t_ptr->up_down = TRUE;
  167.     }
  168.     if (!IS_LAST(t_ptr->cursor_line))
  169.     {
  170.         NEXT(lauf);
  171.         t_ptr->cursor_line = lauf;
  172.         t_ptr->xpos = inter_pos(t_ptr->desire_x,lauf,t_ptr->loc_opt->tab,t_ptr->loc_opt->tabsize);
  173.         t_ptr->ypos++;
  174.         make_chg(t_ptr->link,POS_CHANGE,0);
  175.     }
  176.     else
  177.         end_play();
  178. }
  179.  
  180. static void line_start(TEXTP t_ptr)
  181. {
  182.     t_ptr->up_down = FALSE;
  183.     t_ptr->xpos = 0;
  184.     make_chg(t_ptr->link,POS_CHANGE,0);
  185. }
  186.  
  187. static void line_end(TEXTP t_ptr)
  188. {
  189.     t_ptr->up_down = FALSE;
  190.     t_ptr->xpos = t_ptr->cursor_line->len;
  191.     make_chg(t_ptr->link,POS_CHANGE,0);
  192. }
  193.  
  194. static void word_left(TEXTP t_ptr)
  195. {
  196.     int    xw;
  197.     long    yw;
  198.     char *str;
  199.     ZEILEP lauf;
  200.  
  201.     t_ptr->up_down = FALSE;
  202.     lauf = t_ptr->cursor_line;
  203.     xw = t_ptr->xpos;
  204.     yw = t_ptr->ypos;
  205.     str = TEXT(lauf)+xw;
  206.     do                                     /* Ersten Buchstaben finden */
  207.     {
  208.         while(xw==0)
  209.         {
  210.             if (yw==0) return;
  211.             VORG(lauf);
  212.             yw --;
  213.             xw = lauf->len;
  214.             str = TEXT(lauf)+xw;
  215.         }
  216.         xw--;
  217.     }while (!setin(t_ptr->loc_opt->wort_set,*(--str)));
  218.     while(xw>0)                         /* Ersten NICHT-Buchstaben suchen */
  219.     {
  220.         xw--;
  221.         if (!setin(t_ptr->loc_opt->wort_set,*(--str)))
  222.         {
  223.             xw++;
  224.             break;
  225.         }
  226.     }
  227.     t_ptr->cursor_line = lauf;
  228.     t_ptr->xpos = xw;
  229.     t_ptr->ypos = yw;
  230.     make_chg(t_ptr->link,POS_CHANGE,0);
  231. }
  232.  
  233. static void word_right(TEXTP t_ptr)
  234. {
  235.     int    xw;
  236.     long    yw;
  237.     char *str;
  238.     ZEILEP lauf;
  239.  
  240.     t_ptr->up_down = FALSE;
  241.     lauf = t_ptr->cursor_line;
  242.     xw = t_ptr->xpos;
  243.     yw = t_ptr->ypos;
  244.     str = TEXT(lauf)+xw;
  245.     while (TRUE)                        /* erster nicht-wort-Buchstabe */
  246.     {
  247.         if (xw==lauf->len || !setin(t_ptr->loc_opt->wort_set,*str))
  248.             break;
  249.         str++; xw++;
  250.     }
  251.     while (TRUE)                        /* erster wort-Buchstabe */
  252.     {
  253.         while (xw==lauf->len)
  254.         {
  255.             if (IS_LAST(lauf))
  256.                 goto ende;
  257.             NEXT(lauf);
  258.             yw++;
  259.             xw = 0;
  260.             str = TEXT(lauf);
  261.         }
  262.         if (setin(t_ptr->loc_opt->wort_set,*str))
  263.             break;
  264.         str++; xw++;
  265.     }
  266. ende:
  267.     t_ptr->cursor_line = lauf;
  268.     t_ptr->xpos = xw;
  269.     t_ptr->ypos = yw;
  270.     make_chg(t_ptr->link,POS_CHANGE,0);
  271. }
  272.  
  273. void char_left(TEXTP t_ptr)                /* -> kurzel.c */
  274. {
  275.     if (t_ptr->xpos)
  276.     {
  277.         t_ptr->xpos--;
  278.         make_chg(t_ptr->link,POS_CHANGE,0);
  279.     }
  280.     else if (t_ptr->ypos)
  281.     {
  282.         ZEILEP lauf = t_ptr->cursor_line;
  283.  
  284.         VORG(lauf);
  285.         t_ptr->cursor_line = lauf;
  286.         t_ptr->xpos = lauf->len;
  287.         t_ptr->ypos--;
  288.         make_chg(t_ptr->link,POS_CHANGE,0);
  289.     }
  290.     else
  291.         end_play();
  292. }
  293.  
  294. static void char_right(TEXTP t_ptr)
  295. {
  296.     ZEILEP lauf = t_ptr->cursor_line;
  297.  
  298.     if (t_ptr->xpos<lauf->len)
  299.     {
  300.         t_ptr->xpos++;
  301.         make_chg(t_ptr->link,POS_CHANGE,0);
  302.     }
  303.     else if (!IS_LAST(lauf))
  304.     {
  305.         NEXT(lauf);
  306.         t_ptr->cursor_line = lauf;
  307.         t_ptr->xpos = 0;
  308.         t_ptr->ypos++;
  309.         make_chg(t_ptr->link,POS_CHANGE,0);
  310.     }
  311.     else
  312.         end_play();
  313. }
  314.  
  315.  
  316. /*
  317.  * Text hinzufügen
  318. */
  319. void char_cr(TEXTP t_ptr)                 /* -> kurzel.c */
  320. {
  321.     t_ptr->blk_mark_mode = FALSE;
  322.     t_ptr->up_down = FALSE;
  323.     clr_undo();
  324.     if (t_ptr->block)
  325.         blk_delete(t_ptr);
  326.     t_ptr->moved++;
  327.     col_split(&t_ptr->cursor_line,t_ptr->xpos);
  328.     t_ptr->cursor_line->info |= ABSATZ;
  329.     t_ptr->text.lines++;
  330.     NEXT(t_ptr->cursor_line);
  331.     t_ptr->ypos++;
  332.     if (t_ptr->loc_opt->einruecken)
  333.         t_ptr->xpos = col_einrucken(&t_ptr->cursor_line);
  334.     else
  335.         t_ptr->xpos = 0;
  336.  
  337. /*
  338. Problem: Wenn ein Block markiert war, mu₧ eventuell gescrollt werden
  339.          und es kommt zu Redraw-Fehlern, da doch mehr Zeilen betroffen sind!
  340.  
  341.     make_chg(t_ptr->link,SCROLL_DOWN,t_ptr->ypos);
  342.     make_chg(t_ptr->link,LINE_CHANGE,t_ptr->ypos-1);
  343.     make_chg(t_ptr->link,LINE_CHANGE,t_ptr->ypos);
  344. */
  345.     make_chg(t_ptr->link,TOTAL_CHANGE,0);
  346.     make_chg(t_ptr->link,POS_CHANGE,0);
  347.     if (t_ptr->loc_opt->umbrechen)
  348.         umbruch(t_ptr);
  349.     t_ptr->max_line = NULL;
  350. }
  351.  
  352. void char_insert(TEXTP t_ptr, char c)
  353. {
  354.     t_ptr->up_down = FALSE;
  355.  
  356.     /* Null nur in Binär erlaubt! */
  357.     if (c == 0 && t_ptr->text.ending != binmode)
  358.     {
  359.         Bconout(2, 7);
  360.         return;
  361.     }
  362.     
  363.     if (t_ptr->block)
  364.         blk_delete(t_ptr);
  365.     get_undo_col(t_ptr);
  366.     if (overwrite && t_ptr->xpos < t_ptr->cursor_line->len)
  367.     {
  368.         TEXT(t_ptr->cursor_line)[t_ptr->xpos] = c;
  369.     }
  370.     else
  371.     {
  372.         if (t_ptr->cursor_line->len == MAX_LINE_LEN)
  373.         {
  374.             inote(1, 0, TOOLONG, MAX_LINE_LEN);
  375.             return;
  376.         }
  377.         *(REALLOC(&t_ptr->cursor_line,t_ptr->xpos,1)) = c;
  378.     }
  379.     t_ptr->xpos++;
  380.     t_ptr->moved++;
  381.     make_chg(t_ptr->link,LINE_CHANGE,t_ptr->ypos);
  382.     make_chg(t_ptr->link,POS_CHANGE,0);
  383.     if (t_ptr->loc_opt->umbrechen)
  384.         umbruch(t_ptr);
  385. }
  386.  
  387. static void tabulator(TEXTP t_ptr)
  388. {
  389.     t_ptr->blk_mark_mode = FALSE;
  390.     t_ptr->up_down = FALSE;
  391.     if (t_ptr->block)
  392.         blk_delete(t_ptr);
  393.     if (t_ptr->loc_opt->tab)
  394.         char_insert(t_ptr, '\t');
  395.     else
  396.     {
  397.         int xw, tabsize = t_ptr->loc_opt->tabsize;
  398.  
  399.         xw = bild_pos(t_ptr->xpos,t_ptr->cursor_line,t_ptr->loc_opt->tab,tabsize);
  400.         xw = tabsize-(xw%tabsize);
  401.         while((--xw) >= 0)
  402.             char_insert(t_ptr, ' ');
  403.     }
  404. }
  405.  
  406. void char_swap(TEXTP t_ptr)        /* -> menu.c */
  407. {
  408.     char     c;
  409.     int    x;
  410.  
  411.     x = t_ptr->xpos;
  412.     if (x > 0 && x < t_ptr->cursor_line->len)
  413.     {
  414.         get_undo_col(t_ptr);
  415.         c = TEXT(t_ptr->cursor_line)[x];
  416.         TEXT(t_ptr->cursor_line)[x] = TEXT(t_ptr->cursor_line)[x-1];
  417.         TEXT(t_ptr->cursor_line)[x-1] = c;
  418.         t_ptr->xpos++;
  419.         t_ptr->moved++;
  420.         make_chg(t_ptr->link,LINE_CHANGE,t_ptr->ypos);
  421.         make_chg(t_ptr->link,POS_CHANGE,0);
  422.     }
  423. }
  424.  
  425. static void expand_kurzel(TEXTP t_ptr)
  426. {
  427.     if (krz_loaded)
  428.     {
  429.         blk_demark(t_ptr);
  430.         if (ctrl_mark_mode)
  431.             t_ptr->blk_mark_mode = FALSE;
  432.         t_ptr->up_down = FALSE;
  433.         do_kurzel(t_ptr, FALSE);
  434.     }
  435.     else
  436.         Bconout(2, 7);
  437. }
  438.  
  439.  
  440. /*
  441.  * Text enfernen
  442. */
  443. void char_bs(TEXTP t_ptr)             /* -> kurzel.c */
  444. {
  445.     if (IS_FIRST(t_ptr->cursor_line) && t_ptr->xpos==0)
  446.     {
  447.         end_play();             /* Makro beenden */
  448.     }
  449.     else
  450.     {
  451.         char_left(t_ptr);
  452.         char_delete(t_ptr);
  453.     }
  454. }
  455.  
  456. static void char_delete(TEXTP t_ptr)
  457. {
  458.     ZEILEP col = t_ptr->cursor_line;
  459.  
  460.     if (t_ptr->xpos < col->len)
  461.     {
  462.         get_undo_col(t_ptr);
  463.         t_ptr->moved++;
  464.         REALLOC(&t_ptr->cursor_line,t_ptr->xpos,-1);
  465.         make_chg(t_ptr->link,LINE_CHANGE,t_ptr->ypos);
  466.         make_chg(t_ptr->link,POS_CHANGE,0);                     /* wg. moved */
  467.     }
  468.     else if (!IS_LAST(col))
  469.     {
  470.         if (col->len + col->nachf->len > MAX_LINE_LEN)
  471.         {
  472.             inote(1, 0, TOOLONG, MAX_LINE_LEN);
  473.             return;
  474.         }
  475.         clr_undo();
  476.         t_ptr->moved++;
  477.         col_concate(&t_ptr->cursor_line);
  478.         t_ptr->text.lines--;
  479.         make_chg(t_ptr->link,SCROLL_UP,t_ptr->ypos+1);
  480.         make_chg(t_ptr->link,LINE_CHANGE,t_ptr->ypos);
  481.         make_chg(t_ptr->link,POS_CHANGE,0);
  482.     }
  483.     else
  484.         end_play();             /* Makro beenden */
  485.     if (t_ptr->loc_opt->umbrechen)
  486.         umbruch(t_ptr);
  487. }
  488.  
  489. static void word_bs(TEXTP t_ptr)
  490. /* Löschen wortweise nach links */
  491. {
  492.     int        xpos = t_ptr->xpos - 1;
  493.     bool    in_word = FALSE;
  494.  
  495.     t_ptr->blk_mark_mode = FALSE;
  496.     t_ptr->up_down = FALSE;
  497.     if (!t_ptr->block)
  498.     {
  499.         blk_mark(t_ptr,0);
  500.         while (setin(t_ptr->loc_opt->wort_set, TEXT(t_ptr->cursor_line)[xpos])
  501.                     && xpos > 0)
  502.         {
  503.             xpos--;
  504.             in_word = TRUE;
  505.         }
  506.         if (!in_word)
  507.             while (!setin(t_ptr->loc_opt->wort_set, TEXT(t_ptr->cursor_line)[xpos])
  508.                         && xpos > 0)
  509.                 xpos--;
  510.         if (xpos == 0 && t_ptr->xpos == 1)        /* erstes Zeichen */
  511.             t_ptr->xpos = 0;
  512.         else
  513.             t_ptr->xpos = xpos + 1;
  514.         blk_mark(t_ptr,1);
  515.     }
  516.     blk_delete(t_ptr);
  517. }
  518.  
  519. static void word_delete(TEXTP t_ptr)
  520. /* Löschen bis zum nächsten Wortanfang */
  521. {
  522.     int xpos = t_ptr->xpos;
  523.     bool    in_word = FALSE;
  524.  
  525.     t_ptr->blk_mark_mode = FALSE;
  526.     t_ptr->up_down = FALSE;
  527.     if (!t_ptr->block)
  528.     {
  529.         blk_mark(t_ptr,0);
  530.         while (setin(t_ptr->loc_opt->wort_set,TEXT(t_ptr->cursor_line)[xpos])
  531.                 && t_ptr->cursor_line->len > xpos)
  532.         {
  533.             xpos++;
  534.             in_word = TRUE;
  535.         }
  536.         if (!in_word)
  537.             while (!setin(t_ptr->loc_opt->wort_set,TEXT(t_ptr->cursor_line)[xpos])
  538.                     && t_ptr->cursor_line->len > xpos)
  539.             xpos++;
  540.         t_ptr->xpos = xpos;
  541.         blk_mark(t_ptr,1);
  542.     }
  543.     blk_delete(t_ptr);
  544. }
  545.  
  546. static void ctrl_y(TEXTP t_ptr)
  547. {
  548.     ZEILEP col = t_ptr->cursor_line;
  549.  
  550.     if (!t_ptr->block)
  551.     {
  552.         t_ptr->xpos = 0;
  553.         blk_mark(t_ptr, 0);
  554.         if (IS_LAST(col))                    /* letzte Zeile im Text nur kürzen */
  555.         {
  556.             t_ptr->xpos = col->len;
  557.             blk_mark(t_ptr,1);
  558.         }
  559.         else
  560.         {
  561.             NEXT(col);
  562.             t_ptr->cursor_line = col;
  563.             t_ptr->ypos++;
  564.             blk_mark(t_ptr,1);
  565.         }
  566.     }
  567.     blk_cut(t_ptr);
  568. }
  569.  
  570.  
  571.  
  572. static void set_block(TEXTP t_ptr)
  573. {
  574.     if (!t_ptr->blk_mark_mode)
  575.     {
  576.         blk_mark(t_ptr, 0);
  577.         t_ptr->blk_mark_mode = TRUE;
  578.     }
  579. }
  580.  
  581. static void unset_block(TEXTP t_ptr)
  582. {
  583.     blk_demark(t_ptr);
  584.     t_ptr->blk_mark_mode = FALSE;
  585. }
  586.  
  587. /* Deselektiert Block und stellt Cursor entsprechend <dir> */
  588. static void deselect_block(TEXTP t_ptr, int dir)
  589. {
  590.     switch (dir)
  591.     {
  592.         case UP        :
  593.             desire_x = bild_pos(t_ptr->x1, t_ptr->cursor_line, t_ptr->loc_opt->tab, t_ptr->loc_opt->tabsize);
  594.             desire_y = t_ptr->z1;
  595.             break;
  596.         case DOWN    :
  597.             desire_x = bild_pos(t_ptr->x2, t_ptr->cursor_line, t_ptr->loc_opt->tab, t_ptr->loc_opt->tabsize);
  598.             desire_y = t_ptr->z2;
  599.             break;
  600.         case LEFT    :
  601.             desire_x = bild_pos(t_ptr->x1, t_ptr->cursor_line, t_ptr->loc_opt->tab, t_ptr->loc_opt->tabsize);
  602.             desire_y = t_ptr->z1;
  603.             t_ptr->up_down = FALSE;
  604.             break;
  605.         case RIGHT    :
  606.             desire_x = bild_pos(t_ptr->x2, t_ptr->cursor_line, t_ptr->loc_opt->tab, t_ptr->loc_opt->tabsize);
  607.             desire_y = t_ptr->z2;
  608.             t_ptr->up_down = FALSE;
  609.             break;
  610.     }
  611.     blk_demark(t_ptr);
  612.     if (ctrl_mark_mode)
  613.         t_ptr->blk_mark_mode = FALSE;
  614.     icon_edit(t_ptr->link, DO_GOTO);
  615. }
  616.  
  617.  
  618. bool edit_key(TEXTP t_ptr, WINDOWP window, int kstate, int kreturn)
  619. {
  620.     int    nkey;
  621.     int    ascii_code;
  622.     bool    shift, ctrl, alt;
  623.     
  624.     /* Key konvertieren */    
  625.     nkey = gem_to_norm(kstate, kreturn);
  626.     nkey &= ~(NKF_RESVD|NKF_SHIFT|NKF_CTRL|NKF_CAPS);
  627.     ascii_code = nkey & 0x00FF;
  628.     shift = (kstate & (K_RSHIFT|K_LSHIFT)) != 0;
  629.     ctrl = (kstate & K_CTRL) != 0;
  630.     alt = (kstate & K_ALT) != 0;
  631.  
  632.     /* Sonderbehandlung für ^Y */
  633.     if (ascii_code == 'Y' && (ctrl))
  634.     {
  635.         pos_korr(window, t_ptr);
  636.         t_ptr->blk_mark_mode = FALSE;
  637.         ctrl_y(t_ptr);
  638.         t_ptr->up_down = FALSE;
  639.         return TRUE;
  640.     }
  641.  
  642.     if (alt_cnt != -1 && !(nkey & NKF_FUNC))
  643.         alt_cnt = -1;
  644.  
  645.     if (nkey & NKF_FUNC)
  646.     {
  647.         nkey &= ~NKF_FUNC;
  648.         if (shift && ctrl)                                        /* Shift-Ctrl */
  649.         {
  650.             switch (nkey)
  651.             {
  652.                 case NK_UP :
  653.                     if (ctrl_mark_mode)
  654.                     {
  655.                         if (!t_ptr->block)
  656.                             pos_korr(window, t_ptr);
  657.                         set_block(t_ptr);
  658.                         page_up(t_ptr);
  659.                         blk_mark(t_ptr,1);
  660.                     }
  661.                     break;
  662.                 case NK_DOWN :
  663.                     if (ctrl_mark_mode)
  664.                     {
  665.                     if (!t_ptr->block)
  666.                         pos_korr(window, t_ptr);
  667.                         set_block(t_ptr);
  668.                         page_down(t_ptr);
  669.                         blk_mark(t_ptr,1);
  670.                     }
  671.                     break;
  672.                 case NK_LEFT :
  673.                     if (ctrl_mark_mode)
  674.                     {
  675.                     if (!t_ptr->block)
  676.                         pos_korr(window, t_ptr);
  677.                         set_block(t_ptr);
  678.                         word_left(t_ptr);
  679.                         blk_mark(t_ptr,1);
  680.                     }
  681.                     break;
  682.                 case NK_RIGHT :
  683.                     if (ctrl_mark_mode)
  684.                     {
  685.                     if (!t_ptr->block)
  686.                         pos_korr(window, t_ptr);
  687.                         set_block(t_ptr);
  688.                         word_right(t_ptr);
  689.                         blk_mark(t_ptr,1);
  690.                     }
  691.                     break;
  692.                 default:
  693.                     return FALSE;
  694.             }
  695.         }
  696.         else if (shift)                                                /* alle Shift-Codes */
  697.         {
  698.             switch (nkey)
  699.             {
  700.                 case NK_CLRHOME:
  701.                     if (!t_ptr->block)
  702.                         pos_korr(window, t_ptr);
  703.                     if (ctrl_mark_mode)
  704.                         unset_block(t_ptr);
  705.                     else if (!t_ptr->blk_mark_mode)
  706.                         blk_demark(t_ptr);
  707.                     text_end(t_ptr);
  708.                     if (!ctrl_mark_mode && t_ptr->blk_mark_mode)
  709.                         blk_mark(t_ptr,1);
  710.                     break;
  711.                 case NK_UP:
  712.                     if (!t_ptr->block)
  713.                         pos_korr(window, t_ptr);
  714.                     if (ctrl_mark_mode)
  715.                         unset_block(t_ptr);
  716.                     else if (!t_ptr->blk_mark_mode)
  717.                         blk_demark(t_ptr);
  718.                     page_up(t_ptr);
  719.                     if (!ctrl_mark_mode && t_ptr->blk_mark_mode)
  720.                         blk_mark(t_ptr,1);
  721.                     break;
  722.                 case NK_DOWN:
  723.                     if (!t_ptr->block)
  724.                         pos_korr(window, t_ptr);
  725.                     if (ctrl_mark_mode)
  726.                         unset_block(t_ptr);
  727.                     else if (!t_ptr->blk_mark_mode)
  728.                         blk_demark(t_ptr);
  729.                     page_down(t_ptr);
  730.                     if (!ctrl_mark_mode && t_ptr->blk_mark_mode)
  731.                         blk_mark(t_ptr,1);
  732.                     break;
  733.                 case NK_LEFT:
  734.                     if (!t_ptr->block)
  735.                         pos_korr(window, t_ptr);
  736.                     if (ctrl_mark_mode)
  737.                         unset_block(t_ptr);
  738.                     else if (!t_ptr->blk_mark_mode && t_ptr->block)
  739.                         blk_demark(t_ptr);
  740.                     line_start(t_ptr);
  741.                     if (!ctrl_mark_mode && t_ptr->blk_mark_mode)
  742.                         blk_mark(t_ptr,1);
  743.                     break;
  744.                 case NK_RIGHT:
  745.                     if (!t_ptr->block)
  746.                         pos_korr(window, t_ptr);
  747.                     if (ctrl_mark_mode)
  748.                         unset_block(t_ptr);
  749.                     else if (!t_ptr->blk_mark_mode && t_ptr->block)
  750.                         blk_demark(t_ptr);
  751.                     line_end(t_ptr);
  752.                     if (!ctrl_mark_mode && t_ptr->blk_mark_mode)
  753.                         blk_mark(t_ptr,1);
  754.                     break;
  755.                 case NK_BS:
  756.                     if (!t_ptr->block)
  757.                         pos_korr(window, t_ptr);
  758.                     word_bs(t_ptr);
  759.                     break;
  760.                 case NK_DEL:
  761.                     if (!t_ptr->block)
  762.                         pos_korr(window, t_ptr);
  763.                     word_delete(t_ptr);
  764.                     break;
  765.                 case NK_RET :
  766.                     if (!t_ptr->block)
  767.                         pos_korr(window, t_ptr);
  768.                     word_left(t_ptr);
  769.                     char_cr(t_ptr);
  770.                     break;
  771.                 default:
  772.                     return FALSE;
  773.             } /* switch shift */
  774.         } /* if shift */
  775.         else if (ctrl)                                             /* alle Control-Codes */
  776.         {
  777.             switch (nkey)
  778.             {
  779.                 case NK_UP:
  780.                     if (!t_ptr->block)
  781.                         pos_korr(window, t_ptr);
  782.                     if (ctrl_mark_mode)
  783.                     {
  784.                         set_block(t_ptr);
  785.                         line_up(t_ptr);
  786.                         blk_mark(t_ptr,1);
  787.                     }
  788.                     else     /* seitenweise Blättern, für PC-Tastaturen PgUp/Down */
  789.                     {
  790.                         if (!t_ptr->blk_mark_mode && t_ptr->block)
  791.                             deselect_block(t_ptr, UP);
  792.                         else
  793.                         {
  794.                             page_up(t_ptr);
  795.                             if (t_ptr->blk_mark_mode)
  796.                                 blk_mark(t_ptr,1);
  797.                         }
  798.                     }
  799.                     break;
  800.                 case NK_DOWN:
  801.                     if (!t_ptr->block)
  802.                         pos_korr(window, t_ptr);
  803.                     if (ctrl_mark_mode)
  804.                     {
  805.                         set_block(t_ptr);
  806.                         line_down(t_ptr);
  807.                         blk_mark(t_ptr,1);
  808.                     }
  809.                     else
  810.                     {
  811.                         if (!t_ptr->blk_mark_mode && t_ptr->block)
  812.                             deselect_block(t_ptr, DOWN);
  813.                         else
  814.                         {
  815.                             page_down(t_ptr);
  816.                             if (t_ptr->blk_mark_mode)
  817.                                 blk_mark(t_ptr,1);
  818.                         }
  819.                     }
  820.                     break;
  821.                 case NK_LEFT:
  822.                     if (!t_ptr->block)
  823.                         pos_korr(window, t_ptr);
  824.                     if (ctrl_mark_mode)
  825.                     {
  826.                         set_block(t_ptr);
  827.                         t_ptr->up_down = FALSE;
  828.                         char_left(t_ptr);
  829.                         blk_mark(t_ptr,1);
  830.                     }
  831.                     else
  832.                     {
  833.                         if (!t_ptr->blk_mark_mode && t_ptr->block)
  834.                             deselect_block(t_ptr, LEFT);
  835.                         else
  836.                         {
  837.                             word_left(t_ptr);
  838.                             if (t_ptr->blk_mark_mode)
  839.                                 blk_mark(t_ptr,1);
  840.                         }
  841.                     }
  842.                     break;
  843.                 case NK_RIGHT:
  844.                     if (!t_ptr->block)
  845.                         pos_korr(window, t_ptr);
  846.                     if (ctrl_mark_mode)
  847.                     {
  848.                         set_block(t_ptr);
  849.                         t_ptr->up_down = FALSE;
  850.                         char_right(t_ptr);
  851.                         blk_mark(t_ptr,1);
  852.                     }
  853.                     else
  854.                     {
  855.                         if (!t_ptr->blk_mark_mode && t_ptr->block)
  856.                             deselect_block(t_ptr, RIGHT);
  857.                         else
  858.                         {
  859.                             word_right(t_ptr);
  860.                             if (t_ptr->blk_mark_mode)
  861.                                 blk_mark(t_ptr,1);
  862.                         }
  863.                     }
  864.                     break;
  865.                 case NK_TAB:
  866.                     if (!t_ptr->block)
  867.                         pos_korr(window, t_ptr);
  868.                     if (!ctrl_mark_mode)
  869.                         t_ptr->blk_mark_mode = FALSE;
  870.                     t_ptr->up_down = FALSE;
  871.                     if (!blk_mark_brace(t_ptr))
  872.                         blk_mark_word(t_ptr);
  873.                     break;
  874.                 case NK_DEL :
  875.                     if (!t_ptr->block)
  876.                         pos_korr(window, t_ptr);
  877.                     if (ctrl_mark_mode)
  878.                     {
  879.                         t_ptr->up_down = FALSE;
  880.                         do_icon(t_ptr->link, DO_CUT);
  881.                     }
  882.                     break;
  883.                 case NK_INS:
  884.                     if (!t_ptr->block)
  885.                         pos_korr(window, t_ptr);
  886.                     if (ctrl_mark_mode)
  887.                     {
  888.                         t_ptr->up_down = FALSE;
  889.                         do_icon(t_ptr->link, DO_PASTE);
  890.                     }
  891.                     break;
  892.                 case NK_CLRHOME:
  893.                     if (!t_ptr->block)
  894.                         pos_korr(window, t_ptr);
  895.                     if (ctrl_mark_mode)
  896.                     {
  897.                         t_ptr->up_down = FALSE;
  898.                         if (t_ptr->block)
  899.                             do_icon(t_ptr->link, DO_COPY);
  900.                         else
  901.                             do_icon(t_ptr->link, DO_LINECOPY);
  902.                     }
  903.                     break;
  904.                 default:
  905.                     return FALSE;
  906.             }
  907.         } /* if ctrl */
  908.         else if (alt)                                                /* alle Alt-Codes */
  909.         {
  910.             char    c;
  911.             int    i;
  912.             
  913.             c = (char)nkey;
  914.             if ((nkey & NKF_NUM) && c >= '0' && c <= '9')
  915.             {
  916.                 if (!t_ptr->block)
  917.                     pos_korr(window, t_ptr);
  918.                 if (alt_cnt < 2)
  919.                 {
  920.                     alt_cnt++;
  921.                     alt_str[alt_cnt] = c;
  922.                 }
  923.                 if (alt_cnt == 2)
  924.                 {
  925.                     alt_cnt = -1;
  926.                     alt_str[3] = EOS;
  927.                     i = atoi(alt_str);
  928.                     if (i < 256)
  929.                         char_insert(t_ptr, i);
  930.                 }
  931.                 return TRUE;
  932.             }
  933.             else            
  934.                 return FALSE;
  935.         } /* if alt */
  936.         else                                        /* alles restliche Funktionscodes */
  937.         {
  938.             switch (nkey)
  939.             {
  940.                 case NK_ESC :
  941.                     if (!t_ptr->block)
  942.                         pos_korr(window, t_ptr);
  943.                     expand_kurzel(t_ptr);
  944.                     break;
  945.                 case NK_TAB:
  946.                     if (!t_ptr->block)
  947.                         pos_korr(window, t_ptr);
  948.                     tabulator(t_ptr);
  949.                     break;
  950.                 case NK_RET:
  951.                 case (NK_ENTER|NKF_NUM) :
  952.                     if (!t_ptr->block)
  953.                         pos_korr(window, t_ptr);
  954.                     char_cr(t_ptr);
  955.                     break;
  956.                 case NK_CLRHOME:
  957.                     if (!t_ptr->block)
  958.                         pos_korr(window, t_ptr);
  959.                     if (ctrl_mark_mode)
  960.                         unset_block(t_ptr);
  961.                     else if (!t_ptr->blk_mark_mode)
  962.                         blk_demark(t_ptr);
  963.                     text_start(t_ptr);
  964.                     if (!ctrl_mark_mode && t_ptr->blk_mark_mode)
  965.                         blk_mark(t_ptr,1);
  966.                     break;
  967.                 case NK_UNDO:
  968.                     if (!t_ptr->block)
  969.                         pos_korr(window, t_ptr);
  970.                     icon_edit(t_ptr->link, DO_UNDO);
  971.                     break;
  972.                 case NK_UP:
  973.                     if (!t_ptr->block)
  974.                         pos_korr(window, t_ptr);
  975.                     if ((ctrl_mark_mode || !t_ptr->blk_mark_mode) && t_ptr->block)
  976.                     {
  977.                         deselect_block(t_ptr, UP);
  978.                         break;
  979.                     }
  980.                     line_up(t_ptr);
  981.                     if (!ctrl_mark_mode && t_ptr->blk_mark_mode)
  982.                         blk_mark(t_ptr,1);
  983.                     break;
  984.                 case NK_DOWN:
  985.                     if (!t_ptr->block)
  986.                         pos_korr(window, t_ptr);
  987.                     if ((ctrl_mark_mode || !t_ptr->blk_mark_mode) && t_ptr->block)
  988.                     {
  989.                         deselect_block(t_ptr, DOWN);
  990.                         break;
  991.                     }
  992.                     line_down(t_ptr);
  993.                     if (!ctrl_mark_mode && t_ptr->blk_mark_mode)
  994.                         blk_mark(t_ptr,1);
  995.                     break;
  996.                 case NK_LEFT:
  997.                     if (!t_ptr->block)
  998.                         pos_korr(window, t_ptr);
  999.                     t_ptr->up_down = FALSE;
  1000.                     if ((ctrl_mark_mode || !t_ptr->blk_mark_mode) && t_ptr->block)
  1001.                     {
  1002.                         deselect_block(t_ptr, LEFT);
  1003.                         break;
  1004.                     }
  1005.                     char_left(t_ptr);
  1006.                     if (!ctrl_mark_mode && t_ptr->blk_mark_mode)
  1007.                         blk_mark(t_ptr,1);
  1008.                     break;
  1009.                 case NK_RIGHT:
  1010.                     if (!t_ptr->block)
  1011.                         pos_korr(window, t_ptr);
  1012.                     t_ptr->up_down = FALSE;
  1013.                     if ((ctrl_mark_mode || !t_ptr->blk_mark_mode) && t_ptr->block)
  1014.                     {
  1015.                         deselect_block(t_ptr, RIGHT);
  1016.                         break;
  1017.                     }
  1018.                     char_right(t_ptr);
  1019.                     if (!ctrl_mark_mode && t_ptr->blk_mark_mode)
  1020.                         blk_mark(t_ptr,1);
  1021.                     break;
  1022.                 case NK_BS:
  1023.                     if (!t_ptr->block)
  1024.                         pos_korr(window, t_ptr);
  1025.                     t_ptr->blk_mark_mode = FALSE;
  1026.                     t_ptr->up_down = FALSE;
  1027.                     if (t_ptr->block)
  1028.                         blk_delete(t_ptr);
  1029.                     else
  1030.                         char_bs(t_ptr);
  1031.                     break;
  1032.                 case NK_DEL:
  1033.                     if (!t_ptr->block)
  1034.                         pos_korr(window, t_ptr);
  1035.                     t_ptr->blk_mark_mode = FALSE;
  1036.                     t_ptr->up_down = FALSE;
  1037.                     if (t_ptr->block)
  1038.                         blk_delete(t_ptr);
  1039.                     else
  1040.                         char_delete(t_ptr);
  1041.                     break;
  1042.                 case NK_M_PGUP:                /* Mac: page up -> shift-up */
  1043.                     if (!t_ptr->block)
  1044.                         pos_korr(window, t_ptr);
  1045.                     if (ctrl_mark_mode)
  1046.                         unset_block(t_ptr);
  1047.                     else if (!t_ptr->blk_mark_mode)
  1048.                         blk_demark(t_ptr);
  1049.                     page_up(t_ptr);
  1050.                     if (!ctrl_mark_mode && t_ptr->blk_mark_mode)
  1051.                         blk_mark(t_ptr,1);
  1052.                     break;
  1053.                 case NK_M_PGDOWN:             /* Mac: page down -> shift-down */
  1054.                     if (!t_ptr->block)
  1055.                         pos_korr(window, t_ptr);
  1056.                     if (ctrl_mark_mode)
  1057.                         unset_block(t_ptr);
  1058.                     else if (!t_ptr->blk_mark_mode)
  1059.                         blk_demark(t_ptr);
  1060.                     page_down(t_ptr);
  1061.                     if (!ctrl_mark_mode && t_ptr->blk_mark_mode)
  1062.                         blk_mark(t_ptr,1);
  1063.                     break;
  1064.                 case NK_M_END:                 /* Mac: end -> shift-home */
  1065.                     if (!t_ptr->block)
  1066.                         pos_korr(window, t_ptr);
  1067.                     if (ctrl_mark_mode)
  1068.                         unset_block(t_ptr);
  1069.                     else if (!t_ptr->blk_mark_mode)
  1070.                         blk_demark(t_ptr);
  1071.                     text_end(t_ptr);
  1072.                     if (!ctrl_mark_mode && t_ptr->blk_mark_mode)
  1073.                         blk_mark(t_ptr,1);
  1074.                     break;
  1075.                 default:
  1076.                     return FALSE;
  1077.             }
  1078.         }
  1079.     } /* if NKF_FUNC */
  1080.     else                                                    /* keine Funktionstaste */
  1081.     {
  1082.         if (!t_ptr->block)
  1083.             pos_korr(window, t_ptr);
  1084.         if (ascii_code)
  1085.         {
  1086.             t_ptr->blk_mark_mode = FALSE;
  1087.             char_insert(t_ptr, ascii_code);
  1088.             if (krz_loaded)
  1089.                 do_kurzel(t_ptr, TRUE);
  1090.         }
  1091.         else
  1092.             return FALSE;
  1093.     }
  1094.     return TRUE;
  1095. }
  1096.