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