home *** CD-ROM | disk | FTP | other *** search
/ Media Share 9 / MEDIASHARE_09.ISO / cprog / dflt14.zip / EDITBOX.C < prev    next >
Text File  |  1992-08-03  |  35KB  |  1,098 lines
  1. /* ------------- editbox.c ------------ */
  2. #include "dflat.h"
  3.  
  4. #define EditBufLen(wnd) (isMultiLine(wnd) ? EDITLEN : ENTRYLEN)
  5. #define SetLinePointer(wnd, ln) (wnd->CurrLine = ln)
  6. #define isWhite(c)     ((c)==' '||(c)=='\n')
  7. /* ---------- local prototypes ----------- */
  8. static void SaveDeletedText(WINDOW, char *, int);
  9. static void Forward(WINDOW);
  10. static void Backward(WINDOW);
  11. static void End(WINDOW);
  12. static void Home(WINDOW);
  13. static void Downward(WINDOW);
  14. static void Upward(WINDOW);
  15. static void StickEnd(WINDOW);
  16. static void NextWord(WINDOW);
  17. static void PrevWord(WINDOW);
  18. static void ModTextPointers(WINDOW, int, int);
  19. /* -------- local variables -------- */
  20. static BOOL KeyBoardMarking, ButtonDown;
  21. static BOOL TextMarking;
  22. static int ButtonX, ButtonY;
  23. static int PrevY = -1;
  24.  
  25. /* ----------- CREATE_WINDOW Message ---------- */
  26. static int CreateWindowMsg(WINDOW wnd)
  27. {
  28.     int rtn = BaseWndProc(EDITBOX, wnd, CREATE_WINDOW, 0, 0);
  29.     wnd->MaxTextLength = MAXTEXTLEN+1;
  30.     wnd->textlen = EditBufLen(wnd);
  31.     wnd->InsertMode = TRUE;
  32.     SendMessage(wnd, CLEARTEXT, 0, 0);
  33.     return rtn;
  34. }
  35. /* ----------- SETTEXT Message ---------- */
  36. static int SetTextMsg(WINDOW wnd, PARAM p1)
  37. {
  38.     int rtn = FALSE;
  39.     if (strlen((char *)p1) <= wnd->MaxTextLength)
  40.         rtn = BaseWndProc(EDITBOX, wnd, SETTEXT, p1, 0);
  41.     return rtn;
  42. }
  43. /* ----------- CLEARTEXT Message ------------ */
  44. static int ClearTextMsg(WINDOW wnd)
  45. {
  46.     int rtn = BaseWndProc(EDITBOX, wnd, CLEARTEXT, 0, 0);
  47.     unsigned blen = EditBufLen(wnd)+2;
  48.     wnd->text = DFrealloc(wnd->text, blen);
  49.     memset(wnd->text, 0, blen);
  50.     wnd->wlines = 0;
  51.     wnd->CurrLine = 0;
  52.     wnd->CurrCol = 0;
  53.     wnd->WndRow = 0;
  54.     wnd->wleft = 0;
  55.     wnd->wtop = 0;
  56.     wnd->textwidth = 0;
  57.     wnd->TextChanged = FALSE;
  58.     return rtn;
  59. }
  60. /* ----------- ADDTEXT Message ---------- */
  61. static int AddTextMsg(WINDOW wnd, PARAM p1, PARAM p2)
  62. {
  63.     int rtn = FALSE;
  64.     if (strlen((char *)p1)+wnd->textlen <= wnd->MaxTextLength) {
  65.         rtn = BaseWndProc(EDITBOX, wnd, ADDTEXT, p1, p2);
  66.         if (rtn != FALSE)    {
  67.             if (!isMultiLine(wnd))    {
  68.                 wnd->CurrLine = 0;
  69.                 wnd->CurrCol = strlen((char *)p1);
  70.                 if (wnd->CurrCol >= ClientWidth(wnd))    {
  71.                     wnd->wleft = wnd->CurrCol-ClientWidth(wnd);
  72.                     wnd->CurrCol -= wnd->wleft;
  73.                 }
  74.                 wnd->BlkEndCol = wnd->CurrCol;
  75.                 SendMessage(wnd, KEYBOARD_CURSOR,
  76.                                      WndCol, wnd->WndRow);
  77.             }
  78.         }
  79.     }
  80.     return rtn;
  81. }
  82. /* ----------- GETTEXT Message ---------- */
  83. static int GetTextMsg(WINDOW wnd, PARAM p1, PARAM p2)
  84. {
  85.     char *cp1 = (char *)p1;
  86.     char *cp2 = wnd->text;
  87.     if (cp2 != NULL)    {
  88.         while (p2-- && *cp2 && *cp2 != '\n')
  89.             *cp1++ = *cp2++;
  90.         *cp1 = '\0';
  91.         return TRUE;
  92.     }
  93.     return FALSE;
  94. }
  95. /* ----------- SETTEXTLENGTH Message ---------- */
  96. static int SetTextLengthMsg(WINDOW wnd, unsigned int len)
  97. {
  98.     if (++len < MAXTEXTLEN)    {
  99.         wnd->MaxTextLength = len;
  100.         if (len < wnd->textlen)    {
  101.             wnd->text=DFrealloc(wnd->text, len+2);
  102.             wnd->textlen = len;
  103.             *((wnd->text)+len) = '\0';
  104.             *((wnd->text)+len+1) = '\0';
  105.             BuildTextPointers(wnd);
  106.         }
  107.         return TRUE;
  108.     }
  109.     return FALSE;
  110. }
  111. /* ----------- KEYBOARD_CURSOR Message ---------- */
  112. static void KeyboardCursorMsg(WINDOW wnd, PARAM p1, PARAM p2)
  113. {
  114.     wnd->CurrCol = (int)p1 + wnd->wleft;
  115.     wnd->WndRow = (int)p2;
  116.     wnd->CurrLine = (int)p2 + wnd->wtop;
  117.     if (wnd == inFocus)    {
  118.         if (CharInView(wnd, (int)p1, (int)p2))
  119.             SendMessage(NULL, SHOW_CURSOR, wnd->InsertMode, 0);
  120.         else
  121.             SendMessage(NULL, HIDE_CURSOR, 0, 0);
  122.     }
  123. }
  124. /* ----------- SIZE Message ---------- */
  125. int SizeMsg(WINDOW wnd, PARAM p1, PARAM p2)
  126. {
  127.     int rtn = BaseWndProc(EDITBOX, wnd, SIZE, p1, p2);
  128.     if (WndCol > ClientWidth(wnd)-1)
  129.         wnd->CurrCol = ClientWidth(wnd)-1 + wnd->wleft;
  130.     if (wnd->WndRow > ClientHeight(wnd)-1)    {
  131.         wnd->WndRow = ClientHeight(wnd)-1;
  132.         SetLinePointer(wnd, wnd->WndRow+wnd->wtop);
  133.     }
  134.     SendMessage(wnd, KEYBOARD_CURSOR, WndCol, wnd->WndRow);
  135.     return rtn;
  136. }
  137. /* ----------- SCROLL Message ---------- */
  138. static int ScrollMsg(WINDOW wnd, PARAM p1)
  139. {
  140.     int rtn = FALSE;
  141.     if (isMultiLine(wnd))    {
  142.         rtn = BaseWndProc(EDITBOX,wnd,SCROLL,p1,0);
  143.         if (rtn != FALSE)    {
  144.             if (p1)    {
  145.                 /* -------- scrolling up --------- */
  146.                 if (wnd->WndRow == 0)    {
  147.                     wnd->CurrLine++;
  148.                     StickEnd(wnd);
  149.                 }
  150.                 else
  151.                     --wnd->WndRow;
  152.             }
  153.             else    {
  154.                 /* -------- scrolling down --------- */
  155.                 if (wnd->WndRow == ClientHeight(wnd)-1)    {
  156.                     if (wnd->CurrLine > 0)
  157.                         --wnd->CurrLine;
  158.                     StickEnd(wnd);
  159.                 }
  160.                 else
  161.                     wnd->WndRow++;
  162.             }
  163.             SendMessage(wnd,KEYBOARD_CURSOR,WndCol,wnd->WndRow);
  164.         }
  165.     }
  166.     return rtn;
  167. }
  168. /* ----------- HORIZSCROLL Message ---------- */
  169. static int HorizScrollMsg(WINDOW wnd, PARAM p1)
  170. {
  171.     int rtn = FALSE;
  172.     char *currchar = CurrChar;
  173.     if (!(p1 &&
  174.             wnd->CurrCol == wnd->wleft && *currchar == '\n'))  {
  175.         rtn = BaseWndProc(EDITBOX, wnd, HORIZSCROLL, p1, 0);
  176.         if (rtn != FALSE)    {
  177.             if (wnd->CurrCol < wnd->wleft)
  178.                 wnd->CurrCol++;
  179.             else if (WndCol == ClientWidth(wnd))
  180.                 --wnd->CurrCol;
  181.             SendMessage(wnd,KEYBOARD_CURSOR,WndCol,wnd->WndRow);
  182.         }
  183.     }
  184.     return rtn;
  185. }
  186. /* ----------- SCROLLPAGE Message ---------- */
  187. static int ScrollPageMsg(WINDOW wnd, PARAM p1)
  188. {
  189.     int rtn = FALSE;
  190.     if (isMultiLine(wnd))    {
  191.         rtn = BaseWndProc(EDITBOX, wnd, SCROLLPAGE, p1, 0);
  192.         SetLinePointer(wnd, wnd->wtop+wnd->WndRow);
  193.         StickEnd(wnd);
  194.         SendMessage(wnd, KEYBOARD_CURSOR,WndCol, wnd->WndRow);
  195.     }
  196.     return rtn;
  197. }
  198. /* ----------- HORIZSCROLLPAGE Message ---------- */
  199. static int HorizPageMsg(WINDOW wnd, PARAM p1)
  200. {
  201.     int rtn = BaseWndProc(EDITBOX, wnd, HORIZPAGE, p1, 0);
  202.     if ((int) p1 == FALSE)    {
  203.         if (wnd->CurrCol > wnd->wleft+ClientWidth(wnd)-1)
  204.             wnd->CurrCol = wnd->wleft+ClientWidth(wnd)-1;
  205.     }
  206.     else if (wnd->CurrCol < wnd->wleft)
  207.         wnd->CurrCol = wnd->wleft;
  208.     SendMessage(wnd, KEYBOARD_CURSOR, WndCol, wnd->WndRow);
  209.     return rtn;
  210. }
  211. /* ----- Extend the marked block to the new x,y position ---- */
  212. static void ExtendBlock(WINDOW wnd, int x, int y)
  213. {
  214.     int bbl, bel;
  215.     int ptop = min(wnd->BlkBegLine, wnd->BlkEndLine);
  216.     int pbot = max(wnd->BlkBegLine, wnd->BlkEndLine);
  217.     char *lp = TextLine(wnd, wnd->wtop+y);
  218.     int len = (int) (strchr(lp, '\n') - lp);
  219.     x = max(0, min(x, len-wnd->wleft));
  220.     y = max(0, y);
  221.     wnd->BlkEndCol = x+wnd->wleft;
  222.     wnd->BlkEndLine = y+wnd->wtop;
  223.     bbl = min(wnd->BlkBegLine, wnd->BlkEndLine);
  224.     bel = max(wnd->BlkBegLine, wnd->BlkEndLine);
  225.     while (ptop < bbl)    {
  226.         WriteTextLine(wnd, NULL, ptop, FALSE);
  227.         ptop++;
  228.     }
  229.     for (y = bbl; y <= bel; y++)
  230.         WriteTextLine(wnd, NULL, y, FALSE);
  231.     while (pbot > bel)    {
  232.         WriteTextLine(wnd, NULL, pbot, FALSE);
  233.         --pbot;
  234.     }
  235. }
  236. /* ----------- LEFT_BUTTON Message ---------- */
  237. static int LeftButtonMsg(WINDOW wnd, PARAM p1, PARAM p2)
  238. {
  239.     int MouseX = (int) p1 - GetClientLeft(wnd);
  240.     int MouseY = (int) p2 - GetClientTop(wnd);
  241.     RECT rc = ClientRect(wnd);
  242.     char *lp;
  243.     int len;
  244.     if (KeyBoardMarking)
  245.         return TRUE;
  246.     if (WindowMoving || WindowSizing)
  247.         return FALSE;
  248.     if (isMultiLine(wnd))    {
  249.         if (TextMarking)    {
  250.             if (!InsideRect(p1, p2, rc))    {
  251.                 if ((int)p1 == GetLeft(wnd))
  252.                     if (SendMessage(wnd, HORIZSCROLL, 0, 0))
  253.                         ExtendBlock(wnd, MouseX-1, MouseY);
  254.                 if ((int)p1 == GetRight(wnd))
  255.                     if (SendMessage(wnd, HORIZSCROLL, TRUE, 0))
  256.                         ExtendBlock(wnd, MouseX+1, MouseY);
  257.                 if ((int)p2 == GetTop(wnd))
  258.                     if (SendMessage(wnd, SCROLL, FALSE, 0))
  259.                         ExtendBlock(wnd, MouseX, MouseY+1);
  260.                 if ((int)p2 == GetBottom(wnd))
  261.                     if (SendMessage(wnd, SCROLL, TRUE, 0))
  262.                         ExtendBlock(wnd, MouseX, MouseY-1);
  263.                 SendMessage(wnd, PAINT, 0, 0);
  264.             }
  265.             return TRUE;
  266.         }
  267.         if (!InsideRect(p1, p2, rc))
  268.             return FALSE;
  269.         if (TextBlockMarked(wnd))    {
  270.             ClearTextBlock(wnd);
  271.             SendMessage(wnd, PAINT, 0, 0);
  272.         }
  273.         if (wnd->wlines)    {
  274.             if (MouseY > wnd->wlines-1)
  275.                 return TRUE;
  276.             lp = TextLine(wnd, MouseY+wnd->wtop);
  277.             len = (int) (strchr(lp, '\n') - lp);
  278.             MouseX = min(MouseX, len);
  279.             if (MouseX < wnd->wleft)    {
  280.                 MouseX = 0;
  281.                 SendMessage(wnd, KEYBOARD, HOME, 0);
  282.             }
  283.             ButtonDown = TRUE;
  284.             ButtonX = MouseX;
  285.             ButtonY = MouseY;
  286.         }
  287.         else
  288.             MouseX = MouseY = 0;
  289.         wnd->WndRow = MouseY;
  290.         SetLinePointer(wnd, MouseY+wnd->wtop);
  291.     }
  292.     if (isMultiLine(wnd) ||
  293.         (!TextBlockMarked(wnd)
  294.             && MouseX+wnd->wleft < strlen(wnd->text)))
  295.         wnd->CurrCol = MouseX+wnd->wleft;
  296.     SendMessage(wnd, KEYBOARD_CURSOR, WndCol, wnd->WndRow);
  297.     return TRUE;
  298. }
  299. /* ----------- MOUSE_MOVED Message ---------- */
  300. static int MouseMovedMsg(WINDOW wnd, PARAM p1, PARAM p2)
  301. {
  302.     int MouseX = (int) p1 - GetClientLeft(wnd);
  303.     int MouseY = (int) p2 - GetClientTop(wnd);
  304.     RECT rc = ClientRect(wnd);
  305.     if (!InsideRect(p1, p2, rc))
  306.         return FALSE;
  307.     if (MouseY > wnd->wlines-1)
  308.         return FALSE;
  309.     if (ButtonDown)    {
  310.         SetAnchor(wnd, ButtonX+wnd->wleft, ButtonY+wnd->wtop);
  311.         TextMarking = TRUE;
  312.         rc = WindowRect(wnd);
  313.         SendMessage(NULL,MOUSE_TRAVEL,(PARAM) &rc, 0);
  314.         ButtonDown = FALSE;
  315.     }
  316.     if (TextMarking && !(WindowMoving || WindowSizing))    {
  317.         ExtendBlock(wnd, MouseX, MouseY);
  318.         return TRUE;
  319.     }
  320.     return FALSE;
  321. }
  322. static void StopMarking(WINDOW wnd)
  323. {
  324.     TextMarking = FALSE;
  325.     if (wnd->BlkBegLine > wnd->BlkEndLine)    {
  326.         swap(wnd->BlkBegLine, wnd->BlkEndLine);
  327.         swap(wnd->BlkBegCol, wnd->BlkEndCol);
  328.     }
  329.     if (wnd->BlkBegLine == wnd->BlkEndLine &&
  330.             wnd->BlkBegCol > wnd->BlkEndCol)
  331.         swap(wnd->BlkBegCol, wnd->BlkEndCol);
  332. }
  333. /* ----------- BUTTON_RELEASED Message ---------- */
  334. static int ButtonReleasedMsg(WINDOW wnd)
  335. {
  336.     if (isMultiLine(wnd))    {
  337.         ButtonDown = FALSE;
  338.         if (TextMarking && !(WindowMoving || WindowSizing))  {
  339.             /* release the mouse ouside the edit box */
  340.             SendMessage(NULL, MOUSE_TRAVEL, 0, 0);
  341.             StopMarking(wnd);
  342.             return TRUE;
  343.         }
  344.         else
  345.             PrevY = -1;
  346.     }
  347.     return FALSE;
  348. }
  349. /* ---- Process text block keys for multiline text box ---- */
  350. static void DoMultiLines(WINDOW wnd, int c, PARAM p2)
  351. {
  352.     if (isMultiLine(wnd))    {
  353.         if ((int)p2 & (LEFTSHIFT | RIGHTSHIFT))    {
  354.             int kx, ky;
  355.             SendMessage(NULL, CURRENT_KEYBOARD_CURSOR,
  356.                 (PARAM) &kx, (PARAM) &ky);
  357.             kx -= GetClientLeft(wnd);
  358.             ky -= GetClientTop(wnd);
  359.             switch (c)    {
  360.                 case HOME:
  361.                 case END:
  362.                 case CTRL_HOME:
  363.                 case CTRL_END:
  364.                 case PGUP:
  365.                 case PGDN:
  366.                 case CTRL_PGUP:
  367.                 case CTRL_PGDN:
  368.                 case UP:
  369.                 case DN:
  370.                 case FWD:
  371.                 case BS:
  372.                 case CTRL_FWD:
  373.                 case CTRL_BS:
  374.                     if (!KeyBoardMarking)    {
  375.                         if (TextBlockMarked(wnd))    {
  376.                             ClearTextBlock(wnd);
  377.                             SendMessage(wnd, PAINT, 0, 0);
  378.                         }
  379.                         KeyBoardMarking = TextMarking = TRUE;
  380.                         SetAnchor(wnd, kx+wnd->wleft,
  381.                                                 ky+wnd->wtop);
  382.                     }
  383.                     break;
  384.                 default:
  385.                     break;
  386.             }
  387.         }
  388.     }
  389. }
  390. /* ---------- page/scroll keys ----------- */
  391. static int DoScrolling(WINDOW wnd, int c, PARAM p2)
  392. {
  393.     switch (c)    {
  394.         case PGUP:
  395.         case PGDN:
  396.             if (isMultiLine(wnd))
  397.                 BaseWndProc(EDITBOX, wnd, KEYBOARD, c, p2);
  398.             break;
  399.         case CTRL_PGUP:
  400.         case CTRL_PGDN:
  401.             BaseWndProc(EDITBOX, wnd, KEYBOARD, c, p2);
  402.             break;
  403.         case HOME:
  404.             Home(wnd);
  405.             break;
  406.         case END:
  407.             End(wnd);
  408.             break;
  409.         case CTRL_FWD:
  410.             NextWord(wnd);
  411.             break;
  412.         case CTRL_BS:
  413.             PrevWord(wnd);
  414.             break;
  415.         case CTRL_HOME:
  416.             if (isMultiLine(wnd))    {
  417.                 SendMessage(wnd, SCROLLDOC, TRUE, 0);
  418.                 wnd->CurrLine = 0;
  419.                 wnd->WndRow = 0;
  420.             }
  421.             Home(wnd);
  422.             break;
  423.         case CTRL_END:
  424.             if (isMultiLine(wnd) &&
  425.                     wnd->WndRow+wnd->wtop+1 < wnd->wlines
  426.                         && wnd->wlines > 0) {
  427.                 SendMessage(wnd, SCROLLDOC, FALSE, 0);
  428.                 SetLinePointer(wnd, wnd->wlines-1);
  429.                 wnd->WndRow =
  430.                     min(ClientHeight(wnd)-1, wnd->wlines-1);
  431.                 Home(wnd);
  432.             }
  433.             End(wnd);
  434.             break;
  435.         case UP:
  436.             if (isMultiLine(wnd))
  437.                 Upward(wnd);
  438.             break;
  439.         case DN:
  440.             if (isMultiLine(wnd))
  441.                 Downward(wnd);
  442.             break;
  443.         case FWD:
  444.             Forward(wnd);
  445.             break;
  446.         case BS:
  447.             Backward(wnd);
  448.             break;
  449.         default:
  450.             return FALSE;
  451.     }
  452.     if (!KeyBoardMarking && TextBlockMarked(wnd))    {
  453.         ClearTextBlock(wnd);
  454.         SendMessage(wnd, PAINT, 0, 0);
  455.     }
  456.     SendMessage(wnd, KEYBOARD_CURSOR, WndCol, wnd->WndRow);
  457.     return TRUE;
  458. }
  459. /* -------------- Del key ---------------- */
  460. static void DelKey(WINDOW wnd)
  461. {
  462.     char *currchar = CurrChar;
  463.     int repaint = *currchar == '\n';
  464.     if (TextBlockMarked(wnd))    {
  465.         SendMessage(wnd, COMMAND, ID_DELETETEXT, 0);
  466.         SendMessage(wnd, PAINT, 0, 0);
  467.         return;
  468.     }
  469.     if (isMultiLine(wnd) && *currchar == '\n' && *(currchar+1) == '\0')
  470.         return;
  471.     strcpy(currchar, currchar+1);
  472.     if (repaint)    {
  473.         BuildTextPointers(wnd);
  474.         SendMessage(wnd, PAINT, 0, 0);
  475.     }
  476.     else    {
  477.         ModTextPointers(wnd, wnd->CurrLine+1, -1);
  478.         WriteTextLine(wnd, NULL, wnd->WndRow+wnd->wtop, FALSE);
  479.     }
  480.     wnd->TextChanged = TRUE;
  481. }
  482. /* ------------ Tab key ------------ */
  483. static void TabKey(WINDOW wnd, PARAM p2)
  484. {
  485.     if (isMultiLine(wnd))    {
  486.         int insmd = wnd->InsertMode;
  487.         do  {
  488.             char *cc = CurrChar+1;
  489.             if (!insmd && *cc == '\0')
  490.                 break;
  491.             if (wnd->textlen == wnd->MaxTextLength)
  492.                 break;
  493.             SendMessage(wnd,KEYBOARD,insmd ? ' ' : FWD,0);
  494.         } while (wnd->CurrCol % cfg.Tabs);
  495.     }
  496.     else
  497.         PostMessage(GetParent(wnd), KEYBOARD, '\t', p2);
  498. }
  499. /* ------------ Shift+Tab key ------------ */
  500. static void ShiftTabKey(WINDOW wnd, PARAM p2)
  501. {
  502.     if (isMultiLine(wnd))    {
  503.         do  {
  504.             if (CurrChar == GetText(wnd))
  505.                 break;
  506.             SendMessage(wnd,KEYBOARD,BS,0);
  507.         } while (wnd->CurrCol % cfg.Tabs);
  508.     }
  509.     else
  510.         PostMessage(GetParent(wnd), KEYBOARD, SHIFT_HT, p2);
  511. }
  512. /* --------- All displayable typed keys ------------- */
  513. static void KeyTyped(WINDOW wnd, int c)
  514. {
  515.     char *currchar = CurrChar;
  516.     if ((c != '\n' && c < ' ') || (c & 0x1000))
  517.         /* ---- not recognized by editor --- */
  518.         return;
  519.     if (!isMultiLine(wnd) && TextBlockMarked(wnd))    {
  520.         SendMessage(wnd, CLEARTEXT, 0, 0);
  521.         currchar = CurrChar;
  522.     }
  523.     /* ---- test typing at end of text ---- */
  524.     if (currchar == wnd->text+wnd->MaxTextLength)    {
  525.         /* ---- typing at the end of maximum buffer ---- */
  526.         beep();
  527.         return;
  528.     }
  529.     if (*currchar == '\0')    {
  530.         /* --- insert a newline at end of text --- */
  531.         *currchar = '\n';
  532.         *(currchar+1) = '\0';
  533.         BuildTextPointers(wnd);
  534.     }
  535.     /* --- displayable char or newline --- */
  536.     if (c == '\n' || wnd->InsertMode || *currchar == '\n') {
  537.         /* ------ inserting the keyed character ------ */
  538.         if (wnd->text[wnd->textlen-1] != '\0')    {
  539.             /* --- the current text buffer is full --- */
  540.             if (wnd->textlen == wnd->MaxTextLength)    {
  541.                 /* --- text buffer is at maximum size --- */
  542.                 beep();
  543.                 return;
  544.             }
  545.             /* ---- increase the text buffer size ---- */
  546.             wnd->textlen += GROWLENGTH;
  547.             /* --- but not above maximum size --- */
  548.             if (wnd->textlen > wnd->MaxTextLength)
  549.                 wnd->textlen = wnd->MaxTextLength;
  550.             wnd->text = DFrealloc(wnd->text, wnd->textlen+2);
  551.             wnd->text[wnd->textlen-1] = '\0';
  552.             currchar = CurrChar;
  553.         }
  554.         memmove(currchar+1, currchar, strlen(currchar)+1);
  555.         ModTextPointers(wnd, wnd->CurrLine+1, 1);
  556.         if (isMultiLine(wnd) && wnd->wlines > 1)
  557.             wnd->textwidth = max(wnd->textwidth,
  558.                 (int) (TextLine(wnd, wnd->CurrLine+1)-
  559.                 TextLine(wnd, wnd->CurrLine)));
  560.         else
  561.             wnd->textwidth = max(wnd->textwidth,
  562.                 strlen(wnd->text));
  563.         WriteTextLine(wnd, NULL,
  564.             wnd->wtop+wnd->WndRow, FALSE);
  565.     }
  566.     /* ----- put the char in the buffer ----- */
  567.     *currchar = c;
  568.     wnd->TextChanged = TRUE;
  569.     if (c == '\n')    {
  570.         wnd->wleft = 0;
  571.         BuildTextPointers(wnd);
  572.         End(wnd);
  573.         Forward(wnd);
  574.         SendMessage(wnd, PAINT, 0, 0);
  575.         return;
  576.     }
  577.     /* ---------- test end of window --------- */
  578.     if (WndCol == ClientWidth(wnd)-1)    {
  579.         if (!isMultiLine(wnd))    {
  580.             if (!(currchar == wnd->text+wnd->MaxTextLength-2))
  581.             SendMessage(wnd, HORIZSCROLL, TRUE, 0);
  582.         }
  583.         else    {
  584.             char *cp = currchar;
  585.             while (*cp != ' ' && cp != TextLine(wnd, wnd->CurrLine))
  586.                 --cp;
  587.             if (cp == TextLine(wnd, wnd->CurrLine) ||
  588.                     !wnd->WordWrapMode)
  589.                 SendMessage(wnd, HORIZSCROLL, TRUE, 0);
  590.             else    {
  591.                 int dif = 0;
  592.                 if (c != ' ')    {
  593.                     dif = (int) (currchar - cp);
  594.                     wnd->CurrCol -= dif;
  595.                     SendMessage(wnd, KEYBOARD, DEL, 0);
  596.                     --dif;
  597.                 }
  598.                 SendMessage(wnd, KEYBOARD, '\n', 0);
  599.                 currchar = CurrChar;
  600.                 wnd->CurrCol = dif;
  601.                 if (c == ' ')
  602.                     return;
  603.             }
  604.         }
  605.     }
  606.     /* ------ display the character ------ */
  607.     SetStandardColor(wnd);
  608.     PutWindowChar(wnd, c, WndCol, wnd->WndRow);
  609.     /* ----- advance the pointers ------ */
  610.     wnd->CurrCol++;
  611. }
  612. /* ------------ screen changing key strokes ------------- */
  613. static void DoKeyStroke(WINDOW wnd, int c, PARAM p2)
  614. {
  615.     switch (c)    {
  616.         case RUBOUT:
  617.             if (wnd->CurrCol == 0 && wnd->CurrLine == 0)
  618.                 break;
  619.             Backward(wnd);
  620.         case DEL:
  621.             DelKey(wnd);
  622.             break;
  623.         case SHIFT_HT:
  624.             ShiftTabKey(wnd, p2);
  625.             break;
  626.         case '\t':
  627.             TabKey(wnd, p2);
  628.             break;
  629.         case '\r':
  630.             if (!isMultiLine(wnd))    {
  631.                 PostMessage(GetParent(wnd), KEYBOARD, c, p2);
  632.                 break;
  633.             }
  634.             c = '\n';
  635.         default:
  636.             if (TextBlockMarked(wnd))    {
  637.                 SendMessage(wnd, COMMAND, ID_DELETETEXT, 0);
  638.                 SendMessage(wnd, PAINT, 0, 0);
  639.             }
  640.             KeyTyped(wnd, c);
  641.             break;
  642.     }
  643. }
  644. /* ----------- KEYBOARD Message ---------- */
  645. static int KeyboardMsg(WINDOW wnd, PARAM p1, PARAM p2)
  646. {
  647.     int c = (int) p1;
  648.     if (WindowMoving || WindowSizing || ((int)p2 & ALTKEY))
  649.         return FALSE;
  650.     switch (c)    {
  651.         /* --- these keys get processed by lower classes --- */
  652.         case ESC:
  653.         case F1:
  654.         case F2:
  655.         case F3:
  656.         case F4:
  657.         case F5:
  658.         case F6:
  659.         case F7:
  660.         case F8:
  661.         case F9:
  662.         case F10:
  663.         case INS:
  664.         case SHIFT_INS:
  665.         case SHIFT_DEL:
  666.             return FALSE;
  667.         /* --- these keys get processed here --- */
  668.         case CTRL_FWD:
  669.         case CTRL_BS:
  670.         case CTRL_HOME:
  671.         case CTRL_END:
  672.         case CTRL_PGUP:
  673.         case CTRL_PGDN:
  674.             break;
  675.         default:
  676.             /* other ctrl keys get processed by lower classes */
  677.             if ((int)p2 & CTRLKEY)
  678.                 return FALSE;
  679.             /* --- all other keys get processed here --- */
  680.             break;
  681.     }
  682.     DoMultiLines(wnd, c, p2);
  683.     if (DoScrolling(wnd, c, p2))    {
  684.         if (KeyBoardMarking)
  685.             ExtendBlock(wnd, WndCol, wnd->WndRow);
  686.     }
  687.     else if (!TestAttribute(wnd, READONLY))    {
  688.         DoKeyStroke(wnd, c, p2);
  689.         SendMessage(wnd, KEYBOARD_CURSOR, WndCol, wnd->WndRow);
  690.     }
  691.     else
  692.         beep();
  693.     return TRUE;
  694. }
  695. /* ----------- SHIFT_CHANGED Message ---------- */
  696. static void ShiftChangedMsg(WINDOW wnd, PARAM p1)
  697. {
  698.     if (!((int)p1 & (LEFTSHIFT | RIGHTSHIFT)) &&
  699.                                    KeyBoardMarking)    {
  700.         StopMarking(wnd);
  701.         KeyBoardMarking = FALSE;
  702.     }
  703. }
  704. /* ----------- ID_DELETETEXT Command ---------- */
  705. static void DeleteTextCmd(WINDOW wnd)
  706. {
  707.     if (TextBlockMarked(wnd))    {
  708.         char *bbl=TextLine(wnd,wnd->BlkBegLine)+wnd->BlkBegCol;
  709.         char *bel=TextLine(wnd,wnd->BlkEndLine)+wnd->BlkEndCol;
  710.         int len = (int) (bel - bbl);
  711.         SaveDeletedText(wnd, bbl, len);
  712.         wnd->TextChanged = TRUE;
  713.         strcpy(bbl, bel);
  714.         wnd->CurrLine = TextLineNumber(wnd, bbl-wnd->BlkBegCol);
  715.         wnd->CurrCol = wnd->BlkBegCol;
  716.         wnd->WndRow = wnd->BlkBegLine - wnd->wtop;
  717.         if (wnd->WndRow < 0)    {
  718.             wnd->wtop = wnd->BlkBegLine;
  719.             wnd->WndRow = 0;
  720.         }
  721.         SendMessage(wnd, KEYBOARD_CURSOR, WndCol, wnd->WndRow);
  722.         ClearTextBlock(wnd);
  723.         BuildTextPointers(wnd);
  724.     }
  725. }
  726. /* ----------- ID_CLEAR Command ---------- */
  727. static void ClearCmd(WINDOW wnd)
  728. {
  729.     if (TextBlockMarked(wnd))    {
  730.         char *bbl=TextLine(wnd,wnd->BlkBegLine)+wnd->BlkBegCol;
  731.         char *bel=TextLine(wnd,wnd->BlkEndLine)+wnd->BlkEndCol;
  732.         int len = (int) (bel - bbl);
  733.         SaveDeletedText(wnd, bbl, len);
  734.         wnd->CurrLine = TextLineNumber(wnd, bbl);
  735.         wnd->CurrCol = wnd->BlkBegCol;
  736.         wnd->WndRow = wnd->BlkBegLine - wnd->wtop;
  737.         if (wnd->WndRow < 0)    {
  738.             wnd->WndRow = 0;
  739.             wnd->wtop = wnd->BlkBegLine;
  740.         }
  741.         /* ------ change all text lines in block to \n ----- */
  742.         while (bbl < bel)    {
  743.             char *cp = strchr(bbl, '\n');
  744.             if (cp > bel)
  745.                 cp = bel;
  746.             strcpy(bbl, cp);
  747.             bel -= (int) (cp - bbl);
  748.             bbl++;
  749.         }
  750.         ClearTextBlock(wnd);
  751.         BuildTextPointers(wnd);
  752.         SendMessage(wnd, KEYBOARD_CURSOR, WndCol, wnd->WndRow);
  753.         wnd->TextChanged = TRUE;
  754.     }
  755. }
  756. /* ----------- ID_UNDO Command ---------- */
  757. static void UndoCmd(WINDOW wnd)
  758. {
  759.     if (wnd->DeletedText != NULL)    {
  760.         PasteText(wnd, wnd->DeletedText, wnd->DeletedLength);
  761.         free(wnd->DeletedText);
  762.         wnd->DeletedText = NULL;
  763.         wnd->DeletedLength = 0;
  764.         SendMessage(wnd, PAINT, 0, 0);
  765.     }
  766. }
  767. /* ----------- ID_PARAGRAPH Command ---------- */
  768. static void ParagraphCmd(WINDOW wnd)
  769. {
  770.     int bc, fl;
  771.     char *bl, *bbl, *bel, *bb;
  772.  
  773.     ClearTextBlock(wnd);
  774.     /* ---- forming paragraph from cursor position --- */
  775.     fl = wnd->wtop + wnd->WndRow;
  776.     bbl = bel = bl = TextLine(wnd, wnd->CurrLine);
  777.     if ((bc = wnd->CurrCol) >= ClientWidth(wnd))
  778.         bc = 0;
  779.     Home(wnd);
  780.     /* ---- locate the end of the paragraph ---- */
  781.     while (*bel)    {
  782.         int blank = TRUE;
  783.         char *bll = bel;
  784.         /* --- blank line marks end of paragraph --- */
  785.         while (*bel && *bel != '\n')    {
  786.             if (*bel != ' ')
  787.                 blank = FALSE;
  788.             bel++;
  789.         }
  790.         if (blank)    {
  791.             bel = bll;
  792.             break;
  793.         }
  794.         if (*bel)
  795.             bel++;
  796.     }
  797.     if (bel == bbl)    {
  798.         SendMessage(wnd, KEYBOARD, DN, 0);
  799.         return;
  800.     }
  801.     if (*bel == '\0')
  802.         --bel;
  803.     if (*bel == '\n')
  804.         --bel;
  805.     /* --- change all newlines in block to spaces --- */
  806.     while (CurrChar < bel)    {
  807.         if (*CurrChar == '\n')    {
  808.             *CurrChar = ' ';
  809.             wnd->CurrLine++;
  810.             wnd->CurrCol = 0;
  811.         }
  812.         else
  813.             wnd->CurrCol++;
  814.     }
  815.     /* ---- insert newlines at new margin boundaries ---- */
  816.     bb = bbl;
  817.     while (bbl < bel)    {
  818.         bbl++;
  819.         if ((int)(bbl - bb) == ClientWidth(wnd)-1)    {
  820.             while (*bbl != ' ' && bbl > bb)
  821.                 --bbl;
  822.             if (*bbl != ' ')    {
  823.                 bbl = strchr(bbl, ' ');
  824.                 if (bbl == NULL || bbl >= bel)
  825.                     break;
  826.             }
  827.             *bbl = '\n';
  828.             bb = bbl+1;
  829.         }
  830.     }
  831.     BuildTextPointers(wnd);
  832.     /* --- put cursor back at beginning --- */
  833.     wnd->CurrLine = TextLineNumber(wnd, bl);
  834.     wnd->CurrCol = bc;
  835.     if (fl < wnd->wtop)
  836.         wnd->wtop = fl;
  837.     wnd->WndRow = fl - wnd->wtop;
  838.     SendMessage(wnd, PAINT, 0, 0);
  839.     SendMessage(wnd, KEYBOARD_CURSOR, WndCol, wnd->WndRow);
  840.     wnd->TextChanged = TRUE;
  841.     BuildTextPointers(wnd);
  842. }
  843. /* ----------- COMMAND Message ---------- */
  844. static int CommandMsg(WINDOW wnd, PARAM p1)
  845. {
  846.     switch ((int)p1)    {
  847.         case ID_DELETETEXT:
  848.             DeleteTextCmd(wnd);
  849.             return TRUE;
  850.         case ID_CLEAR:
  851.             ClearCmd(wnd);
  852.             return TRUE;
  853.         case ID_UNDO:
  854.             UndoCmd(wnd);
  855.             return TRUE;
  856.         case ID_PARAGRAPH:
  857.             ParagraphCmd(wnd);
  858.             return TRUE;
  859.         default:
  860.             break;
  861.     }
  862.     return FALSE;
  863. }
  864. /* ---------- CLOSE_WINDOW Message ----------- */
  865. static int CloseWindowMsg(WINDOW wnd, PARAM p1, PARAM p2)
  866. {
  867.     int rtn;
  868.     SendMessage(NULL, HIDE_CURSOR, 0, 0);
  869.     if (wnd->DeletedText != NULL)
  870.         free(wnd->DeletedText);
  871.     rtn = BaseWndProc(EDITBOX, wnd, CLOSE_WINDOW, p1, p2);
  872.     if (wnd->text != NULL)    {
  873.         free(wnd->text);
  874.         wnd->text = NULL;
  875.     }
  876.     return rtn;
  877. }
  878. /* ------- Window processing module for EDITBOX class ------ */
  879. int EditBoxProc(WINDOW wnd, MESSAGE msg, PARAM p1, PARAM p2)
  880. {
  881.     int rtn;
  882.     switch (msg)    {
  883.         case CREATE_WINDOW:
  884.             return CreateWindowMsg(wnd);
  885.         case ADDTEXT:
  886.             return AddTextMsg(wnd, p1, p2);
  887.         case SETTEXT:
  888.             return SetTextMsg(wnd, p1);
  889.         case CLEARTEXT:
  890.             return ClearTextMsg(wnd);
  891.         case GETTEXT:
  892.             return GetTextMsg(wnd, p1, p2);
  893.         case SETTEXTLENGTH:
  894.             return SetTextLengthMsg(wnd, (unsigned) p1);
  895.         case KEYBOARD_CURSOR:
  896.             KeyboardCursorMsg(wnd, p1, p2);
  897.             return TRUE;
  898.         case SETFOCUS:
  899.             if (!(int)p1)
  900.                 SendMessage(NULL, HIDE_CURSOR, 0, 0);
  901.         case PAINT:
  902.         case MOVE:
  903.             rtn = BaseWndProc(EDITBOX, wnd, msg, p1, p2);
  904.             SendMessage(wnd,KEYBOARD_CURSOR,WndCol,wnd->WndRow);
  905.             return rtn;
  906.         case SIZE:
  907.             return SizeMsg(wnd, p1, p2);
  908.         case SCROLL:
  909.             return ScrollMsg(wnd, p1);
  910.         case HORIZSCROLL:
  911.             return HorizScrollMsg(wnd, p1);
  912.         case SCROLLPAGE:
  913.             return ScrollPageMsg(wnd, p1);
  914.         case HORIZPAGE:
  915.             return HorizPageMsg(wnd, p1);
  916.         case LEFT_BUTTON:
  917.             if (LeftButtonMsg(wnd, p1, p2))
  918.                 return TRUE;
  919.             break;
  920.         case MOUSE_MOVED:
  921.             if (MouseMovedMsg(wnd, p1, p2))
  922.                 return TRUE;
  923.             break;
  924.         case BUTTON_RELEASED:
  925.             if (ButtonReleasedMsg(wnd))
  926.                 return TRUE;
  927.             break;
  928.         case KEYBOARD:
  929.             if (KeyboardMsg(wnd, p1, p2))
  930.                 return TRUE;
  931.             break;
  932.         case SHIFT_CHANGED:
  933.             ShiftChangedMsg(wnd, p1);
  934.             break;
  935.         case COMMAND:
  936.             if (CommandMsg(wnd, p1))
  937.                 return TRUE;
  938.             break;
  939.         case CLOSE_WINDOW:
  940.             return CloseWindowMsg(wnd, p1, p2);
  941.         default:
  942.             break;
  943.     }
  944.     return BaseWndProc(EDITBOX, wnd, msg, p1, p2);
  945. }
  946. /* ------ save deleted text for the Undo command ------ */
  947. static void SaveDeletedText(WINDOW wnd, char *bbl, int len)
  948. {
  949.     wnd->DeletedLength = len;
  950.     wnd->DeletedText=DFrealloc(wnd->DeletedText,len);
  951.     memmove(wnd->DeletedText, bbl, len);
  952. }
  953. /* ---- cursor right key: right one character position ---- */
  954. static void Forward(WINDOW wnd)
  955. {
  956.     char *cc = CurrChar+1;
  957.     if (*cc == '\0')
  958.         return;
  959.     if (*CurrChar == '\n')    {
  960.         Home(wnd);
  961.         Downward(wnd);
  962.     }
  963.     else    {
  964.         wnd->CurrCol++;
  965.         if (WndCol == ClientWidth(wnd))
  966.             SendMessage(wnd, HORIZSCROLL, TRUE, 0);
  967.     }
  968. }
  969. /* ----- stick the moving cursor to the end of the line ---- */
  970. static void StickEnd(WINDOW wnd)
  971. {
  972.     char *cp = TextLine(wnd, wnd->CurrLine);
  973.     char *cp1 = strchr(cp, '\n');
  974.     int len = cp1 ? (int) (cp1 - cp) : 0;
  975.     wnd->CurrCol = min(len, wnd->CurrCol);
  976.     if (wnd->wleft > wnd->CurrCol)    {
  977.         wnd->wleft = max(0, wnd->CurrCol - 4);
  978.         SendMessage(wnd, PAINT, 0, 0);
  979.     }
  980.     else if (wnd->CurrCol-wnd->wleft >= ClientWidth(wnd))    {
  981.         wnd->wleft = wnd->CurrCol - (ClientWidth(wnd)-1);
  982.         SendMessage(wnd, PAINT, 0, 0);
  983.     }
  984. }
  985. /* --------- cursor down key: down one line --------- */
  986. static void Downward(WINDOW wnd)
  987. {
  988.     if (isMultiLine(wnd) &&
  989.             wnd->WndRow+wnd->wtop+1 < wnd->wlines)  {
  990.         wnd->CurrLine++;
  991.         if (wnd->WndRow == ClientHeight(wnd)-1)
  992.             BaseWndProc(EDITBOX, wnd, SCROLL, TRUE, 0);
  993.         else
  994.             wnd->WndRow++;
  995.         StickEnd(wnd);
  996.     }
  997. }
  998. /* -------- cursor up key: up one line ------------ */
  999. static void Upward(WINDOW wnd)
  1000. {
  1001.     if (isMultiLine(wnd) && wnd->CurrLine != 0)    {
  1002.         --wnd->CurrLine;
  1003.         if (wnd->WndRow == 0)
  1004.             BaseWndProc(EDITBOX, wnd, SCROLL, FALSE, 0);
  1005.         else
  1006.             --wnd->WndRow;
  1007.         StickEnd(wnd);
  1008.     }
  1009. }
  1010. /* ---- cursor left key: left one character position ---- */
  1011. static void Backward(WINDOW wnd)
  1012. {
  1013.     if (wnd->CurrCol)    {
  1014.         --wnd->CurrCol;
  1015.         if (wnd->CurrCol < wnd->wleft)
  1016.             SendMessage(wnd, HORIZSCROLL, FALSE, 0);
  1017.     }
  1018.     else if (isMultiLine(wnd) && wnd->CurrLine != 0)    {
  1019.         Upward(wnd);
  1020.         End(wnd);
  1021.     }
  1022. }
  1023. /* -------- End key: to end of line ------- */
  1024. static void End(WINDOW wnd)
  1025. {
  1026.     while (*CurrChar && *CurrChar != '\n')
  1027.         ++wnd->CurrCol;
  1028.     if (WndCol >= ClientWidth(wnd))    {
  1029.         wnd->wleft = wnd->CurrCol - (ClientWidth(wnd)-1);
  1030.         SendMessage(wnd, PAINT, 0, 0);
  1031.     }
  1032. }
  1033. /* -------- Home key: to beginning of line ------- */
  1034. static void Home(WINDOW wnd)
  1035. {
  1036.     wnd->CurrCol = 0;
  1037.     if (wnd->wleft != 0)    {
  1038.         wnd->wleft = 0;
  1039.         SendMessage(wnd, PAINT, 0, 0);
  1040.     }
  1041. }
  1042. /* -- Ctrl+cursor right key: to beginning of next word -- */
  1043. static void NextWord(WINDOW wnd)
  1044. {
  1045.     int savetop = wnd->wtop;
  1046.     int saveleft = wnd->wleft;
  1047.     ClearVisible(wnd);
  1048.     while (!isWhite(*CurrChar))    {
  1049.         char *cc = CurrChar+1;
  1050.         if (*cc == '\0')
  1051.             break;
  1052.         Forward(wnd);
  1053.     }
  1054.     while (isWhite(*CurrChar))    {
  1055.         char *cc = CurrChar+1;
  1056.         if (*cc == '\0')
  1057.             break;
  1058.         Forward(wnd);
  1059.     }
  1060.     SetVisible(wnd);
  1061.     SendMessage(wnd, KEYBOARD_CURSOR, WndCol, wnd->WndRow);
  1062.     if (wnd->wtop != savetop || wnd->wleft != saveleft)
  1063.         SendMessage(wnd, PAINT, 0, 0);
  1064. }
  1065. /* -- Ctrl+cursor left key: to beginning of previous word -- */
  1066. static void PrevWord(WINDOW wnd)
  1067. {
  1068.     int savetop = wnd->wtop;
  1069.     int saveleft = wnd->wleft;
  1070.     ClearVisible(wnd);
  1071.     Backward(wnd);
  1072.     while (isWhite(*CurrChar))    {
  1073.         if (wnd->CurrLine == 0 && wnd->CurrCol == 0)
  1074.             break;
  1075.         Backward(wnd);
  1076.     }
  1077.     while (wnd->CurrCol != 0 && !isWhite(*CurrChar))
  1078.         Backward(wnd);
  1079.     if (isWhite(*CurrChar))
  1080.         Forward(wnd);
  1081.     SetVisible(wnd);
  1082.     if (wnd->wleft != saveleft)
  1083.         if (wnd->CurrCol >= saveleft)
  1084.             if (wnd->CurrCol - saveleft < ClientWidth(wnd))
  1085.                 wnd->wleft = saveleft;
  1086.     SendMessage(wnd, KEYBOARD_CURSOR, WndCol, wnd->WndRow);
  1087.     if (wnd->wtop != savetop || wnd->wleft != saveleft)
  1088.         SendMessage(wnd, PAINT, 0, 0);
  1089. }
  1090. /* ----- modify text pointers from a specified position
  1091.                 by a specified plus or minus amount ----- */
  1092. static void ModTextPointers(WINDOW wnd, int lineno, int var)
  1093. {
  1094.     while (lineno < wnd->wlines)
  1095.         *((wnd->TextPointers) + lineno++) += var;
  1096. }
  1097.  
  1098.