git.oblomov.eu Git - wine/blob - controls/edit.c

   1 /*
   2  *      Edit control
   3  *
   4  *      Copyright  David W. Metcalfe, 1994
   5  *      Copyright  William Magro, 1995, 1996
   6  *      Copyright  Frans van Dorsselaer, 1996, 1997
   7  *
   8  */
   9
  10 /*
  11  *      please read EDIT.TODO (and update it when you change things)
  12  */
  13
  14 #include <string.h>
  15 #include "winnt.h"
  16 #include "win.h"
  17 #include "wine/winbase16.h"
  18 #include "combo.h"
  19 #include "local.h"
  20 #include "resource.h"
  21 #include "debug.h"
  22 #include "callback.h"
  23 #include "tweak.h"
  24
  25 #define BUFLIMIT_MULTI          65534   /* maximum buffer size (not including '\0')
  26                                            FIXME: BTW, new specs say 65535 (do you dare ???) */
  27 #define BUFLIMIT_SINGLE         32766   /* maximum buffer size (not including '\0') */
  28 #define BUFSTART_MULTI          1024    /* starting size */
  29 #define BUFSTART_SINGLE         256     /* starting size */
  30 #define GROWLENGTH              64      /* buffers grow by this much */
  31 #define HSCROLL_FRACTION        3       /* scroll window by 1/3 width */
  32
  33 /*
  34  *      extra flags for EDITSTATE.flags field
  35  */
  36 #define EF_MODIFIED             0x0001  /* text has been modified */
  37 #define EF_FOCUSED              0x0002  /* we have input focus */
  38 #define EF_UPDATE               0x0004  /* notify parent of changed state on next WM_PAINT */
  39 #define EF_VSCROLL_TRACK        0x0008  /* don't SetScrollPos() since we are tracking the thumb */
  40 #define EF_HSCROLL_TRACK        0x0010  /* don't SetScrollPos() since we are tracking the thumb */
  41 #define EF_VSCROLL_HACK         0x0020  /* we already have informed the user of the hacked handler */
  42 #define EF_HSCROLL_HACK         0x0040  /* we already have informed the user of the hacked handler */
  43 #define EF_AFTER_WRAP           0x0080  /* the caret is displayed after the last character of a
  44                                            wrapped line, instead of in front of the next character */
  45 #define EF_USE_SOFTBRK          0x0100  /* Enable soft breaks in text. */
  46
  47 typedef enum
  48 {
  49         END_0 = 0,      /* line ends with terminating '\0' character */
  50         END_WRAP,       /* line is wrapped */
  51         END_HARD,       /* line ends with a hard return '\r\n' */
  52         END_SOFT        /* line ends with a soft return '\r\r\n' */
  53 } LINE_END;
  54
  55 typedef struct tagLINEDEF {
  56         INT length;             /* bruto length of a line in bytes */
  57         INT net_length; /* netto length of a line in visible characters */
  58         LINE_END ending;
  59         INT width;              /* width of the line in pixels */
  60         struct tagLINEDEF *next;
  61 } LINEDEF;
  62
  63 typedef struct
  64 {
  65         HANDLE heap;                    /* our own heap */
  66         LPSTR text;                     /* the actual contents of the control */
  67         INT buffer_size;                /* the size of the buffer */
  68         INT buffer_limit;               /* the maximum size to which the buffer may grow */
  69         HFONT font;                     /* NULL means standard system font */
  70         INT x_offset;                   /* scroll offset        for multi lines this is in pixels
  71                                                                 for single lines it's in characters */
  72         INT line_height;                /* height of a screen line in pixels */
  73         INT char_width;         /* average character width in pixels */
  74         DWORD style;                    /* sane version of wnd->dwStyle */
  75         WORD flags;                     /* flags that are not in es->style or wnd->flags (EF_XXX) */
  76         INT undo_insert_count;  /* number of characters inserted in sequence */
  77         INT undo_position;              /* character index of the insertion and deletion */
  78         LPSTR undo_text;                /* deleted text */
  79         INT undo_buffer_size;           /* size of the deleted text buffer */
  80         INT selection_start;            /* == selection_end if no selection */
  81         INT selection_end;              /* == current caret position */
  82         CHAR password_char;             /* == 0 if no password char, and for multi line controls */
  83         INT left_margin;                /* in pixels */
  84         INT right_margin;               /* in pixels */
  85         RECT format_rect;
  86         INT region_posx;                /* Position of cursor relative to region: */
  87         INT region_posy;                /* -1: to left, 0: within, 1: to right */
  88         EDITWORDBREAKPROC16 word_break_proc16;
  89         EDITWORDBREAKPROCA word_break_proc32A;
  90         INT line_count;         /* number of lines */
  91         INT y_offset;                   /* scroll offset in number of lines */
  92         /*
  93          *      only for multi line controls
  94          */
  95         INT lock_count;         /* amount of re-entries in the EditWndProc */
  96         INT tabs_count;
  97         LPINT tabs;
  98         INT text_width;         /* width of the widest line in pixels */
  99         LINEDEF *first_line_def;        /* linked list of (soft) linebreaks */
 100         HLOCAL16 hloc16;                /* for controls receiving EM_GETHANDLE16 */
 101         HLOCAL hloc32;          /* for controls receiving EM_GETHANDLE */
 102 } EDITSTATE;
 103
 104
 105 #define SWAP_INT32(x,y) do { INT temp = (INT)(x); (x) = (INT)(y); (y) = temp; } while(0)
 106 #define ORDER_INT(x,y) do { if ((INT)(y) < (INT)(x)) SWAP_INT32((x),(y)); } while(0)
 107
 108 #define SWAP_UINT32(x,y) do { UINT temp = (UINT)(x); (x) = (UINT)(y); (y) = temp; } while(0)
 109 #define ORDER_UINT(x,y) do { if ((UINT)(y) < (UINT)(x)) SWAP_UINT32((x),(y)); } while(0)
 110
 111 #define DPRINTF_EDIT_NOTIFY(hwnd, str) \
 112         ({TRACE(edit, "notification " str " sent to hwnd=%08x\n", \
 113                        (UINT)(hwnd));})
 114
 115 #define EDIT_SEND_CTLCOLOR(wnd,hdc) \
 116         (SendMessageA((wnd)->parent->hwndSelf, WM_CTLCOLOREDIT, \
 117                         (WPARAM)(hdc), (LPARAM)(wnd)->hwndSelf))
 118 #define EDIT_NOTIFY_PARENT(wnd, wNotifyCode, str) \
 119         (DPRINTF_EDIT_NOTIFY((wnd)->parent->hwndSelf, str), \
 120         SendMessageA((wnd)->parent->hwndSelf, WM_COMMAND, \
 121                         MAKEWPARAM((wnd)->wIDmenu, wNotifyCode), \
 122                         (LPARAM)(wnd)->hwndSelf))
 123 #define DPRINTF_EDIT_MSG16(str) \
 124         TRACE(edit, \
 125                      "16 bit : " str ": hwnd=%08x, wParam=%08x, lParam=%08x\n", \
 126                      (UINT)hwnd, (UINT)wParam, (UINT)lParam)
 127 #define DPRINTF_EDIT_MSG32(str) \
 128         TRACE(edit, \
 129                      "32 bit : " str ": hwnd=%08x, wParam=%08x, lParam=%08x\n", \
 130                      (UINT)hwnd, (UINT)wParam, (UINT)lParam)
 131
 132 /*********************************************************************
 133  *
 134  *      Declarations
 135  *
 136  */
 137
 138 /*
 139  *      These functions have trivial implementations
 140  *      We still like to call them internally
 141  *      "static __inline__" makes them more like macro's
 142  */
 143 static __inline__ BOOL  EDIT_EM_CanUndo(WND *wnd, EDITSTATE *es);
 144 static __inline__ void          EDIT_EM_EmptyUndoBuffer(WND *wnd, EDITSTATE *es);
 145 static __inline__ void          EDIT_WM_Clear(WND *wnd, EDITSTATE *es);
 146 static __inline__ void          EDIT_WM_Cut(WND *wnd, EDITSTATE *es);
 147 /*
 148  *      This is the only exported function
 149  */
 150 LRESULT WINAPI EditWndProc( HWND hwnd, UINT msg,
 151                             WPARAM wParam, LPARAM lParam );
 152 /*
 153  *      Helper functions only valid for one type of control
 154  */
 155 static void     EDIT_BuildLineDefs_ML(WND *wnd, EDITSTATE *es);
 156 static LPSTR    EDIT_GetPasswordPointer_SL(WND *wnd, EDITSTATE *es);
 157 static void     EDIT_MoveDown_ML(WND *wnd, EDITSTATE *es, BOOL extend);
 158 static void     EDIT_MovePageDown_ML(WND *wnd, EDITSTATE *es, BOOL extend);
 159 static void     EDIT_MovePageUp_ML(WND *wnd, EDITSTATE *es, BOOL extend);
 160 static void     EDIT_MoveUp_ML(WND *wnd, EDITSTATE *es, BOOL extend);
 161 /*
 162  *      Helper functions valid for both single line _and_ multi line controls
 163  */
 164 static INT      EDIT_CallWordBreakProc(WND *wnd, EDITSTATE *es, INT start, INT index, INT count, INT action);
 165 static INT      EDIT_CharFromPos(WND *wnd, EDITSTATE *es, INT x, INT y, LPBOOL after_wrap);
 166 static void     EDIT_ConfinePoint(WND *wnd, EDITSTATE *es, LPINT x, LPINT y);
 167 static void     EDIT_GetLineRect(WND *wnd, EDITSTATE *es, INT line, INT scol, INT ecol, LPRECT rc);
 168 static void     EDIT_InvalidateText(WND *wnd, EDITSTATE *es, INT start, INT end);
 169 static void     EDIT_LockBuffer(WND *wnd, EDITSTATE *es);
 170 static BOOL     EDIT_MakeFit(WND *wnd, EDITSTATE *es, INT size);
 171 static BOOL     EDIT_MakeUndoFit(WND *wnd, EDITSTATE *es, INT size);
 172 static void     EDIT_MoveBackward(WND *wnd, EDITSTATE *es, BOOL extend);
 173 static void     EDIT_MoveEnd(WND *wnd, EDITSTATE *es, BOOL extend);
 174 static void     EDIT_MoveForward(WND *wnd, EDITSTATE *es, BOOL extend);
 175 static void     EDIT_MoveHome(WND *wnd, EDITSTATE *es, BOOL extend);
 176 static void     EDIT_MoveWordBackward(WND *wnd, EDITSTATE *es, BOOL extend);
 177 static void     EDIT_MoveWordForward(WND *wnd, EDITSTATE *es, BOOL extend);
 178 static void     EDIT_PaintLine(WND *wnd, EDITSTATE *es, HDC hdc, INT line, BOOL rev);
 179 static INT      EDIT_PaintText(WND *wnd, EDITSTATE *es, HDC hdc, INT x, INT y, INT line, INT col, INT count, BOOL rev);
 180 static void     EDIT_SetCaretPos(WND *wnd, EDITSTATE *es, INT pos, BOOL after_wrap);
 181 static void     EDIT_SetRectNP(WND *wnd, EDITSTATE *es, LPRECT lprc);
 182 static void     EDIT_UnlockBuffer(WND *wnd, EDITSTATE *es, BOOL force);
 183 static INT      EDIT_WordBreakProc(LPSTR s, INT index, INT count, INT action);
 184 /*
 185  *      EM_XXX message handlers
 186  */
 187 static LRESULT  EDIT_EM_CharFromPos(WND *wnd, EDITSTATE *es, INT x, INT y);
 188 static BOOL     EDIT_EM_FmtLines(WND *wnd, EDITSTATE *es, BOOL add_eol);
 189 static HLOCAL   EDIT_EM_GetHandle(WND *wnd, EDITSTATE *es);
 190 static HLOCAL16 EDIT_EM_GetHandle16(WND *wnd, EDITSTATE *es);
 191 static INT      EDIT_EM_GetLine(WND *wnd, EDITSTATE *es, INT line, LPSTR lpch);
 192 static LRESULT  EDIT_EM_GetSel(WND *wnd, EDITSTATE *es, LPUINT start, LPUINT end);
 193 static LRESULT  EDIT_EM_GetThumb(WND *wnd, EDITSTATE *es);
 194 static INT      EDIT_EM_LineFromChar(WND *wnd, EDITSTATE *es, INT index);
 195 static INT      EDIT_EM_LineIndex(WND *wnd, EDITSTATE *es, INT line);
 196 static INT      EDIT_EM_LineLength(WND *wnd, EDITSTATE *es, INT index);
 197 static BOOL     EDIT_EM_LineScroll(WND *wnd, EDITSTATE *es, INT dx, INT dy);
 198 static LRESULT  EDIT_EM_PosFromChar(WND *wnd, EDITSTATE *es, INT index, BOOL after_wrap);
 199 static void     EDIT_EM_ReplaceSel(WND *wnd, EDITSTATE *es, BOOL can_undo, LPCSTR lpsz_replace);
 200 static LRESULT  EDIT_EM_Scroll(WND *wnd, EDITSTATE *es, INT action);
 201 static void     EDIT_EM_ScrollCaret(WND *wnd, EDITSTATE *es);
 202 static void     EDIT_EM_SetHandle(WND *wnd, EDITSTATE *es, HLOCAL hloc);
 203 static void     EDIT_EM_SetHandle16(WND *wnd, EDITSTATE *es, HLOCAL16 hloc);
 204 static void     EDIT_EM_SetLimitText(WND *wnd, EDITSTATE *es, INT limit);
 205 static void     EDIT_EM_SetMargins(WND *wnd, EDITSTATE *es, INT action, INT left, INT right);
 206 static void     EDIT_EM_SetPasswordChar(WND *wnd, EDITSTATE *es, CHAR c);
 207 static void     EDIT_EM_SetSel(WND *wnd, EDITSTATE *es, UINT start, UINT end, BOOL after_wrap);
 208 static BOOL     EDIT_EM_SetTabStops(WND *wnd, EDITSTATE *es, INT count, LPINT tabs);
 209 static BOOL     EDIT_EM_SetTabStops16(WND *wnd, EDITSTATE *es, INT count, LPINT16 tabs);
 210 static void     EDIT_EM_SetWordBreakProc(WND *wnd, EDITSTATE *es, EDITWORDBREAKPROCA wbp);
 211 static void     EDIT_EM_SetWordBreakProc16(WND *wnd, EDITSTATE *es, EDITWORDBREAKPROC16 wbp);
 212 static BOOL     EDIT_EM_Undo(WND *wnd, EDITSTATE *es);
 213 /*
 214  *      WM_XXX message handlers
 215  */
 216 static void     EDIT_WM_Char(WND *wnd, EDITSTATE *es, CHAR c, DWORD key_data);
 217 static void     EDIT_WM_Command(WND *wnd, EDITSTATE *es, INT code, INT id, HWND conrtol);
 218 static void     EDIT_WM_ContextMenu(WND *wnd, EDITSTATE *es, HWND hwnd, INT x, INT y);
 219 static void     EDIT_WM_Copy(WND *wnd, EDITSTATE *es);
 220 static LRESULT  EDIT_WM_Create(WND *wnd, EDITSTATE *es, LPCREATESTRUCTA cs);
 221 static void     EDIT_WM_Destroy(WND *wnd, EDITSTATE *es);
 222 static LRESULT  EDIT_WM_EraseBkGnd(WND *wnd, EDITSTATE *es, HDC dc);
 223 static INT      EDIT_WM_GetText(WND *wnd, EDITSTATE *es, INT count, LPSTR text);
 224 static LRESULT  EDIT_WM_HScroll(WND *wnd, EDITSTATE *es, INT action, INT pos, HWND scroll_bar);
 225 static LRESULT  EDIT_WM_KeyDown(WND *wnd, EDITSTATE *es, INT key, DWORD key_data);
 226 static LRESULT  EDIT_WM_KillFocus(WND *wnd, EDITSTATE *es, HWND window_getting_focus);
 227 static LRESULT  EDIT_WM_LButtonDblClk(WND *wnd, EDITSTATE *es, DWORD keys, INT x, INT y);
 228 static LRESULT  EDIT_WM_LButtonDown(WND *wnd, EDITSTATE *es, DWORD keys, INT x, INT y);
 229 static LRESULT  EDIT_WM_LButtonUp(WND *wnd, EDITSTATE *es, DWORD keys, INT x, INT y);
 230 static LRESULT  EDIT_WM_MouseMove(WND *wnd, EDITSTATE *es, DWORD keys, INT x, INT y);
 231 static LRESULT  EDIT_WM_NCCreate(WND *wnd, LPCREATESTRUCTA cs);
 232 static void     EDIT_WM_Paint(WND *wnd, EDITSTATE *es);
 233 static void     EDIT_WM_Paste(WND *wnd, EDITSTATE *es);
 234 static void     EDIT_WM_SetFocus(WND *wnd, EDITSTATE *es, HWND window_losing_focus);
 235 static void     EDIT_WM_SetFont(WND *wnd, EDITSTATE *es, HFONT font, BOOL redraw);
 236 static void     EDIT_WM_SetText(WND *wnd, EDITSTATE *es, LPCSTR text);
 237 static void     EDIT_WM_Size(WND *wnd, EDITSTATE *es, UINT action, INT width, INT height);
 238 static LRESULT  EDIT_WM_SysKeyDown(WND *wnd, EDITSTATE *es, INT key, DWORD key_data);
 239 static void     EDIT_WM_Timer(WND *wnd, EDITSTATE *es, INT id, TIMERPROC timer_proc);
 240 static LRESULT  EDIT_WM_VScroll(WND *wnd, EDITSTATE *es, INT action, INT pos, HWND scroll_bar);
 241
 242
 243 /*********************************************************************
 244  *
 245  *      EM_CANUNDO
 246  *
 247  */
 248 static __inline__ BOOL EDIT_EM_CanUndo(WND *wnd, EDITSTATE *es)
 249 {
 250         return (es->undo_insert_count || lstrlenA(es->undo_text));
 251 }
 252
 253
 254 /*********************************************************************
 255  *
 256  *      EM_EMPTYUNDOBUFFER
 257  *
 258  */
 259 static __inline__ void EDIT_EM_EmptyUndoBuffer(WND *wnd, EDITSTATE *es)
 260 {
 261         es->undo_insert_count = 0;
 262         *es->undo_text = '\0';
 263 }
 264
 265
 266 /*********************************************************************
 267  *
 268  *      WM_CLEAR
 269  *
 270  */
 271 static __inline__ void EDIT_WM_Clear(WND *wnd, EDITSTATE *es)
 272 {
 273         EDIT_EM_ReplaceSel(wnd, es, TRUE, "");
 274 }
 275
 276
 277 /*********************************************************************
 278  *
 279  *      WM_CUT
 280  *
 281  */
 282 static __inline__ void EDIT_WM_Cut(WND *wnd, EDITSTATE *es)
 283 {
 284         EDIT_WM_Copy(wnd, es);
 285         EDIT_WM_Clear(wnd, es);
 286 }
 287
 288
 289 /*********************************************************************
 290  *
 291  *      EditWndProc()
 292  *
 293  *      The messages are in the order of the actual integer values
 294  *      (which can be found in include/windows.h)
 295  *      Whereever possible the 16 bit versions are converted to
 296  *      the 32 bit ones, so that we can 'fall through' to the
 297  *      helper functions.  These are mostly 32 bit (with a few
 298  *      exceptions, clearly indicated by a '16' extension to their
 299  *      names).
 300  *
 301  */
 302 LRESULT WINAPI EditWndProc( HWND hwnd, UINT msg,
 303                             WPARAM wParam, LPARAM lParam )
 304 {
 305         WND *wnd = WIN_FindWndPtr(hwnd);
 306         EDITSTATE *es = *(EDITSTATE **)((wnd)->wExtra);
 307         LRESULT result = 0;
 308
 309         switch (msg) {
 310         case WM_DESTROY:
 311                 DPRINTF_EDIT_MSG32("WM_DESTROY");
 312                 EDIT_WM_Destroy(wnd, es);
 313                 result = 0;
 314                 goto END;
 315
 316         case WM_NCCREATE:
 317                 DPRINTF_EDIT_MSG32("WM_NCCREATE");
 318                 result = EDIT_WM_NCCreate(wnd, (LPCREATESTRUCTA)lParam);
 319                 goto END;
 320         }
 321
 322         if (!es)
 323         {
 324             result = DefWindowProcA(hwnd, msg, wParam, lParam);
 325             goto END;
 326         }
 327
 328
 329         EDIT_LockBuffer(wnd, es);
 330         switch (msg) {
 331         case EM_GETSEL16:
 332                 DPRINTF_EDIT_MSG16("EM_GETSEL");
 333                 wParam = 0;
 334                 lParam = 0;
 335                 /* fall through */
 336         case EM_GETSEL:
 337                 DPRINTF_EDIT_MSG32("EM_GETSEL");
 338                 result = EDIT_EM_GetSel(wnd, es, (LPUINT)wParam, (LPUINT)lParam);
 339                 break;
 340
 341         case EM_SETSEL16:
 342                 DPRINTF_EDIT_MSG16("EM_SETSEL");
 343                 if (SLOWORD(lParam) == -1)
 344                         EDIT_EM_SetSel(wnd, es, -1, 0, FALSE);
 345                 else
 346                         EDIT_EM_SetSel(wnd, es, LOWORD(lParam), HIWORD(lParam), FALSE);
 347                 if (!wParam)
 348                         EDIT_EM_ScrollCaret(wnd, es);
 349                 result = 1;
 350                 break;
 351         case EM_SETSEL:
 352                 DPRINTF_EDIT_MSG32("EM_SETSEL");
 353                 EDIT_EM_SetSel(wnd, es, wParam, lParam, FALSE);
 354                 result = 1;
 355                 break;
 356
 357         case EM_GETRECT16:
 358                 DPRINTF_EDIT_MSG16("EM_GETRECT");
 359                 if (lParam)
 360                         CONV_RECT32TO16(&es->format_rect, (LPRECT16)PTR_SEG_TO_LIN(lParam));
 361                 break;
 362         case EM_GETRECT:
 363                 DPRINTF_EDIT_MSG32("EM_GETRECT");
 364                 if (lParam)
 365                         CopyRect((LPRECT)lParam, &es->format_rect);
 366                 break;
 367
 368         case EM_SETRECT16:
 369                 DPRINTF_EDIT_MSG16("EM_SETRECT");
 370                 if ((es->style & ES_MULTILINE) && lParam) {
 371                         RECT rc;
 372                         CONV_RECT16TO32((LPRECT16)PTR_SEG_TO_LIN(lParam), &rc);
 373                         EDIT_SetRectNP(wnd, es, &rc);
 374                         InvalidateRect(wnd->hwndSelf, NULL, TRUE);
 375                 }
 376                 break;
 377         case EM_SETRECT:
 378                 DPRINTF_EDIT_MSG32("EM_SETRECT");
 379                 if ((es->style & ES_MULTILINE) && lParam) {
 380                         EDIT_SetRectNP(wnd, es, (LPRECT)lParam);
 381                         InvalidateRect(wnd->hwndSelf, NULL, TRUE);
 382                 }
 383                 break;
 384
 385         case EM_SETRECTNP16:
 386                 DPRINTF_EDIT_MSG16("EM_SETRECTNP");
 387                 if ((es->style & ES_MULTILINE) && lParam) {
 388                         RECT rc;
 389                         CONV_RECT16TO32((LPRECT16)PTR_SEG_TO_LIN(lParam), &rc);
 390                         EDIT_SetRectNP(wnd, es, &rc);
 391                 }
 392                 break;
 393         case EM_SETRECTNP:
 394                 DPRINTF_EDIT_MSG32("EM_SETRECTNP");
 395                 if ((es->style & ES_MULTILINE) && lParam)
 396                         EDIT_SetRectNP(wnd, es, (LPRECT)lParam);
 397                 break;
 398
 399         case EM_SCROLL16:
 400                 DPRINTF_EDIT_MSG16("EM_SCROLL");
 401                 /* fall through */
 402         case EM_SCROLL:
 403                 DPRINTF_EDIT_MSG32("EM_SCROLL");
 404                 result = EDIT_EM_Scroll(wnd, es, (INT)wParam);
 405                 break;
 406
 407         case EM_LINESCROLL16:
 408                 DPRINTF_EDIT_MSG16("EM_LINESCROLL");
 409                 wParam = (WPARAM)(INT)SHIWORD(lParam);
 410                 lParam = (LPARAM)(INT)SLOWORD(lParam);
 411                 /* fall through */
 412         case EM_LINESCROLL:
 413                 DPRINTF_EDIT_MSG32("EM_LINESCROLL");
 414                 result = (LRESULT)EDIT_EM_LineScroll(wnd, es, (INT)wParam, (INT)lParam);
 415                 break;
 416
 417         case EM_SCROLLCARET16:
 418                 DPRINTF_EDIT_MSG16("EM_SCROLLCARET");
 419                 /* fall through */
 420         case EM_SCROLLCARET:
 421                 DPRINTF_EDIT_MSG32("EM_SCROLLCARET");
 422                 EDIT_EM_ScrollCaret(wnd, es);
 423                 result = 1;
 424                 break;
 425
 426         case EM_GETMODIFY16:
 427                 DPRINTF_EDIT_MSG16("EM_GETMODIFY");
 428                 /* fall through */
 429         case EM_GETMODIFY:
 430                 DPRINTF_EDIT_MSG32("EM_GETMODIFY");
 431                 return ((es->flags & EF_MODIFIED) != 0);
 432                 break;
 433
 434         case EM_SETMODIFY16:
 435                 DPRINTF_EDIT_MSG16("EM_SETMODIFY");
 436                 /* fall through */
 437         case EM_SETMODIFY:
 438                 DPRINTF_EDIT_MSG32("EM_SETMODIFY");
 439                 if (wParam)
 440                         es->flags |= EF_MODIFIED;
 441                 else
 442                         es->flags &= ~EF_MODIFIED;
 443                 break;
 444
 445         case EM_GETLINECOUNT16:
 446                 DPRINTF_EDIT_MSG16("EM_GETLINECOUNT");
 447                 /* fall through */
 448         case EM_GETLINECOUNT:
 449                 DPRINTF_EDIT_MSG32("EM_GETLINECOUNT");
 450                 result = (es->style & ES_MULTILINE) ? es->line_count : 1;
 451                 break;
 452
 453         case EM_LINEINDEX16:
 454                 DPRINTF_EDIT_MSG16("EM_LINEINDEX");
 455                 if ((INT16)wParam == -1)
 456                         wParam = (WPARAM)-1;
 457                 /* fall through */
 458         case EM_LINEINDEX:
 459                 DPRINTF_EDIT_MSG32("EM_LINEINDEX");
 460                 result = (LRESULT)EDIT_EM_LineIndex(wnd, es, (INT)wParam);
 461                 break;
 462
 463         case EM_SETHANDLE16:
 464                 DPRINTF_EDIT_MSG16("EM_SETHANDLE");
 465                 EDIT_EM_SetHandle16(wnd, es, (HLOCAL16)wParam);
 466                 break;
 467         case EM_SETHANDLE:
 468                 DPRINTF_EDIT_MSG32("EM_SETHANDLE");
 469                 EDIT_EM_SetHandle(wnd, es, (HLOCAL)wParam);
 470                 break;
 471
 472         case EM_GETHANDLE16:
 473                 DPRINTF_EDIT_MSG16("EM_GETHANDLE");
 474                 result = (LRESULT)EDIT_EM_GetHandle16(wnd, es);
 475                 break;
 476         case EM_GETHANDLE:
 477                 DPRINTF_EDIT_MSG32("EM_GETHANDLE");
 478                 result = (LRESULT)EDIT_EM_GetHandle(wnd, es);
 479                 break;
 480
 481         case EM_GETTHUMB16:
 482                 DPRINTF_EDIT_MSG16("EM_GETTHUMB");
 483                 /* fall through */
 484         case EM_GETTHUMB:
 485                 DPRINTF_EDIT_MSG32("EM_GETTHUMB");
 486                 result = EDIT_EM_GetThumb(wnd, es);
 487                 break;
 488
 489         /* messages 0x00bf and 0x00c0 missing from specs */
 490
 491         case WM_USER+15:
 492                 DPRINTF_EDIT_MSG16("undocumented WM_USER+15, please report");
 493                 /* fall through */
 494         case 0x00bf:
 495                 DPRINTF_EDIT_MSG32("undocumented 0x00bf, please report");
 496                 result = DefWindowProcA(hwnd, msg, wParam, lParam);
 497                 break;
 498
 499         case WM_USER+16:
 500                 DPRINTF_EDIT_MSG16("undocumented WM_USER+16, please report");
 501                 /* fall through */
 502         case 0x00c0:
 503                 DPRINTF_EDIT_MSG32("undocumented 0x00c0, please report");
 504                 result = DefWindowProcA(hwnd, msg, wParam, lParam);
 505                 break;
 506
 507         case EM_LINELENGTH16:
 508                 DPRINTF_EDIT_MSG16("EM_LINELENGTH");
 509                 /* fall through */
 510         case EM_LINELENGTH:
 511                 DPRINTF_EDIT_MSG32("EM_LINELENGTH");
 512                 result = (LRESULT)EDIT_EM_LineLength(wnd, es, (INT)wParam);
 513                 break;
 514
 515         case EM_REPLACESEL16:
 516                 DPRINTF_EDIT_MSG16("EM_REPLACESEL");
 517                 lParam = (LPARAM)PTR_SEG_TO_LIN((SEGPTR)lParam);
 518                 /* fall through */
 519         case EM_REPLACESEL:
 520                 DPRINTF_EDIT_MSG32("EM_REPLACESEL");
 521                 EDIT_EM_ReplaceSel(wnd, es, (BOOL)wParam, (LPCSTR)lParam);
 522                 result = 1;
 523                 break;
 524
 525         /* message 0x00c3 missing from specs */
 526
 527         case WM_USER+19:
 528                 DPRINTF_EDIT_MSG16("undocumented WM_USER+19, please report");
 529                 /* fall through */
 530         case 0x00c3:
 531                 DPRINTF_EDIT_MSG32("undocumented 0x00c3, please report");
 532                 result = DefWindowProcA(hwnd, msg, wParam, lParam);
 533                 break;
 534
 535         case EM_GETLINE16:
 536                 DPRINTF_EDIT_MSG16("EM_GETLINE");
 537                 lParam = (LPARAM)PTR_SEG_TO_LIN((SEGPTR)lParam);
 538                 /* fall through */
 539         case EM_GETLINE:
 540                 DPRINTF_EDIT_MSG32("EM_GETLINE");
 541                 result = (LRESULT)EDIT_EM_GetLine(wnd, es, (INT)wParam, (LPSTR)lParam);
 542                 break;
 543
 544         case EM_LIMITTEXT16:
 545                 DPRINTF_EDIT_MSG16("EM_LIMITTEXT");
 546                 /* fall through */
 547         case EM_SETLIMITTEXT:
 548                 DPRINTF_EDIT_MSG32("EM_SETLIMITTEXT");
 549                 EDIT_EM_SetLimitText(wnd, es, (INT)wParam);
 550                 break;
 551
 552         case EM_CANUNDO16:
 553                 DPRINTF_EDIT_MSG16("EM_CANUNDO");
 554                 /* fall through */
 555         case EM_CANUNDO:
 556                 DPRINTF_EDIT_MSG32("EM_CANUNDO");
 557                 result = (LRESULT)EDIT_EM_CanUndo(wnd, es);
 558                 break;
 559
 560         case EM_UNDO16:
 561                 DPRINTF_EDIT_MSG16("EM_UNDO");
 562                 /* fall through */
 563         case EM_UNDO:
 564                 /* fall through */
 565         case WM_UNDO:
 566                 DPRINTF_EDIT_MSG32("EM_UNDO / WM_UNDO");
 567                 result = (LRESULT)EDIT_EM_Undo(wnd, es);
 568                 break;
 569
 570         case EM_FMTLINES16:
 571                 DPRINTF_EDIT_MSG16("EM_FMTLINES");
 572                 /* fall through */
 573         case EM_FMTLINES:
 574                 DPRINTF_EDIT_MSG32("EM_FMTLINES");
 575                 result = (LRESULT)EDIT_EM_FmtLines(wnd, es, (BOOL)wParam);
 576                 break;
 577
 578         case EM_LINEFROMCHAR16:
 579                 DPRINTF_EDIT_MSG16("EM_LINEFROMCHAR");
 580                 /* fall through */
 581         case EM_LINEFROMCHAR:
 582                 DPRINTF_EDIT_MSG32("EM_LINEFROMCHAR");
 583                 result = (LRESULT)EDIT_EM_LineFromChar(wnd, es, (INT)wParam);
 584                 break;
 585
 586         /* message 0x00ca missing from specs */
 587
 588         case WM_USER+26:
 589                 DPRINTF_EDIT_MSG16("undocumented WM_USER+26, please report");
 590                 /* fall through */
 591         case 0x00ca:
 592                 DPRINTF_EDIT_MSG32("undocumented 0x00ca, please report");
 593                 result = DefWindowProcA(hwnd, msg, wParam, lParam);
 594                 break;
 595
 596         case EM_SETTABSTOPS16:
 597                 DPRINTF_EDIT_MSG16("EM_SETTABSTOPS");
 598                 result = (LRESULT)EDIT_EM_SetTabStops16(wnd, es, (INT)wParam, (LPINT16)PTR_SEG_TO_LIN((SEGPTR)lParam));
 599                 break;
 600         case EM_SETTABSTOPS:
 601                 DPRINTF_EDIT_MSG32("EM_SETTABSTOPS");
 602                 result = (LRESULT)EDIT_EM_SetTabStops(wnd, es, (INT)wParam, (LPINT)lParam);
 603                 break;
 604
 605         case EM_SETPASSWORDCHAR16:
 606                 DPRINTF_EDIT_MSG16("EM_SETPASSWORDCHAR");
 607                 /* fall through */
 608         case EM_SETPASSWORDCHAR:
 609                 DPRINTF_EDIT_MSG32("EM_SETPASSWORDCHAR");
 610                 EDIT_EM_SetPasswordChar(wnd, es, (CHAR)wParam);
 611                 break;
 612
 613         case EM_EMPTYUNDOBUFFER16:
 614                 DPRINTF_EDIT_MSG16("EM_EMPTYUNDOBUFFER");
 615                 /* fall through */
 616         case EM_EMPTYUNDOBUFFER:
 617                 DPRINTF_EDIT_MSG32("EM_EMPTYUNDOBUFFER");
 618                 EDIT_EM_EmptyUndoBuffer(wnd, es);
 619                 break;
 620
 621         case EM_GETFIRSTVISIBLELINE16:
 622                 DPRINTF_EDIT_MSG16("EM_GETFIRSTVISIBLELINE");
 623                 result = es->y_offset;
 624                 break;
 625         case EM_GETFIRSTVISIBLELINE:
 626                 DPRINTF_EDIT_MSG32("EM_GETFIRSTVISIBLELINE");
 627                 result = (es->style & ES_MULTILINE) ? es->y_offset : es->x_offset;
 628                 break;
 629
 630         case EM_SETREADONLY16:
 631                 DPRINTF_EDIT_MSG16("EM_SETREADONLY");
 632                 /* fall through */
 633         case EM_SETREADONLY:
 634                 DPRINTF_EDIT_MSG32("EM_SETREADONLY");
 635                 if (wParam) {
 636                         wnd->dwStyle |= ES_READONLY;
 637                         es->style |= ES_READONLY;
 638                 } else {
 639                         wnd->dwStyle &= ~ES_READONLY;
 640                         es->style &= ~ES_READONLY;
 641                 }
 642                 result = 1;
 643                 break;
 644
 645         case EM_SETWORDBREAKPROC16:
 646                 DPRINTF_EDIT_MSG16("EM_SETWORDBREAKPROC");
 647                 EDIT_EM_SetWordBreakProc16(wnd, es, (EDITWORDBREAKPROC16)lParam);
 648                 break;
 649         case EM_SETWORDBREAKPROC:
 650                 DPRINTF_EDIT_MSG32("EM_SETWORDBREAKPROC");
 651                 EDIT_EM_SetWordBreakProc(wnd, es, (EDITWORDBREAKPROCA)lParam);
 652                 break;
 653
 654         case EM_GETWORDBREAKPROC16:
 655                 DPRINTF_EDIT_MSG16("EM_GETWORDBREAKPROC");
 656                 result = (LRESULT)es->word_break_proc16;
 657                 break;
 658         case EM_GETWORDBREAKPROC:
 659                 DPRINTF_EDIT_MSG32("EM_GETWORDBREAKPROC");
 660                 result = (LRESULT)es->word_break_proc32A;
 661                 break;
 662
 663         case EM_GETPASSWORDCHAR16:
 664                 DPRINTF_EDIT_MSG16("EM_GETPASSWORDCHAR");
 665                 /* fall through */
 666         case EM_GETPASSWORDCHAR:
 667                 DPRINTF_EDIT_MSG32("EM_GETPASSWORDCHAR");
 668                 result = es->password_char;
 669                 break;
 670
 671         /* The following EM_xxx are new to win95 and don't exist for 16 bit */
 672
 673         case EM_SETMARGINS:
 674                 DPRINTF_EDIT_MSG32("EM_SETMARGINS");
 675                 EDIT_EM_SetMargins(wnd, es, (INT)wParam, SLOWORD(lParam), SHIWORD(lParam));
 676                 break;
 677
 678         case EM_GETMARGINS:
 679                 DPRINTF_EDIT_MSG32("EM_GETMARGINS");
 680                 result = MAKELONG(es->left_margin, es->right_margin);
 681                 break;
 682
 683         case EM_GETLIMITTEXT:
 684                 DPRINTF_EDIT_MSG32("EM_GETLIMITTEXT");
 685                 result = es->buffer_limit;
 686                 break;
 687
 688         case EM_POSFROMCHAR:
 689                 DPRINTF_EDIT_MSG32("EM_POSFROMCHAR");
 690                 result = EDIT_EM_PosFromChar(wnd, es, (INT)wParam, FALSE);
 691                 break;
 692
 693         case EM_CHARFROMPOS:
 694                 DPRINTF_EDIT_MSG32("EM_CHARFROMPOS");
 695                 result = EDIT_EM_CharFromPos(wnd, es, SLOWORD(lParam), SHIWORD(lParam));
 696                 break;
 697
 698         case WM_GETDLGCODE:
 699                 DPRINTF_EDIT_MSG32("WM_GETDLGCODE");
 700                 result = (es->style & ES_MULTILINE) ?
 701                                 DLGC_WANTALLKEYS | DLGC_HASSETSEL | DLGC_WANTCHARS | DLGC_WANTARROWS :
 702                                 DLGC_HASSETSEL | DLGC_WANTCHARS | DLGC_WANTARROWS;
 703                 break;
 704
 705         case WM_CHAR:
 706                 DPRINTF_EDIT_MSG32("WM_CHAR");
 707                 EDIT_WM_Char(wnd, es, (CHAR)wParam, (DWORD)lParam);
 708                 break;
 709
 710         case WM_CLEAR:
 711                 DPRINTF_EDIT_MSG32("WM_CLEAR");
 712                 EDIT_WM_Clear(wnd, es);
 713                 break;
 714
 715         case WM_COMMAND:
 716                 DPRINTF_EDIT_MSG32("WM_COMMAND");
 717                 EDIT_WM_Command(wnd, es, HIWORD(wParam), LOWORD(wParam), (HWND)lParam);
 718                 break;
 719
 720         case WM_CONTEXTMENU:
 721                 DPRINTF_EDIT_MSG32("WM_CONTEXTMENU");
 722                 EDIT_WM_ContextMenu(wnd, es, (HWND)wParam, SLOWORD(lParam), SHIWORD(lParam));
 723                 break;
 724
 725         case WM_COPY:
 726                 DPRINTF_EDIT_MSG32("WM_COPY");
 727                 EDIT_WM_Copy(wnd, es);
 728                 break;
 729
 730         case WM_CREATE:
 731                 DPRINTF_EDIT_MSG32("WM_CREATE");
 732                 result = EDIT_WM_Create(wnd, es, (LPCREATESTRUCTA)lParam);
 733                 break;
 734
 735         case WM_CUT:
 736                 DPRINTF_EDIT_MSG32("WM_CUT");
 737                 EDIT_WM_Cut(wnd, es);
 738                 break;
 739
 740         case WM_ENABLE:
 741                 DPRINTF_EDIT_MSG32("WM_ENABLE");
 742                 InvalidateRect(hwnd, NULL, TRUE);
 743                 break;
 744
 745         case WM_ERASEBKGND:
 746                 DPRINTF_EDIT_MSG32("WM_ERASEBKGND");
 747                 result = EDIT_WM_EraseBkGnd(wnd, es, (HDC)wParam);
 748                 break;
 749
 750         case WM_GETFONT:
 751                 DPRINTF_EDIT_MSG32("WM_GETFONT");
 752                 result = (LRESULT)es->font;
 753                 break;
 754
 755         case WM_GETTEXT:
 756                 DPRINTF_EDIT_MSG32("WM_GETTEXT");
 757                 result = (LRESULT)EDIT_WM_GetText(wnd, es, (INT)wParam, (LPSTR)lParam);
 758                 break;
 759
 760         case WM_GETTEXTLENGTH:
 761                 DPRINTF_EDIT_MSG32("WM_GETTEXTLENGTH");
 762                 result = lstrlenA(es->text);
 763                 break;
 764
 765         case WM_HSCROLL:
 766                 DPRINTF_EDIT_MSG32("WM_HSCROLL");
 767                 result = EDIT_WM_HScroll(wnd, es, LOWORD(wParam), SHIWORD(wParam), (HWND)lParam);
 768                 break;
 769
 770         case WM_KEYDOWN:
 771                 DPRINTF_EDIT_MSG32("WM_KEYDOWN");
 772                 result = EDIT_WM_KeyDown(wnd, es, (INT)wParam, (DWORD)lParam);
 773                 break;
 774
 775         case WM_KILLFOCUS:
 776                 DPRINTF_EDIT_MSG32("WM_KILLFOCUS");
 777                 result = EDIT_WM_KillFocus(wnd, es, (HWND)wParam);
 778                 break;
 779
 780         case WM_LBUTTONDBLCLK:
 781                 DPRINTF_EDIT_MSG32("WM_LBUTTONDBLCLK");
 782                 result = EDIT_WM_LButtonDblClk(wnd, es, (DWORD)wParam, SLOWORD(lParam), SHIWORD(lParam));
 783                 break;
 784
 785         case WM_LBUTTONDOWN:
 786                 DPRINTF_EDIT_MSG32("WM_LBUTTONDOWN");
 787                 result = EDIT_WM_LButtonDown(wnd, es, (DWORD)wParam, SLOWORD(lParam), SHIWORD(lParam));
 788                 break;
 789
 790         case WM_LBUTTONUP:
 791                 DPRINTF_EDIT_MSG32("WM_LBUTTONUP");
 792                 result = EDIT_WM_LButtonUp(wnd, es, (DWORD)wParam, SLOWORD(lParam), SHIWORD(lParam));
 793                 break;
 794
 795         case WM_MOUSEACTIVATE:
 796                 /*
 797                  *      FIXME: maybe DefWindowProc() screws up, but it seems that
 798                  *              modalless dialog boxes need this.  If we don't do this, the focus
 799                  *              will _not_ be set by DefWindowProc() for edit controls in a
 800                  *              modalless dialog box ???
 801                  */
 802                 DPRINTF_EDIT_MSG32("WM_MOUSEACTIVATE");
 803                 SetFocus(wnd->hwndSelf);
 804                 result = MA_ACTIVATE;
 805                 break;
 806
 807         case WM_MOUSEMOVE:
 808                 /*
 809                  *      DPRINTF_EDIT_MSG32("WM_MOUSEMOVE");
 810                  */
 811                 result = EDIT_WM_MouseMove(wnd, es, (DWORD)wParam, SLOWORD(lParam), SHIWORD(lParam));
 812                 break;
 813
 814         case WM_PAINT:
 815                 DPRINTF_EDIT_MSG32("WM_PAINT");
 816                 EDIT_WM_Paint(wnd, es);
 817                 break;
 818
 819         case WM_PASTE:
 820                 DPRINTF_EDIT_MSG32("WM_PASTE");
 821                 EDIT_WM_Paste(wnd, es);
 822                 break;
 823
 824         case WM_SETFOCUS:
 825                 DPRINTF_EDIT_MSG32("WM_SETFOCUS");
 826                 EDIT_WM_SetFocus(wnd, es, (HWND)wParam);
 827                 break;
 828
 829         case WM_SETFONT:
 830                 DPRINTF_EDIT_MSG32("WM_SETFONT");
 831                 EDIT_WM_SetFont(wnd, es, (HFONT)wParam, LOWORD(lParam) != 0);
 832                 break;
 833
 834         case WM_SETTEXT:
 835                 DPRINTF_EDIT_MSG32("WM_SETTEXT");
 836                 EDIT_WM_SetText(wnd, es, (LPCSTR)lParam);
 837                 result = TRUE;
 838                 break;
 839
 840         case WM_SIZE:
 841                 DPRINTF_EDIT_MSG32("WM_SIZE");
 842                 EDIT_WM_Size(wnd, es, (UINT)wParam, LOWORD(lParam), HIWORD(lParam));
 843                 break;
 844
 845         case WM_SYSKEYDOWN:
 846                 DPRINTF_EDIT_MSG32("WM_SYSKEYDOWN");
 847                 result = EDIT_WM_SysKeyDown(wnd, es, (INT)wParam, (DWORD)lParam);
 848                 break;
 849
 850         case WM_TIMER:
 851                 DPRINTF_EDIT_MSG32("WM_TIMER");
 852                 EDIT_WM_Timer(wnd, es, (INT)wParam, (TIMERPROC)lParam);
 853                 break;
 854
 855         case WM_VSCROLL:
 856                 DPRINTF_EDIT_MSG32("WM_VSCROLL");
 857                 result = EDIT_WM_VScroll(wnd, es, LOWORD(wParam), SHIWORD(wParam), (HWND)(lParam));
 858                 break;
 859
 860         default:
 861                 result = DefWindowProcA(hwnd, msg, wParam, lParam);
 862                 break;
 863         }
 864         EDIT_UnlockBuffer(wnd, es, FALSE);
 865     END:
 866         WIN_ReleaseWndPtr(wnd);
 867         return result;
 868
 869 }
 870
 871
 872 /*********************************************************************
 873  *
 874  *      EDIT_BuildLineDefs_ML
 875  *
 876  *      Build linked list of text lines.
 877  *      Lines can end with '\0' (last line), a character (if it is wrapped),
 878  *      a soft return '\r\r\n' or a hard return '\r\n'
 879  *
 880  */
 881 static void EDIT_BuildLineDefs_ML(WND *wnd, EDITSTATE *es)
 882 {
 883         HDC dc;
 884         HFONT old_font = 0;
 885         LPSTR start, cp;
 886         INT fw;
 887         LINEDEF *current_def;
 888         LINEDEF **previous_next;
 889
 890         current_def = es->first_line_def;
 891         do {
 892                 LINEDEF *next_def = current_def->next;
 893                 HeapFree(es->heap, 0, current_def);
 894                 current_def = next_def;
 895         } while (current_def);
 896         es->line_count = 0;
 897         es->text_width = 0;
 898
 899         dc = GetDC(wnd->hwndSelf);
 900         if (es->font)
 901                 old_font = SelectObject(dc, es->font);
 902
 903         fw = es->format_rect.right - es->format_rect.left;
 904         start = es->text;
 905         previous_next = &es->first_line_def;
 906         do {
 907                 current_def = HeapAlloc(es->heap, 0, sizeof(LINEDEF));
 908                 current_def->next = NULL;
 909                 cp = start;
 910                 while (*cp) {
 911                         if ((*cp == '\r') && (*(cp + 1) == '\n'))
 912                                 break;
 913                         cp++;
 914                 }
 915                 if (!(*cp)) {
 916                         current_def->ending = END_0;
 917                         current_def->net_length = lstrlenA(start);
 918                 } else if ((cp > start) && (*(cp - 1) == '\r')) {
 919                         current_def->ending = END_SOFT;
 920                         current_def->net_length = cp - start - 1;
 921                 } else {
 922                         current_def->ending = END_HARD;
 923                         current_def->net_length = cp - start;
 924                 }
 925                 current_def->width = (INT)LOWORD(GetTabbedTextExtentA(dc,
 926                                         start, current_def->net_length,
 927                                         es->tabs_count, es->tabs));
 928                 /* FIXME: check here for lines that are too wide even in AUTOHSCROLL (> 32767 ???) */
 929                 if ((!(es->style & ES_AUTOHSCROLL)) && (current_def->width > fw)) {
 930                         INT next = 0;
 931                         INT prev;
 932                         do {
 933                                 prev = next;
 934                                 next = EDIT_CallWordBreakProc(wnd, es, start - es->text,
 935                                                 prev + 1, current_def->net_length, WB_RIGHT);
 936                                 current_def->width = (INT)LOWORD(GetTabbedTextExtentA(dc,
 937                                                         start, next, es->tabs_count, es->tabs));
 938                         } while (current_def->width <= fw);
 939                         if (!prev) {
 940                                 next = 0;
 941                                 do {
 942                                         prev = next;
 943                                         next++;
 944                                         current_def->width = (INT)LOWORD(GetTabbedTextExtentA(dc,
 945                                                                 start, next, es->tabs_count, es->tabs));
 946                                 } while (current_def->width <= fw);
 947                                 if (!prev)
 948                                         prev = 1;
 949                         }
 950                         current_def->net_length = prev;
 951                         current_def->ending = END_WRAP;
 952                         current_def->width = (INT)LOWORD(GetTabbedTextExtentA(dc, start,
 953                                                 current_def->net_length, es->tabs_count, es->tabs));
 954                 }
 955                 switch (current_def->ending) {
 956                 case END_SOFT:
 957                         current_def->length = current_def->net_length + 3;
 958                         break;
 959                 case END_HARD:
 960                         current_def->length = current_def->net_length + 2;
 961                         break;
 962                 case END_WRAP:
 963                 case END_0:
 964                         current_def->length = current_def->net_length;
 965                         break;
 966                 }
 967                 es->text_width = MAX(es->text_width, current_def->width);
 968                 start += current_def->length;
 969                 *previous_next = current_def;
 970                 previous_next = &current_def->next;
 971                 es->line_count++;
 972         } while (current_def->ending != END_0);
 973         if (es->font)
 974                 SelectObject(dc, old_font);
 975         ReleaseDC(wnd->hwndSelf, dc);
 976 }
 977
 978
 979 /*********************************************************************
 980  *
 981  *      EDIT_CallWordBreakProc
 982  *
 983  *      Call appropriate WordBreakProc (internal or external).
 984  *
 985  *      Note: The "start" argument should always be an index refering
 986  *              to es->text.  The actual wordbreak proc might be
 987  *              16 bit, so we can't always pass any 32 bit LPSTR.
 988  *              Hence we assume that es->text is the buffer that holds
 989  *              the string under examination (we can decide this for ourselves).
 990  *
 991  */
 992 static INT EDIT_CallWordBreakProc(WND *wnd, EDITSTATE *es, INT start, INT index, INT count, INT action)
 993 {
 994         if (es->word_break_proc16) {
 995                 HLOCAL16 hloc16 = EDIT_EM_GetHandle16(wnd, es);
 996                 SEGPTR segptr = LocalLock16(hloc16);
 997                 INT ret = (INT)Callbacks->CallWordBreakProc(es->word_break_proc16,
 998                                                 segptr + start, index, count, action);
 999                 LocalUnlock16(hloc16);
1000                 return ret;
1001         }
1002         else if (es->word_break_proc32A)
1003         {
1004             TRACE(relay, "(wordbrk=%p,str='%s',idx=%d,cnt=%d,act=%d)\n",
1005                            es->word_break_proc32A, es->text + start, index,
1006                            count, action );
1007             return (INT)es->word_break_proc32A( es->text + start, index,
1008                                                   count, action );
1009         }
1010         else
1011             return EDIT_WordBreakProc(es->text + start, index, count, action);
1012 }
1013
1014
1015 /*********************************************************************
1016  *
1017  *      EDIT_CharFromPos
1018  *
1019  *      Beware: This is not the function called on EM_CHARFROMPOS
1020  *              The position _can_ be outside the formatting / client
1021  *              rectangle
1022  *              The return value is only the character index
1023  *
1024  */
1025 static INT EDIT_CharFromPos(WND *wnd, EDITSTATE *es, INT x, INT y, LPBOOL after_wrap)
1026 {
1027         INT index;
1028         HDC dc;
1029         HFONT old_font = 0;
1030
1031         if (es->style & ES_MULTILINE) {
1032                 INT line = (y - es->format_rect.top) / es->line_height + es->y_offset;
1033                 INT line_index = 0;
1034                 LINEDEF *line_def = es->first_line_def;
1035                 INT low, high;
1036                 while ((line > 0) && line_def->next) {
1037                         line_index += line_def->length;
1038                         line_def = line_def->next;
1039                         line--;
1040                 }
1041                 x += es->x_offset - es->format_rect.left;
1042                 if (x >= line_def->width) {
1043                         if (after_wrap)
1044                                 *after_wrap = (line_def->ending == END_WRAP);
1045                         return line_index + line_def->net_length;
1046                 }
1047                 if (x <= 0) {
1048                         if (after_wrap)
1049                                 *after_wrap = FALSE;
1050                         return line_index;
1051                 }
1052                 dc = GetDC(wnd->hwndSelf);
1053                 if (es->font)
1054                         old_font = SelectObject(dc, es->font);
1055                     low = line_index + 1;
1056                     high = line_index + line_def->net_length + 1;
1057                     while (low < high - 1)
1058                     {
1059                         INT mid = (low + high) / 2;
1060                         if (LOWORD(GetTabbedTextExtentA(dc, es->text + line_index,mid - line_index, es->tabs_count, es->tabs)) > x) high = mid;
1061                         else low = mid;
1062                     }
1063                     index = low;
1064
1065                 if (after_wrap)
1066                         *after_wrap = ((index == line_index + line_def->net_length) &&
1067                                                         (line_def->ending == END_WRAP));
1068         } else {
1069                 LPSTR text;
1070                 SIZE size;
1071                 if (after_wrap)
1072                         *after_wrap = FALSE;
1073                 x -= es->format_rect.left;
1074                 if (!x)
1075                         return es->x_offset;
1076                 text = EDIT_GetPasswordPointer_SL(wnd, es);
1077                 dc = GetDC(wnd->hwndSelf);
1078                 if (es->font)
1079                         old_font = SelectObject(dc, es->font);
1080                 if (x < 0)
1081                 {
1082                     INT low = 0;
1083                     INT high = es->x_offset;
1084                     while (low < high - 1)
1085                     {
1086                         INT mid = (low + high) / 2;
1087                         GetTextExtentPoint32A( dc, text + mid,
1088                                                es->x_offset - mid, &size );
1089                         if (size.cx > -x) low = mid;
1090                         else high = mid;
1091                     }
1092                     index = low;
1093                 }
1094                 else
1095                 {
1096                     INT low = es->x_offset;
1097                     INT high = lstrlenA(es->text) + 1;
1098                     while (low < high - 1)
1099                     {
1100                         INT mid = (low + high) / 2;
1101                         GetTextExtentPoint32A( dc, text + es->x_offset,
1102                                                mid - es->x_offset, &size );
1103                         if (size.cx > x) high = mid;
1104                         else low = mid;
1105                     }
1106                     index = low;
1107                 }
1108                 if (es->style & ES_PASSWORD)
1109                         HeapFree(es->heap, 0 ,text);
1110         }
1111         if (es->font)
1112                 SelectObject(dc, old_font);
1113         ReleaseDC(wnd->hwndSelf, dc);
1114         return index;
1115 }
1116
1117
1118 /*********************************************************************
1119  *
1120  *      EDIT_ConfinePoint
1121  *
1122  *      adjusts the point to be within the formatting rectangle
1123  *      (so CharFromPos returns the nearest _visible_ character)
1124  *
1125  */
1126 static void EDIT_ConfinePoint(WND *wnd, EDITSTATE *es, LPINT x, LPINT y)
1127 {
1128         *x = MIN(MAX(*x, es->format_rect.left), es->format_rect.right - 1);
1129         *y = MIN(MAX(*y, es->format_rect.top), es->format_rect.bottom - 1);
1130 }
1131
1132
1133 /*********************************************************************
1134  *
1135  *      EDIT_GetLineRect
1136  *
1137  *      Calculates the bounding rectangle for a line from a starting
1138  *      column to an ending column.
1139  *
1140  */
1141 static void EDIT_GetLineRect(WND *wnd, EDITSTATE *es, INT line, INT scol, INT ecol, LPRECT rc)
1142 {
1143         INT line_index =  EDIT_EM_LineIndex(wnd, es, line);
1144
1145         if (es->style & ES_MULTILINE)
1146                 rc->top = es->format_rect.top + (line - es->y_offset) * es->line_height;
1147         else
1148                 rc->top = es->format_rect.top;
1149         rc->bottom = rc->top + es->line_height;
1150         rc->left = (scol == 0) ? es->format_rect.left : SLOWORD(EDIT_EM_PosFromChar(wnd, es, line_index + scol, TRUE));
1151         rc->right = (ecol == -1) ? es->format_rect.right : SLOWORD(EDIT_EM_PosFromChar(wnd, es, line_index + ecol, TRUE));
1152 }
1153
1154
1155 /*********************************************************************
1156  *
1157  *      EDIT_GetPasswordPointer_SL
1158  *
1159  *      note: caller should free the (optionally) allocated buffer
1160  *
1161  */
1162 static LPSTR EDIT_GetPasswordPointer_SL(WND *wnd, EDITSTATE *es)
1163 {
1164         if (es->style & ES_PASSWORD) {
1165                 INT len = lstrlenA(es->text);
1166                 LPSTR text = HeapAlloc(es->heap, 0, len + 1);
1167                 RtlFillMemory(text, len, es->password_char);
1168                 text[len] = '\0';
1169                 return text;
1170         } else
1171                 return es->text;
1172 }
1173
1174
1175 /*********************************************************************
1176  *
1177  *      EDIT_LockBuffer
1178  *
1179  *      This acts as a LOCAL_Lock(), but it locks only once.  This way
1180  *      you can call it whenever you like, without unlocking.
1181  *
1182  */
1183 static void EDIT_LockBuffer(WND *wnd, EDITSTATE *es)
1184 {
1185         if (!es) {
1186                 ERR(edit, "no EDITSTATE ... please report\n");
1187                 return;
1188         }
1189         if (!(es->style & ES_MULTILINE))
1190                 return;
1191         if (!es->text) {
1192                 if (es->hloc32)
1193                         es->text = LocalLock(es->hloc32);
1194                 else if (es->hloc16)
1195                         es->text = LOCAL_Lock(wnd->hInstance, es->hloc16);
1196                 else {
1197                         ERR(edit, "no buffer ... please report\n");
1198                         return;
1199                 }
1200         }
1201         es->lock_count++;
1202 }
1203
1204
1205 /*********************************************************************
1206  *
1207  *      EDIT_SL_InvalidateText
1208  *
1209  *      Called from EDIT_InvalidateText().
1210  *      Does the job for single-line controls only.
1211  *
1212  */
1213 static void EDIT_SL_InvalidateText(WND *wnd, EDITSTATE *es, INT start, INT end)
1214 {
1215         RECT line_rect;
1216         RECT rc;
1217
1218         EDIT_GetLineRect(wnd, es, 0, start, end, &line_rect);
1219         if (IntersectRect(&rc, &line_rect, &es->format_rect))
1220                 InvalidateRect(wnd->hwndSelf, &rc, FALSE);
1221 }
1222
1223
1224 /*********************************************************************
1225  *
1226  *      EDIT_ML_InvalidateText
1227  *
1228  *      Called from EDIT_InvalidateText().
1229  *      Does the job for multi-line controls only.
1230  *
1231  */
1232 static void EDIT_ML_InvalidateText(WND *wnd, EDITSTATE *es, INT start, INT end)
1233 {
1234         INT vlc = (es->format_rect.bottom - es->format_rect.top) / es->line_height;
1235         INT sl = EDIT_EM_LineFromChar(wnd, es, start);
1236         INT el = EDIT_EM_LineFromChar(wnd, es, end);
1237         INT sc;
1238         INT ec;
1239         RECT rc1;
1240         RECT rcWnd;
1241         RECT rcLine;
1242         RECT rcUpdate;
1243         INT l;
1244
1245         if ((el < es->y_offset) || (sl > es->y_offset + vlc))
1246                 return;
1247
1248         sc = start - EDIT_EM_LineIndex(wnd, es, sl);
1249         ec = end - EDIT_EM_LineIndex(wnd, es, el);
1250         if (sl < es->y_offset) {
1251                 sl = es->y_offset;
1252                 sc = 0;
1253         }
1254         if (el > es->y_offset + vlc) {
1255                 el = es->y_offset + vlc;
1256                 ec = EDIT_EM_LineLength(wnd, es, EDIT_EM_LineIndex(wnd, es, el));
1257         }
1258         GetClientRect(wnd->hwndSelf, &rc1);
1259         IntersectRect(&rcWnd, &rc1, &es->format_rect);
1260         if (sl == el) {
1261                 EDIT_GetLineRect(wnd, es, sl, sc, ec, &rcLine);
1262                 if (IntersectRect(&rcUpdate, &rcWnd, &rcLine))
1263                         InvalidateRect(wnd->hwndSelf, &rcUpdate, FALSE);
1264         } else {
1265                 EDIT_GetLineRect(wnd, es, sl, sc,
1266                                 EDIT_EM_LineLength(wnd, es,
1267                                         EDIT_EM_LineIndex(wnd, es, sl)),
1268                                 &rcLine);
1269                 if (IntersectRect(&rcUpdate, &rcWnd, &rcLine))
1270                         InvalidateRect(wnd->hwndSelf, &rcUpdate, FALSE);
1271                 for (l = sl + 1 ; l < el ; l++) {
1272                         EDIT_GetLineRect(wnd, es, l, 0,
1273                                 EDIT_EM_LineLength(wnd, es,
1274                                         EDIT_EM_LineIndex(wnd, es, l)),
1275                                 &rcLine);
1276                         if (IntersectRect(&rcUpdate, &rcWnd, &rcLine))
1277                                 InvalidateRect(wnd->hwndSelf, &rcUpdate, FALSE);
1278                 }
1279                 EDIT_GetLineRect(wnd, es, el, 0, ec, &rcLine);
1280                 if (IntersectRect(&rcUpdate, &rcWnd, &rcLine))
1281                         InvalidateRect(wnd->hwndSelf, &rcUpdate, FALSE);
1282         }
1283 }
1284
1285
1286 /*********************************************************************
1287  *
1288  *      EDIT_InvalidateText
1289  *
1290  *      Invalidate the text from offset start upto, but not including,
1291  *      offset end.  Useful for (re)painting the selection.
1292  *      Regions outside the linewidth are not invalidated.
1293  *      end == -1 means end == TextLength.
1294  *      start and end need not be ordered.
1295  *
1296  */
1297 static void EDIT_InvalidateText(WND *wnd, EDITSTATE *es, INT start, INT end)
1298 {
1299         if (end == start)
1300                 return;
1301
1302         if (end == -1)
1303                 end = lstrlenA(es->text);
1304
1305         ORDER_INT(start, end);
1306
1307         if (es->style & ES_MULTILINE)
1308                 EDIT_ML_InvalidateText(wnd, es, start, end);
1309         else
1310                 EDIT_SL_InvalidateText(wnd, es, start, end);
1311 }
1312
1313
1314 /*********************************************************************
1315  *
1316  *      EDIT_MakeFit
1317  *
1318  *      Try to fit size + 1 bytes in the buffer.  Constrain to limits.
1319  *
1320  */
1321 static BOOL EDIT_MakeFit(WND *wnd, EDITSTATE *es, INT size)
1322 {
1323         HLOCAL hNew32;
1324         HLOCAL16 hNew16;
1325
1326         if (size <= es->buffer_size)
1327                 return TRUE;
1328         if (size > es->buffer_limit) {
1329                 EDIT_NOTIFY_PARENT(wnd, EN_MAXTEXT, "EN_MAXTEXT");
1330                 return FALSE;
1331         }
1332         size = ((size / GROWLENGTH) + 1) * GROWLENGTH;
1333         if (size > es->buffer_limit)
1334                 size = es->buffer_limit;
1335
1336         TRACE(edit, "trying to ReAlloc to %d+1\n", size);
1337
1338         EDIT_UnlockBuffer(wnd, es, TRUE);
1339         if (es->text) {
1340                 if ((es->text = HeapReAlloc(es->heap, 0, es->text, size + 1)))
1341                         es->buffer_size = MIN(HeapSize(es->heap, 0, es->text) - 1, es->buffer_limit);
1342                 else
1343                         es->buffer_size = 0;
1344         } else if (es->hloc32) {
1345                 if ((hNew32 = LocalReAlloc(es->hloc32, size + 1, 0))) {
1346                         TRACE(edit, "Old 32 bit handle %08x, new handle %08x\n", es->hloc32, hNew32);
1347                         es->hloc32 = hNew32;
1348                         es->buffer_size = MIN(LocalSize(es->hloc32) - 1, es->buffer_limit);
1349                 }
1350         } else if (es->hloc16) {
1351                 if ((hNew16 = LOCAL_ReAlloc(wnd->hInstance, es->hloc16, size + 1, LMEM_MOVEABLE))) {
1352                         TRACE(edit, "Old 16 bit handle %08x, new handle %08x\n", es->hloc16, hNew16);
1353                         es->hloc16 = hNew16;
1354                         es->buffer_size = MIN(LOCAL_Size(wnd->hInstance, es->hloc16) - 1, es->buffer_limit);
1355                 }
1356         }
1357         if (es->buffer_size < size) {
1358                 EDIT_LockBuffer(wnd, es);
1359                 WARN(edit, "FAILED !  We now have %d+1\n", es->buffer_size);
1360                 EDIT_NOTIFY_PARENT(wnd, EN_ERRSPACE, "EN_ERRSPACE");
1361                 return FALSE;
1362         } else {
1363                 EDIT_LockBuffer(wnd, es);
1364                 TRACE(edit, "We now have %d+1\n", es->buffer_size);
1365                 return TRUE;
1366         }
1367 }
1368
1369
1370 /*********************************************************************
1371  *
1372  *      EDIT_MakeUndoFit
1373  *
1374  *      Try to fit size + 1 bytes in the undo buffer.
1375  *
1376  */
1377 static BOOL EDIT_MakeUndoFit(WND *wnd, EDITSTATE *es, INT size)
1378 {
1379         if (size <= es->undo_buffer_size)
1380                 return TRUE;
1381         size = ((size / GROWLENGTH) + 1) * GROWLENGTH;
1382
1383         TRACE(edit, "trying to ReAlloc to %d+1\n", size);
1384
1385         if ((es->undo_text = HeapReAlloc(es->heap, 0, es->undo_text, size + 1))) {
1386                 es->undo_buffer_size = HeapSize(es->heap, 0, es->undo_text) - 1;
1387                 if (es->undo_buffer_size < size) {
1388                         WARN(edit, "FAILED !  We now have %d+1\n", es->undo_buffer_size);
1389                         return FALSE;
1390                 }
1391                 return TRUE;
1392         }
1393         return FALSE;
1394 }
1395
1396
1397 /*********************************************************************
1398  *
1399  *      EDIT_MoveBackward
1400  *
1401  */
1402 static void EDIT_MoveBackward(WND *wnd, EDITSTATE *es, BOOL extend)
1403 {
1404         INT e = es->selection_end;
1405
1406         if (e) {
1407                 e--;
1408                 if ((es->style & ES_MULTILINE) && e &&
1409                                 (es->text[e - 1] == '\r') && (es->text[e] == '\n')) {
1410                         e--;
1411                         if (e && (es->text[e - 1] == '\r'))
1412                                 e--;
1413                 }
1414         }
1415         EDIT_EM_SetSel(wnd, es, extend ? es->selection_start : e, e, FALSE);
1416         EDIT_EM_ScrollCaret(wnd, es);
1417 }
1418
1419
1420 /*********************************************************************
1421  *
1422  *      EDIT_MoveDown_ML
1423  *
1424  *      Only for multi line controls
1425  *      Move the caret one line down, on a column with the nearest
1426  *      x coordinate on the screen (might be a different column).
1427  *
1428  */
1429 static void EDIT_MoveDown_ML(WND *wnd, EDITSTATE *es, BOOL extend)
1430 {
1431         INT s = es->selection_start;
1432         INT e = es->selection_end;
1433         BOOL after_wrap = (es->flags & EF_AFTER_WRAP);
1434         LRESULT pos = EDIT_EM_PosFromChar(wnd, es, e, after_wrap);
1435         INT x = SLOWORD(pos);
1436         INT y = SHIWORD(pos);
1437
1438         e = EDIT_CharFromPos(wnd, es, x, y + es->line_height, &after_wrap);
1439         if (!extend)
1440                 s = e;
1441         EDIT_EM_SetSel(wnd, es, s, e, after_wrap);
1442         EDIT_EM_ScrollCaret(wnd, es);
1443 }
1444
1445
1446 /*********************************************************************
1447  *
1448  *      EDIT_MoveEnd
1449  *
1450  */
1451 static void EDIT_MoveEnd(WND *wnd, EDITSTATE *es, BOOL extend)
1452 {
1453         BOOL after_wrap = FALSE;
1454         INT e;
1455
1456         if (es->style & ES_MULTILINE)
1457                 e = EDIT_CharFromPos(wnd, es, 0x7fffffff,
1458                         HIWORD(EDIT_EM_PosFromChar(wnd, es, es->selection_end, es->flags & EF_AFTER_WRAP)), &after_wrap);
1459         else
1460                 e = lstrlenA(es->text);
1461         EDIT_EM_SetSel(wnd, es, extend ? es->selection_start : e, e, after_wrap);
1462         EDIT_EM_ScrollCaret(wnd, es);
1463 }
1464
1465
1466 /*********************************************************************
1467  *
1468  *      EDIT_MoveForward
1469  *
1470  */
1471 static void EDIT_MoveForward(WND *wnd, EDITSTATE *es, BOOL extend)
1472 {
1473         INT e = es->selection_end;
1474
1475         if (es->text[e]) {
1476                 e++;
1477                 if ((es->style & ES_MULTILINE) && (es->text[e - 1] == '\r')) {
1478                         if (es->text[e] == '\n')
1479                                 e++;
1480                         else if ((es->text[e] == '\r') && (es->text[e + 1] == '\n'))
1481                                 e += 2;
1482                 }
1483         }
1484         EDIT_EM_SetSel(wnd, es, extend ? es->selection_start : e, e, FALSE);
1485         EDIT_EM_ScrollCaret(wnd, es);
1486 }
1487
1488
1489 /*********************************************************************
1490  *
1491  *      EDIT_MoveHome
1492  *
1493  *      Home key: move to beginning of line.
1494  *
1495  */
1496 static void EDIT_MoveHome(WND *wnd, EDITSTATE *es, BOOL extend)
1497 {
1498         INT e;
1499
1500         if (es->style & ES_MULTILINE)
1501                 e = EDIT_CharFromPos(wnd, es, 0x80000000,
1502                         HIWORD(EDIT_EM_PosFromChar(wnd, es, es->selection_end, es->flags & EF_AFTER_WRAP)), NULL);
1503         else
1504                 e = 0;
1505         EDIT_EM_SetSel(wnd, es, e, extend ? es->selection_start : e, FALSE);
1506         EDIT_EM_ScrollCaret(wnd, es);
1507 }
1508
1509
1510 /*********************************************************************
1511  *
1512  *      EDIT_MovePageDown_ML
1513  *
1514  *      Only for multi line controls
1515  *      Move the caret one page down, on a column with the nearest
1516  *      x coordinate on the screen (might be a different column).
1517  *
1518  */
1519 static void EDIT_MovePageDown_ML(WND *wnd, EDITSTATE *es, BOOL extend)
1520 {
1521         INT s = es->selection_start;
1522         INT e = es->selection_end;
1523         BOOL after_wrap = (es->flags & EF_AFTER_WRAP);
1524         LRESULT pos = EDIT_EM_PosFromChar(wnd, es, e, after_wrap);
1525         INT x = SLOWORD(pos);
1526         INT y = SHIWORD(pos);
1527
1528         e = EDIT_CharFromPos(wnd, es, x,
1529                 y + (es->format_rect.bottom - es->format_rect.top),
1530                 &after_wrap);
1531         if (!extend)
1532                 s = e;
1533         EDIT_EM_SetSel(wnd, es, s, e, after_wrap);
1534         EDIT_EM_ScrollCaret(wnd, es);
1535 }
1536
1537
1538 /*********************************************************************
1539  *
1540  *      EDIT_MovePageUp_ML
1541  *
1542  *      Only for multi line controls
1543  *      Move the caret one page up, on a column with the nearest
1544  *      x coordinate on the screen (might be a different column).
1545  *
1546  */
1547 static void EDIT_MovePageUp_ML(WND *wnd, EDITSTATE *es, BOOL extend)
1548 {
1549         INT s = es->selection_start;
1550         INT e = es->selection_end;
1551         BOOL after_wrap = (es->flags & EF_AFTER_WRAP);
1552         LRESULT pos = EDIT_EM_PosFromChar(wnd, es, e, after_wrap);
1553         INT x = SLOWORD(pos);
1554         INT y = SHIWORD(pos);
1555
1556         e = EDIT_CharFromPos(wnd, es, x,
1557                 y - (es->format_rect.bottom - es->format_rect.top),
1558                 &after_wrap);
1559         if (!extend)
1560                 s = e;
1561         EDIT_EM_SetSel(wnd, es, s, e, after_wrap);
1562         EDIT_EM_ScrollCaret(wnd, es);
1563 }
1564
1565
1566 /*********************************************************************
1567  *
1568  *      EDIT_MoveUp_ML
1569  *
1570  *      Only for multi line controls
1571  *      Move the caret one line up, on a column with the nearest
1572  *      x coordinate on the screen (might be a different column).
1573  *
1574  */
1575 static void EDIT_MoveUp_ML(WND *wnd, EDITSTATE *es, BOOL extend)
1576 {
1577         INT s = es->selection_start;
1578         INT e = es->selection_end;
1579         BOOL after_wrap = (es->flags & EF_AFTER_WRAP);
1580         LRESULT pos = EDIT_EM_PosFromChar(wnd, es, e, after_wrap);
1581         INT x = SLOWORD(pos);
1582         INT y = SHIWORD(pos);
1583
1584         e = EDIT_CharFromPos(wnd, es, x, y - es->line_height, &after_wrap);
1585         if (!extend)
1586                 s = e;
1587         EDIT_EM_SetSel(wnd, es, s, e, after_wrap);
1588         EDIT_EM_ScrollCaret(wnd, es);
1589 }
1590
1591
1592 /*********************************************************************
1593  *
1594  *      EDIT_MoveWordBackward
1595  *
1596  */
1597 static void EDIT_MoveWordBackward(WND *wnd, EDITSTATE *es, BOOL extend)
1598 {
1599         INT s = es->selection_start;
1600         INT e = es->selection_end;
1601         INT l;
1602         INT ll;
1603         INT li;
1604
1605         l = EDIT_EM_LineFromChar(wnd, es, e);
1606         ll = EDIT_EM_LineLength(wnd, es, e);
1607         li = EDIT_EM_LineIndex(wnd, es, l);
1608         if (e - li == 0) {
1609                 if (l) {
1610                         li = EDIT_EM_LineIndex(wnd, es, l - 1);
1611                         e = li + EDIT_EM_LineLength(wnd, es, li);
1612                 }
1613         } else {
1614                 e = li + (INT)EDIT_CallWordBreakProc(wnd, es,
1615                                 li, e - li, ll, WB_LEFT);
1616         }
1617         if (!extend)
1618                 s = e;
1619         EDIT_EM_SetSel(wnd, es, s, e, FALSE);
1620         EDIT_EM_ScrollCaret(wnd, es);
1621 }
1622
1623
1624 /*********************************************************************
1625  *
1626  *      EDIT_MoveWordForward
1627  *
1628  */
1629 static void EDIT_MoveWordForward(WND *wnd, EDITSTATE *es, BOOL extend)
1630 {
1631         INT s = es->selection_start;
1632         INT e = es->selection_end;
1633         INT l;
1634         INT ll;
1635         INT li;
1636
1637         l = EDIT_EM_LineFromChar(wnd, es, e);
1638         ll = EDIT_EM_LineLength(wnd, es, e);
1639         li = EDIT_EM_LineIndex(wnd, es, l);
1640         if (e - li == ll) {
1641                 if ((es->style & ES_MULTILINE) && (l != es->line_count - 1))
1642                         e = EDIT_EM_LineIndex(wnd, es, l + 1);
1643         } else {
1644                 e = li + EDIT_CallWordBreakProc(wnd, es,
1645                                 li, e - li + 1, ll, WB_RIGHT);
1646         }
1647         if (!extend)
1648                 s = e;
1649         EDIT_EM_SetSel(wnd, es, s, e, FALSE);
1650         EDIT_EM_ScrollCaret(wnd, es);
1651 }
1652
1653
1654 /*********************************************************************
1655  *
1656  *      EDIT_PaintLine
1657  *
1658  */
1659 static void EDIT_PaintLine(WND *wnd, EDITSTATE *es, HDC dc, INT line, BOOL rev)
1660 {
1661         INT s = es->selection_start;
1662         INT e = es->selection_end;
1663         INT li;
1664         INT ll;
1665         INT x;
1666         INT y;
1667         LRESULT pos;
1668
1669         if (es->style & ES_MULTILINE) {
1670                 INT vlc = (es->format_rect.bottom - es->format_rect.top) / es->line_height;
1671                 if ((line < es->y_offset) || (line > es->y_offset + vlc) || (line >= es->line_count))
1672                         return;
1673         } else if (line)
1674                 return;
1675
1676         TRACE(edit, "line=%d\n", line);
1677
1678         pos = EDIT_EM_PosFromChar(wnd, es, EDIT_EM_LineIndex(wnd, es, line), FALSE);
1679         x = SLOWORD(pos);
1680         y = SHIWORD(pos);
1681         li = EDIT_EM_LineIndex(wnd, es, line);
1682         ll = EDIT_EM_LineLength(wnd, es, li);
1683         s = es->selection_start;
1684         e = es->selection_end;
1685         ORDER_INT(s, e);
1686         s = MIN(li + ll, MAX(li, s));
1687         e = MIN(li + ll, MAX(li, e));
1688         if (rev && (s != e) &&
1689                         ((es->flags & EF_FOCUSED) || (es->style & ES_NOHIDESEL))) {
1690                 x += EDIT_PaintText(wnd, es, dc, x, y, line, 0, s - li, FALSE);
1691                 x += EDIT_PaintText(wnd, es, dc, x, y, line, s - li, e - s, TRUE);
1692                 x += EDIT_PaintText(wnd, es, dc, x, y, line, e - li, li + ll - e, FALSE);
1693         } else
1694                 x += EDIT_PaintText(wnd, es, dc, x, y, line, 0, ll, FALSE);
1695 }
1696
1697
1698 /*********************************************************************
1699  *
1700  *      EDIT_PaintText
1701  *
1702  */
1703 static INT EDIT_PaintText(WND *wnd, EDITSTATE *es, HDC dc, INT x, INT y, INT line, INT col, INT count, BOOL rev)
1704 {
1705         COLORREF BkColor;
1706         COLORREF TextColor;
1707         INT ret;
1708         INT li;
1709         SIZE size;
1710
1711         if (!count)
1712                 return 0;
1713         BkColor = GetBkColor(dc);
1714         TextColor = GetTextColor(dc);
1715         if (rev) {
1716                 SetBkColor(dc, GetSysColor(COLOR_HIGHLIGHT));
1717                 SetTextColor(dc, GetSysColor(COLOR_HIGHLIGHTTEXT));
1718         }
1719         li = EDIT_EM_LineIndex(wnd, es, line);
1720         if (es->style & ES_MULTILINE) {
1721                 ret = (INT)LOWORD(TabbedTextOutA(dc, x, y, es->text + li + col, count,
1722                                         es->tabs_count, es->tabs, es->format_rect.left - es->x_offset));
1723         } else {
1724                 LPSTR text = EDIT_GetPasswordPointer_SL(wnd, es);
1725                 TextOutA(dc, x, y, text + li + col, count);
1726                 GetTextExtentPoint32A(dc, text + li + col, count, &size);
1727                 ret = size.cx;
1728                 if (es->style & ES_PASSWORD)
1729                         HeapFree(es->heap, 0, text);
1730         }
1731         if (rev) {
1732                 SetBkColor(dc, BkColor);
1733                 SetTextColor(dc, TextColor);
1734         }
1735         return ret;
1736 }
1737
1738
1739 /*********************************************************************
1740  *
1741  *      EDIT_SetCaretPos
1742  *
1743  */
1744 static void EDIT_SetCaretPos(WND *wnd, EDITSTATE *es, INT pos,
1745                              BOOL after_wrap)
1746 {
1747         LRESULT res = EDIT_EM_PosFromChar(wnd, es, pos, after_wrap);
1748         INT x = SLOWORD(res);
1749         INT y = SHIWORD(res);
1750
1751         if(x < es->format_rect.left)
1752                 x = es->format_rect.left;
1753         if(x > es->format_rect.right - 2)
1754                 x = es->format_rect.right - 2;
1755         if(y > es->format_rect.bottom)
1756                 y = es->format_rect.bottom;
1757         if(y < es->format_rect.top)
1758                 y = es->format_rect.top;
1759         SetCaretPos(x, y);
1760         return;
1761 }
1762
1763
1764 /*********************************************************************
1765  *
1766  *      EDIT_SetRectNP
1767  *
1768  *      note:   this is not (exactly) the handler called on EM_SETRECTNP
1769  *              it is also used to set the rect of a single line control
1770  *
1771  */
1772 static void EDIT_SetRectNP(WND *wnd, EDITSTATE *es, LPRECT rc)
1773 {
1774         CopyRect(&es->format_rect, rc);
1775         if (es->style & WS_BORDER) {
1776                 INT bw = GetSystemMetrics(SM_CXBORDER) + 1;
1777                 if(TWEAK_WineLook == WIN31_LOOK)
1778                         bw += 2;
1779                 es->format_rect.left += bw;
1780                 es->format_rect.top += bw;
1781                 es->format_rect.right -= bw;
1782                 es->format_rect.bottom -= bw;
1783         }
1784         es->format_rect.left += es->left_margin;
1785         es->format_rect.right -= es->right_margin;
1786         es->format_rect.right = MAX(es->format_rect.right, es->format_rect.left + es->char_width);
1787         if (es->style & ES_MULTILINE)
1788                 es->format_rect.bottom = es->format_rect.top +
1789                         MAX(1, (es->format_rect.bottom - es->format_rect.top) / es->line_height) * es->line_height;
1790         else
1791                 es->format_rect.bottom = es->format_rect.top + es->line_height;
1792         if ((es->style & ES_MULTILINE) && !(es->style & ES_AUTOHSCROLL))
1793                 EDIT_BuildLineDefs_ML(wnd, es);
1794 }
1795
1796
1797 /*********************************************************************
1798  *
1799  *      EDIT_UnlockBuffer
1800  *
1801  */
1802 static void EDIT_UnlockBuffer(WND *wnd, EDITSTATE *es, BOOL force)
1803 {
1804         if (!es) {
1805                 ERR(edit, "no EDITSTATE ... please report\n");
1806                 return;
1807         }
1808         if (!(es->style & ES_MULTILINE))
1809                 return;
1810         if (!es->lock_count) {
1811                 ERR(edit, "lock_count == 0 ... please report\n");
1812                 return;
1813         }
1814         if (!es->text) {
1815                 ERR(edit, "es->text == 0 ... please report\n");
1816                 return;
1817         }
1818         if (force || (es->lock_count == 1)) {
1819                 if (es->hloc32) {
1820                         LocalUnlock(es->hloc32);
1821                         es->text = NULL;
1822                 } else if (es->hloc16) {
1823                         LOCAL_Unlock(wnd->hInstance, es->hloc16);
1824                         es->text = NULL;
1825                 }
1826         }
1827         es->lock_count--;
1828 }
1829
1830
1831 /*********************************************************************
1832  *
1833  *      EDIT_WordBreakProc
1834  *
1835  *      Find the beginning of words.
1836  *      Note:   unlike the specs for a WordBreakProc, this function only
1837  *              allows to be called without linebreaks between s[0] upto
1838  *              s[count - 1].  Remember it is only called
1839  *              internally, so we can decide this for ourselves.
1840  *
1841  */
1842 static INT EDIT_WordBreakProc(LPSTR s, INT index, INT count, INT action)
1843 {
1844         INT ret = 0;
1845
1846         TRACE(edit, "s=%p, index=%u, count=%u, action=%d\n",
1847                      s, index, count, action);
1848
1849         switch (action) {
1850         case WB_LEFT:
1851                 if (!count)
1852                         break;
1853                 if (index)
1854                         index--;
1855                 if (s[index] == ' ') {
1856                         while (index && (s[index] == ' '))
1857                                 index--;
1858                         if (index) {
1859                                 while (index && (s[index] != ' '))
1860                                         index--;
1861                                 if (s[index] == ' ')
1862                                         index++;
1863                         }
1864                 } else {
1865                         while (index && (s[index] != ' '))
1866                                 index--;
1867                         if (s[index] == ' ')
1868                                 index++;
1869                 }
1870                 ret = index;
1871                 break;
1872         case WB_RIGHT:
1873                 if (!count)
1874                         break;
1875                 if (index)
1876                         index--;
1877                 if (s[index] == ' ')
1878                         while ((index < count) && (s[index] == ' ')) index++;
1879                 else {
1880                         while (s[index] && (s[index] != ' ') && (index < count))
1881                                 index++;
1882                         while ((s[index] == ' ') && (index < count)) index++;
1883                 }
1884                 ret = index;
1885                 break;
1886         case WB_ISDELIMITER:
1887                 ret = (s[index] == ' ');
1888                 break;
1889         default:
1890                 ERR(edit, "unknown action code, please report !\n");
1891                 break;
1892         }
1893         return ret;
1894 }
1895
1896
1897 /*********************************************************************
1898  *
1899  *      EM_CHARFROMPOS
1900  *
1901  *      returns line number (not index) in high-order word of result.
1902  *      NB : Q137805 is unclear about this. POINT * pointer in lParam apply
1903  *      to Richedit, not to the edit control. Original documentation is valid.
1904  *      FIXME: do the specs mean to return -1 if outside client area or
1905  *              if outside formatting rectangle ???
1906  *
1907  */
1908 static LRESULT EDIT_EM_CharFromPos(WND *wnd, EDITSTATE *es, INT x, INT y)
1909 {
1910         POINT pt;
1911         RECT rc;
1912         INT index;
1913
1914         pt.x = x;
1915         pt.y = y;
1916         GetClientRect(wnd->hwndSelf, &rc);
1917         if (!PtInRect(&rc, pt))
1918                 return -1;
1919
1920         index = EDIT_CharFromPos(wnd, es, x, y, NULL);
1921         return MAKELONG(index, EDIT_EM_LineFromChar(wnd, es, index));
1922 }
1923
1924
1925 /*********************************************************************
1926  *
1927  *      EM_FMTLINES
1928  *
1929  * Enable or disable soft breaks.
1930  */
1931 static BOOL EDIT_EM_FmtLines(WND *wnd, EDITSTATE *es, BOOL add_eol)
1932 {
1933         es->flags &= ~EF_USE_SOFTBRK;
1934         if (add_eol) {
1935                 es->flags |= EF_USE_SOFTBRK;
1936                 FIXME(edit, "soft break enabled, not implemented\n");
1937         }
1938         return add_eol;
1939 }
1940
1941
1942 /*********************************************************************
1943  *
1944  *      EM_GETHANDLE
1945  *
1946  *      Hopefully this won't fire back at us.
1947  *      We always start with a fixed buffer in our own heap.
1948  *      However, with this message a 32 bit application requests
1949  *      a handle to 32 bit moveable local heap memory, where it expects
1950  *      to find the text.
1951  *      It's a pity that from this moment on we have to use this
1952  *      local heap, because applications may rely on the handle
1953  *      in the future.
1954  *
1955  *      In this function we'll try to switch to local heap.
1956  *
1957  */
1958 static HLOCAL EDIT_EM_GetHandle(WND *wnd, EDITSTATE *es)
1959 {
1960         HLOCAL newBuf;
1961         LPSTR newText;
1962         INT newSize;
1963
1964         if (!(es->style & ES_MULTILINE))
1965                 return 0;
1966
1967         if (es->hloc32)
1968                 return es->hloc32;
1969         else if (es->hloc16)
1970                 return (HLOCAL)es->hloc16;
1971
1972         if (!(newBuf = LocalAlloc(LMEM_MOVEABLE, lstrlenA(es->text) + 1))) {
1973                 ERR(edit, "could not allocate new 32 bit buffer\n");
1974                 return 0;
1975         }
1976         newSize = MIN(LocalSize(newBuf) - 1, es->buffer_limit);
1977         if (!(newText = LocalLock(newBuf))) {
1978                 ERR(edit, "could not lock new 32 bit buffer\n");
1979                 LocalFree(newBuf);
1980                 return 0;
1981         }
1982         lstrcpyA(newText, es->text);
1983         EDIT_UnlockBuffer(wnd, es, TRUE);
1984         if (es->text)
1985                 HeapFree(es->heap, 0, es->text);
1986         es->hloc32 = newBuf;
1987         es->hloc16 = (HLOCAL16)NULL;
1988         es->buffer_size = newSize;
1989         es->text = newText;
1990         EDIT_LockBuffer(wnd, es);
1991         TRACE(edit, "switched to 32 bit local heap\n");
1992
1993         return es->hloc32;
1994 }
1995
1996
1997 /*********************************************************************
1998  *
1999  *      EM_GETHANDLE16
2000  *
2001  *      Hopefully this won't fire back at us.
2002  *      We always start with a buffer in 32 bit linear memory.
2003  *      However, with this message a 16 bit application requests
2004  *      a handle of 16 bit local heap memory, where it expects to find
2005  *      the text.
2006  *      It's a pitty that from this moment on we have to use this
2007  *      local heap, because applications may rely on the handle
2008  *      in the future.
2009  *
2010  *      In this function we'll try to switch to local heap.
2011  */
2012 static HLOCAL16 EDIT_EM_GetHandle16(WND *wnd, EDITSTATE *es)
2013 {
2014         HLOCAL16 newBuf;
2015         LPSTR newText;
2016         INT newSize;
2017
2018         if (!(es->style & ES_MULTILINE))
2019                 return 0;
2020
2021         if (es->hloc16)
2022                 return es->hloc16;
2023
2024         if (!LOCAL_HeapSize(wnd->hInstance)) {
2025                 if (!LocalInit16(wnd->hInstance, 0,
2026                                 GlobalSize16(wnd->hInstance))) {
2027                         ERR(edit, "could not initialize local heap\n");
2028                         return 0;
2029                 }
2030                 TRACE(edit, "local heap initialized\n");
2031         }
2032         if (!(newBuf = LOCAL_Alloc(wnd->hInstance, LMEM_MOVEABLE, lstrlenA(es->text) + 1))) {
2033                 ERR(edit, "could not allocate new 16 bit buffer\n");
2034                 return 0;
2035         }
2036         newSize = MIN(LOCAL_Size(wnd->hInstance, newBuf) - 1, es->buffer_limit);
2037         if (!(newText = LOCAL_Lock(wnd->hInstance, newBuf))) {
2038                 ERR(edit, "could not lock new 16 bit buffer\n");
2039                 LOCAL_Free(wnd->hInstance, newBuf);
2040                 return 0;
2041         }
2042         lstrcpyA(newText, es->text);
2043         EDIT_UnlockBuffer(wnd, es, TRUE);
2044         if (es->text)
2045                 HeapFree(es->heap, 0, es->text);
2046         else if (es->hloc32) {
2047                 while (LocalFree(es->hloc32)) ;
2048                 LocalFree(es->hloc32);
2049         }
2050         es->hloc32 = (HLOCAL)NULL;
2051         es->hloc16 = newBuf;
2052         es->buffer_size = newSize;
2053         es->text = newText;
2054         EDIT_LockBuffer(wnd, es);
2055         TRACE(edit, "switched to 16 bit buffer\n");
2056
2057         return es->hloc16;
2058 }
2059
2060
2061 /*********************************************************************
2062  *
2063  *      EM_GETLINE
2064  *
2065  */
2066 static INT EDIT_EM_GetLine(WND *wnd, EDITSTATE *es, INT line, LPSTR lpch)
2067 {
2068         LPSTR src;
2069         INT len;
2070         INT i;
2071
2072         if (es->style & ES_MULTILINE) {
2073                 if (line >= es->line_count)
2074                         return 0;
2075         } else
2076                 line = 0;
2077         i = EDIT_EM_LineIndex(wnd, es, line);
2078         src = es->text + i;
2079         len = MIN(*(WORD *)lpch, EDIT_EM_LineLength(wnd, es, i));
2080         for (i = 0 ; i < len ; i++) {
2081                 *lpch = *src;
2082                 src++;
2083                 lpch++;
2084         }
2085         return (LRESULT)len;
2086 }
2087
2088
2089 /*********************************************************************
2090  *
2091  *      EM_GETSEL
2092  *
2093  */
2094 static LRESULT EDIT_EM_GetSel(WND *wnd, EDITSTATE *es, LPUINT start, LPUINT end)
2095 {
2096         UINT s = es->selection_start;
2097         UINT e = es->selection_end;
2098
2099         ORDER_UINT(s, e);
2100         if (start)
2101                 *start = s;
2102         if (end)
2103                 *end = e;
2104         return MAKELONG(s, e);
2105 }
2106
2107
2108 /*********************************************************************
2109  *
2110  *      EM_GETTHUMB
2111  *
2112  *      FIXME: is this right ?  (or should it be only VSCROLL)
2113  *      (and maybe only for edit controls that really have their
2114  *      own scrollbars) (and maybe only for multiline controls ?)
2115  *      All in all: very poorly documented
2116  *
2117  *      FIXME: now it's also broken, because of the new WM_HSCROLL /
2118  *              WM_VSCROLL handlers
2119  *
2120  */
2121 static LRESULT EDIT_EM_GetThumb(WND *wnd, EDITSTATE *es)
2122 {
2123         return MAKELONG(EDIT_WM_VScroll(wnd, es, EM_GETTHUMB16, 0, 0),
2124                 EDIT_WM_HScroll(wnd, es, EM_GETTHUMB16, 0, 0));
2125 }
2126
2127
2128 /*********************************************************************
2129  *
2130  *      EM_LINEFROMCHAR
2131  *
2132  */
2133 static INT EDIT_EM_LineFromChar(WND *wnd, EDITSTATE *es, INT index)
2134 {
2135         INT line;
2136         LINEDEF *line_def;
2137
2138         if (!(es->style & ES_MULTILINE))
2139                 return 0;
2140         if (index > lstrlenA(es->text))
2141                 return es->line_count - 1;
2142         if (index == -1)
2143                 index = MIN(es->selection_start, es->selection_end);
2144
2145         line = 0;
2146         line_def = es->first_line_def;
2147         index -= line_def->length;
2148         while ((index >= 0) && line_def->next) {
2149                 line++;
2150                 line_def = line_def->next;
2151                 index -= line_def->length;
2152         }
2153         return line;
2154 }
2155
2156
2157 /*********************************************************************
2158  *
2159  *      EM_LINEINDEX
2160  *
2161  */
2162 static INT EDIT_EM_LineIndex(WND *wnd, EDITSTATE *es, INT line)
2163 {
2164         INT line_index;
2165         LINEDEF *line_def;
2166
2167         if (!(es->style & ES_MULTILINE))
2168                 return 0;
2169         if (line >= es->line_count)
2170                 return -1;
2171
2172         line_index = 0;
2173         line_def = es->first_line_def;
2174         if (line == -1) {
2175                 INT index = es->selection_end - line_def->length;
2176                 while ((index >= 0) && line_def->next) {
2177                         line_index += line_def->length;
2178                         line_def = line_def->next;
2179                         index -= line_def->length;
2180                 }
2181         } else {
2182                 while (line > 0) {
2183                         line_index += line_def->length;
2184                         line_def = line_def->next;
2185                         line--;
2186                 }
2187         }
2188         return line_index;
2189 }
2190
2191
2192 /*********************************************************************
2193  *
2194  *      EM_LINELENGTH
2195  *
2196  */
2197 static INT EDIT_EM_LineLength(WND *wnd, EDITSTATE *es, INT index)
2198 {
2199         LINEDEF *line_def;
2200
2201         if (!(es->style & ES_MULTILINE))
2202                 return lstrlenA(es->text);
2203
2204         if (index == -1) {
2205                 /* FIXME: broken
2206                 INT32 sl = EDIT_EM_LineFromChar(wnd, es, es->selection_start);
2207                 INT32 el = EDIT_EM_LineFromChar(wnd, es, es->selection_end);
2208                 return es->selection_start - es->line_defs[sl].offset +
2209                                 es->line_defs[el].offset +
2210                                 es->line_defs[el].length - es->selection_end;
2211                 */
2212                 return 0;
2213         }
2214         line_def = es->first_line_def;
2215         index -= line_def->length;
2216         while ((index >= 0) && line_def->next) {
2217                 line_def = line_def->next;
2218                 index -= line_def->length;
2219         }
2220         return line_def->net_length;
2221 }
2222
2223
2224 /*********************************************************************
2225  *
2226  *      EM_LINESCROLL
2227  *
2228  *      FIXME: dx is in average character widths
2229  *              However, we assume it is in pixels when we use this
2230  *              function internally
2231  *
2232  */
2233 static BOOL EDIT_EM_LineScroll(WND *wnd, EDITSTATE *es, INT dx, INT dy)
2234 {
2235         INT nyoff;
2236
2237         if (!(es->style & ES_MULTILINE))
2238                 return FALSE;
2239
2240         if (-dx > es->x_offset)
2241                 dx = -es->x_offset;
2242         if (dx > es->text_width - es->x_offset)
2243                 dx = es->text_width - es->x_offset;
2244         nyoff = MAX(0, es->y_offset + dy);
2245         if (nyoff >= es->line_count)
2246                 nyoff = es->line_count - 1;
2247         dy = (es->y_offset - nyoff) * es->line_height;
2248         if (dx || dy) {
2249                 RECT rc1;
2250                 RECT rc;
2251                 GetClientRect(wnd->hwndSelf, &rc1);
2252                 IntersectRect(&rc, &rc1, &es->format_rect);
2253                 ScrollWindowEx(wnd->hwndSelf, -dx, dy,
2254                                 NULL, &rc, (HRGN)NULL, NULL, SW_INVALIDATE);
2255                 es->y_offset = nyoff;
2256                 es->x_offset += dx;
2257         }
2258         if (dx && !(es->flags & EF_HSCROLL_TRACK))
2259                 EDIT_NOTIFY_PARENT(wnd, EN_HSCROLL, "EN_HSCROLL");
2260         if (dy && !(es->flags & EF_VSCROLL_TRACK))
2261                 EDIT_NOTIFY_PARENT(wnd, EN_VSCROLL, "EN_VSCROLL");
2262         return TRUE;
2263 }
2264
2265
2266 /*********************************************************************
2267  *
2268  *      EM_POSFROMCHAR
2269  *
2270  */
2271 static LRESULT EDIT_EM_PosFromChar(WND *wnd, EDITSTATE *es, INT index, BOOL after_wrap)
2272 {
2273         INT len = lstrlenA(es->text);
2274         INT l;
2275         INT li;
2276         INT x;
2277         INT y = 0;
2278         HDC dc;
2279         HFONT old_font = 0;
2280         SIZE size;
2281
2282         index = MIN(index, len);
2283         dc = GetDC(wnd->hwndSelf);
2284         if (es->font)
2285                 old_font = SelectObject(dc, es->font);
2286         if (es->style & ES_MULTILINE) {
2287                 l = EDIT_EM_LineFromChar(wnd, es, index);
2288                 y = (l - es->y_offset) * es->line_height;
2289                 li = EDIT_EM_LineIndex(wnd, es, l);
2290                 if (after_wrap && (li == index) && l) {
2291                         INT l2 = l - 1;
2292                         LINEDEF *line_def = es->first_line_def;
2293                         while (l2) {
2294                                 line_def = line_def->next;
2295                                 l2--;
2296                         }
2297                         if (line_def->ending == END_WRAP) {
2298                                 l--;
2299                                 y -= es->line_height;
2300                                 li = EDIT_EM_LineIndex(wnd, es, l);
2301                         }
2302                 }
2303                 x = LOWORD(GetTabbedTextExtentA(dc, es->text + li, index - li,
2304                                 es->tabs_count, es->tabs)) - es->x_offset;
2305         } else {
2306                 LPSTR text = EDIT_GetPasswordPointer_SL(wnd, es);
2307                 if (index < es->x_offset) {
2308                         GetTextExtentPoint32A(dc, text + index,
2309                                         es->x_offset - index, &size);
2310                         x = -size.cx;
2311                 } else {
2312                         GetTextExtentPoint32A(dc, text + es->x_offset,
2313                                         index - es->x_offset, &size);
2314                          x = size.cx;
2315                 }
2316                 y = 0;
2317                 if (es->style & ES_PASSWORD)
2318                         HeapFree(es->heap, 0 ,text);
2319         }
2320         x += es->format_rect.left;
2321         y += es->format_rect.top;
2322         if (es->font)
2323                 SelectObject(dc, old_font);
2324         ReleaseDC(wnd->hwndSelf, dc);
2325         return MAKELONG((INT16)x, (INT16)y);
2326 }
2327
2328
2329 /*********************************************************************
2330  *
2331  *      EM_REPLACESEL
2332  *
2333  *      FIXME: handle ES_NUMBER and ES_OEMCONVERT here
2334  *
2335  */
2336 static void EDIT_EM_ReplaceSel(WND *wnd, EDITSTATE *es, BOOL can_undo, LPCSTR lpsz_replace)
2337 {
2338         INT strl = lstrlenA(lpsz_replace);
2339         INT tl = lstrlenA(es->text);
2340         INT utl;
2341         UINT s;
2342         UINT e;
2343         INT i;
2344         LPSTR p;
2345
2346         s = es->selection_start;
2347         e = es->selection_end;
2348
2349         if ((s == e) && !strl)
2350                 return;
2351
2352         ORDER_UINT(s, e);
2353
2354         if (!EDIT_MakeFit(wnd, es, tl - (e - s) + strl))
2355                 return;
2356
2357         if (e != s) {
2358                 /* there is something to be deleted */
2359                 if (can_undo) {
2360                         utl = lstrlenA(es->undo_text);
2361                         if (!es->undo_insert_count && (*es->undo_text && (s == es->undo_position))) {
2362                                 /* undo-buffer is extended to the right */
2363                                 EDIT_MakeUndoFit(wnd, es, utl + e - s);
2364                                 lstrcpynA(es->undo_text + utl, es->text + s, e - s + 1);
2365                         } else if (!es->undo_insert_count && (*es->undo_text && (e == es->undo_position))) {
2366                                 /* undo-buffer is extended to the left */
2367                                 EDIT_MakeUndoFit(wnd, es, utl + e - s);
2368                                 for (p = es->undo_text + utl ; p >= es->undo_text ; p--)
2369                                         p[e - s] = p[0];
2370                                 for (i = 0 , p = es->undo_text ; i < e - s ; i++)
2371                                         p[i] = (es->text + s)[i];
2372                                 es->undo_position = s;
2373                         } else {
2374                                 /* new undo-buffer */
2375                                 EDIT_MakeUndoFit(wnd, es, e - s);
2376                                 lstrcpynA(es->undo_text, es->text + s, e - s + 1);
2377                                 es->undo_position = s;
2378                         }
2379                         /* any deletion makes the old insertion-undo invalid */
2380                         es->undo_insert_count = 0;
2381                 } else
2382                         EDIT_EM_EmptyUndoBuffer(wnd, es);
2383
2384                 /* now delete */
2385                 lstrcpyA(es->text + s, es->text + e);
2386         }
2387         if (strl) {
2388                 /* there is an insertion */
2389                 if (can_undo) {
2390                         if ((s == es->undo_position) ||
2391                                         ((es->undo_insert_count) &&
2392                                         (s == es->undo_position + es->undo_insert_count)))
2393                                 /*
2394                                  * insertion is new and at delete position or
2395                                  * an extension to either left or right
2396                                  */
2397                                 es->undo_insert_count += strl;
2398                         else {
2399                                 /* new insertion undo */
2400                                 es->undo_position = s;
2401                                 es->undo_insert_count = strl;
2402                                 /* new insertion makes old delete-buffer invalid */
2403                                 *es->undo_text = '\0';
2404                         }
2405                 } else
2406                         EDIT_EM_EmptyUndoBuffer(wnd, es);
2407
2408                 /* now insert */
2409                 tl = lstrlenA(es->text);
2410                 for (p = es->text + tl ; p >= es->text + s ; p--)
2411                         p[strl] = p[0];
2412                 for (i = 0 , p = es->text + s ; i < strl ; i++)
2413                         p[i] = lpsz_replace[i];
2414                 if(es->style & ES_UPPERCASE)
2415                         CharUpperBuffA(p, strl);
2416                 else if(es->style & ES_LOWERCASE)
2417                         CharLowerBuffA(p, strl);
2418                 s += strl;
2419         }
2420         /* FIXME: really inefficient */
2421         if (es->style & ES_MULTILINE)
2422                 EDIT_BuildLineDefs_ML(wnd, es);
2423
2424         EDIT_EM_SetSel(wnd, es, s, s, FALSE);
2425         es->flags |= EF_MODIFIED;
2426         es->flags |= EF_UPDATE;
2427         EDIT_EM_ScrollCaret(wnd, es);
2428
2429         /* FIXME: really inefficient */
2430         InvalidateRect(wnd->hwndSelf, NULL, TRUE);
2431 }
2432
2433
2434 /*********************************************************************
2435  *
2436  *      EM_SCROLL
2437  *
2438  */
2439 static LRESULT EDIT_EM_Scroll(WND *wnd, EDITSTATE *es, INT action)
2440 {
2441         INT dy;
2442
2443         if (!(es->style & ES_MULTILINE))
2444                 return (LRESULT)FALSE;
2445
2446         dy = 0;
2447
2448         switch (action) {
2449         case SB_LINEUP:
2450                 if (es->y_offset)
2451                         dy = -1;
2452                 break;
2453         case SB_LINEDOWN:
2454                 if (es->y_offset < es->line_count - 1)
2455                         dy = 1;
2456                 break;
2457         case SB_PAGEUP:
2458                 if (es->y_offset)
2459                         dy = -(es->format_rect.bottom - es->format_rect.top) / es->line_height;
2460                 break;
2461         case SB_PAGEDOWN:
2462                 if (es->y_offset < es->line_count - 1)
2463                         dy = (es->format_rect.bottom - es->format_rect.top) / es->line_height;
2464                 break;
2465         default:
2466                 return (LRESULT)FALSE;
2467         }
2468         if (dy) {
2469                 EDIT_EM_LineScroll(wnd, es, 0, dy);
2470                 EDIT_NOTIFY_PARENT(wnd, EN_VSCROLL, "EN_VSCROLL");
2471         }
2472         return MAKELONG((INT16)dy, (BOOL16)TRUE);
2473 }
2474
2475
2476 /*********************************************************************
2477  *
2478  *      EM_SCROLLCARET
2479  *
2480  */
2481 static void EDIT_EM_ScrollCaret(WND *wnd, EDITSTATE *es)
2482 {
2483         if (es->style & ES_MULTILINE) {
2484                 INT l;
2485                 INT li;
2486                 INT vlc;
2487                 INT ww;
2488                 INT cw = es->char_width;
2489                 INT x;
2490                 INT dy = 0;
2491                 INT dx = 0;
2492
2493                 l = EDIT_EM_LineFromChar(wnd, es, es->selection_end);
2494                 li = EDIT_EM_LineIndex(wnd, es, l);
2495                 x = SLOWORD(EDIT_EM_PosFromChar(wnd, es, es->selection_end, es->flags & EF_AFTER_WRAP));
2496                 vlc = (es->format_rect.bottom - es->format_rect.top) / es->line_height;
2497                 if (l >= es->y_offset + vlc)
2498                         dy = l - vlc + 1 - es->y_offset;
2499                 if (l < es->y_offset)
2500                         dy = l - es->y_offset;
2501                 ww = es->format_rect.right - es->format_rect.left;
2502                 if (x < es->format_rect.left)
2503                         dx = x - es->format_rect.left - ww / HSCROLL_FRACTION / cw * cw;
2504                 if (x > es->format_rect.right)
2505                         dx = x - es->format_rect.left - (HSCROLL_FRACTION - 1) * ww / HSCROLL_FRACTION / cw * cw;
2506                 if (dy || dx)
2507                         EDIT_EM_LineScroll(wnd, es, dx, dy);
2508         } else {
2509                 INT x;
2510                 INT goal;
2511                 INT format_width;
2512
2513                 if (!(es->style & ES_AUTOHSCROLL))
2514                         return;
2515
2516                 x = SLOWORD(EDIT_EM_PosFromChar(wnd, es, es->selection_end, FALSE));
2517                 format_width = es->format_rect.right - es->format_rect.left;
2518                 if (x < es->format_rect.left) {
2519                         goal = es->format_rect.left + format_width / HSCROLL_FRACTION;
2520                         do {
2521                                 es->x_offset--;
2522                                 x = SLOWORD(EDIT_EM_PosFromChar(wnd, es, es->selection_end, FALSE));
2523                         } while ((x < goal) && es->x_offset);
2524                         /* FIXME: use ScrollWindow() somehow to improve performance */
2525                         InvalidateRect(wnd->hwndSelf, NULL, TRUE);
2526                 } else if (x > es->format_rect.right) {
2527                         INT x_last;
2528                         INT len = lstrlenA(es->text);
2529                         goal = es->format_rect.right - format_width / HSCROLL_FRACTION;
2530                         do {
2531                                 es->x_offset++;
2532                                 x = SLOWORD(EDIT_EM_PosFromChar(wnd, es, es->selection_end, FALSE));
2533                                 x_last = SLOWORD(EDIT_EM_PosFromChar(wnd, es, len, FALSE));
2534                         } while ((x > goal) && (x_last > es->format_rect.right));
2535                         /* FIXME: use ScrollWindow() somehow to improve performance */
2536                         InvalidateRect(wnd->hwndSelf, NULL, TRUE);
2537                 }
2538         }
2539 }
2540
2541
2542 /*********************************************************************
2543  *
2544  *      EM_SETHANDLE
2545  *
2546  *      FIXME:  ES_LOWERCASE, ES_UPPERCASE, ES_OEMCONVERT, ES_NUMBER ???
2547  *
2548  */
2549 static void EDIT_EM_SetHandle(WND *wnd, EDITSTATE *es, HLOCAL hloc)
2550 {
2551         if (!(es->style & ES_MULTILINE))
2552                 return;
2553
2554         if (!hloc) {
2555                 WARN(edit, "called with NULL handle\n");
2556                 return;
2557         }
2558
2559         EDIT_UnlockBuffer(wnd, es, TRUE);
2560         /*
2561          *      old buffer is freed by caller, unless
2562          *      it is still in our own heap.  (in that case
2563          *      we free it, correcting the buggy caller.)
2564          */
2565         if (es->text)
2566                 HeapFree(es->heap, 0, es->text);
2567
2568         es->hloc16 = (HLOCAL16)NULL;
2569         es->hloc32 = hloc;
2570         es->text = NULL;
2571         es->buffer_size = LocalSize(es->hloc32) - 1;
2572         EDIT_LockBuffer(wnd, es);
2573
2574         es->x_offset = es->y_offset = 0;
2575         es->selection_start = es->selection_end = 0;
2576         EDIT_EM_EmptyUndoBuffer(wnd, es);
2577         es->flags &= ~EF_MODIFIED;
2578         es->flags &= ~EF_UPDATE;
2579         EDIT_BuildLineDefs_ML(wnd, es);
2580         InvalidateRect(wnd->hwndSelf, NULL, TRUE);
2581         EDIT_EM_ScrollCaret(wnd, es);
2582 }
2583
2584
2585 /*********************************************************************
2586  *
2587  *      EM_SETHANDLE16
2588  *
2589  *      FIXME:  ES_LOWERCASE, ES_UPPERCASE, ES_OEMCONVERT, ES_NUMBER ???
2590  *
2591  */
2592 static void EDIT_EM_SetHandle16(WND *wnd, EDITSTATE *es, HLOCAL16 hloc)
2593 {
2594         if (!(es->style & ES_MULTILINE))
2595                 return;
2596
2597         if (!hloc) {
2598                 WARN(edit, "called with NULL handle\n");
2599                 return;
2600         }
2601
2602         EDIT_UnlockBuffer(wnd, es, TRUE);
2603         /*
2604          *      old buffer is freed by caller, unless
2605          *      it is still in our own heap.  (in that case
2606          *      we free it, correcting the buggy caller.)
2607          */
2608         if (es->text)
2609                 HeapFree(es->heap, 0, es->text);
2610
2611         es->hloc16 = hloc;
2612         es->hloc32 = (HLOCAL)NULL;
2613         es->text = NULL;
2614         es->buffer_size = LOCAL_Size(wnd->hInstance, es->hloc16) - 1;
2615         EDIT_LockBuffer(wnd, es);
2616
2617         es->x_offset = es->y_offset = 0;
2618         es->selection_start = es->selection_end = 0;
2619         EDIT_EM_EmptyUndoBuffer(wnd, es);
2620         es->flags &= ~EF_MODIFIED;
2621         es->flags &= ~EF_UPDATE;
2622         EDIT_BuildLineDefs_ML(wnd, es);
2623         InvalidateRect(wnd->hwndSelf, NULL, TRUE);
2624         EDIT_EM_ScrollCaret(wnd, es);
2625 }
2626
2627
2628 /*********************************************************************
2629  *
2630  *      EM_SETLIMITTEXT
2631  *
2632  *      FIXME: in WinNT maxsize is 0x7FFFFFFF / 0xFFFFFFFF
2633  *      However, the windows version is not complied to yet in all of edit.c
2634  *
2635  */
2636 static void EDIT_EM_SetLimitText(WND *wnd, EDITSTATE *es, INT limit)
2637 {
2638         if (es->style & ES_MULTILINE) {
2639                 if (limit)
2640                         es->buffer_limit = MIN(limit, BUFLIMIT_MULTI);
2641                 else
2642                         es->buffer_limit = BUFLIMIT_MULTI;
2643         } else {
2644                 if (limit)
2645                         es->buffer_limit = MIN(limit, BUFLIMIT_SINGLE);
2646                 else
2647                         es->buffer_limit = BUFLIMIT_SINGLE;
2648         }
2649 }
2650
2651
2652 /*********************************************************************
2653  *
2654  *      EM_SETMARGINS
2655  *
2656  * EC_USEFONTINFO is used as a left or right value i.e. lParam and not as an
2657  * action wParam despite what the docs say. It also appears not to affect
2658  * multiline controls??
2659  *
2660  */
2661 static void EDIT_EM_SetMargins(WND *wnd, EDITSTATE *es, INT action,
2662                                INT left, INT right)
2663 {
2664         if (action & EC_LEFTMARGIN) {
2665                 if (left != EC_USEFONTINFO)
2666                         es->left_margin = left;
2667                 else
2668                         if (es->style & ES_MULTILINE)
2669                                 es->left_margin = 0; /* ?? */
2670                         else
2671                           es->left_margin = es->char_width;
2672         }
2673
2674         if (action & EC_RIGHTMARGIN) {
2675                 if (right != EC_USEFONTINFO)
2676                         es->right_margin = right;
2677                 else
2678                         if (es->style & ES_MULTILINE)
2679                                 es->right_margin = 0; /* ?? */
2680                         else
2681                                 es->right_margin = es->char_width;
2682         }
2683         TRACE(edit, "left=%d, right=%d\n", es->left_margin, es->right_margin);
2684 }
2685
2686
2687 /*********************************************************************
2688  *
2689  *      EM_SETPASSWORDCHAR
2690  *
2691  */
2692 static void EDIT_EM_SetPasswordChar(WND *wnd, EDITSTATE *es, CHAR c)
2693 {
2694         if (es->style & ES_MULTILINE)
2695                 return;
2696
2697         if (es->password_char == c)
2698                 return;
2699
2700         es->password_char = c;
2701         if (c) {
2702                 wnd->dwStyle |= ES_PASSWORD;
2703                 es->style |= ES_PASSWORD;
2704         } else {
2705                 wnd->dwStyle &= ~ES_PASSWORD;
2706                 es->style &= ~ES_PASSWORD;
2707         }
2708         InvalidateRect(wnd->hwndSelf, NULL, TRUE);
2709 }
2710
2711
2712 /*********************************************************************
2713  *
2714  *      EDIT_EM_SetSel
2715  *
2716  *      note:   unlike the specs say: the order of start and end
2717  *              _is_ preserved in Windows.  (i.e. start can be > end)
2718  *              In other words: this handler is OK
2719  *
2720  */
2721 static void EDIT_EM_SetSel(WND *wnd, EDITSTATE *es, UINT start, UINT end, BOOL after_wrap)
2722 {
2723         UINT old_start = es->selection_start;
2724         UINT old_end = es->selection_end;
2725         UINT len = lstrlenA(es->text);
2726
2727         if (start == -1) {
2728                 start = es->selection_end;
2729                 end = es->selection_end;
2730         } else {
2731                 start = MIN(start, len);
2732                 end = MIN(end, len);
2733         }
2734         es->selection_start = start;
2735         es->selection_end = end;
2736         if (after_wrap)
2737                 es->flags |= EF_AFTER_WRAP;
2738         else
2739                 es->flags &= ~EF_AFTER_WRAP;
2740         if (es->flags & EF_FOCUSED)
2741                 EDIT_SetCaretPos(wnd, es, end, after_wrap);
2742 /* This is little  bit more efficient than before, not sure if it can be improved. FIXME? */
2743         ORDER_UINT(start, end);
2744         ORDER_UINT(end, old_end);
2745         ORDER_UINT(start, old_start);
2746         ORDER_UINT(old_start, old_end);
2747         if (end != old_start)
2748         {
2749 /*
2750  * One can also do
2751  *          ORDER_UINT32(end, old_start);
2752  *          EDIT_InvalidateText(wnd, es, start, end);
2753  *          EDIT_InvalidateText(wnd, es, old_start, old_end);
2754  * in place of the following if statement.
2755  */
2756             if (old_start > end )
2757             {
2758                 EDIT_InvalidateText(wnd, es, start, end);
2759                 EDIT_InvalidateText(wnd, es, old_start, old_end);
2760             }
2761             else
2762             {
2763                 EDIT_InvalidateText(wnd, es, start, old_start);
2764                 EDIT_InvalidateText(wnd, es, end, old_end);
2765             }
2766         }
2767         else EDIT_InvalidateText(wnd, es, start, old_end);
2768 }
2769
2770
2771 /*********************************************************************
2772  *
2773  *      EM_SETTABSTOPS
2774  *
2775  */
2776 static BOOL EDIT_EM_SetTabStops(WND *wnd, EDITSTATE *es, INT count, LPINT tabs)
2777 {
2778         if (!(es->style & ES_MULTILINE))
2779                 return FALSE;
2780         if (es->tabs)
2781                 HeapFree(es->heap, 0, es->tabs);
2782         es->tabs_count = count;
2783         if (!count)
2784                 es->tabs = NULL;
2785         else {
2786                 es->tabs = HeapAlloc(es->heap, 0, count * sizeof(INT));
2787                 memcpy(es->tabs, tabs, count * sizeof(INT));
2788         }
2789         return TRUE;
2790 }
2791
2792
2793 /*********************************************************************
2794  *
2795  *      EM_SETTABSTOPS16
2796  *
2797  */
2798 static BOOL EDIT_EM_SetTabStops16(WND *wnd, EDITSTATE *es, INT count, LPINT16 tabs)
2799 {
2800         if (!(es->style & ES_MULTILINE))
2801                 return FALSE;
2802         if (es->tabs)
2803                 HeapFree(es->heap, 0, es->tabs);
2804         es->tabs_count = count;
2805         if (!count)
2806                 es->tabs = NULL;
2807         else {
2808                 INT i;
2809                 es->tabs = HeapAlloc(es->heap, 0, count * sizeof(INT));
2810                 for (i = 0 ; i < count ; i++)
2811                         es->tabs[i] = *tabs++;
2812         }
2813         return TRUE;
2814 }
2815
2816
2817 /*********************************************************************
2818  *
2819  *      EM_SETWORDBREAKPROC
2820  *
2821  */
2822 static void EDIT_EM_SetWordBreakProc(WND *wnd, EDITSTATE *es, EDITWORDBREAKPROCA wbp)
2823 {
2824         if (es->word_break_proc32A == wbp)
2825                 return;
2826
2827         es->word_break_proc32A = wbp;
2828         es->word_break_proc16 = NULL;
2829         if ((es->style & ES_MULTILINE) && !(es->style & ES_AUTOHSCROLL)) {
2830                 EDIT_BuildLineDefs_ML(wnd, es);
2831                 InvalidateRect(wnd->hwndSelf, NULL, TRUE);
2832         }
2833 }
2834
2835
2836 /*********************************************************************
2837  *
2838  *      EM_SETWORDBREAKPROC16
2839  *
2840  */
2841 static void EDIT_EM_SetWordBreakProc16(WND *wnd, EDITSTATE *es, EDITWORDBREAKPROC16 wbp)
2842 {
2843         if (es->word_break_proc16 == wbp)
2844                 return;
2845
2846         es->word_break_proc32A = NULL;
2847         es->word_break_proc16 = wbp;
2848         if ((es->style & ES_MULTILINE) && !(es->style & ES_AUTOHSCROLL)) {
2849                 EDIT_BuildLineDefs_ML(wnd, es);
2850                 InvalidateRect(wnd->hwndSelf, NULL, TRUE);
2851         }
2852 }
2853
2854
2855 /*********************************************************************
2856  *
2857  *      EM_UNDO / WM_UNDO
2858  *
2859  */
2860 static BOOL EDIT_EM_Undo(WND *wnd, EDITSTATE *es)
2861 {
2862         INT ulength = lstrlenA(es->undo_text);
2863         LPSTR utext = HeapAlloc(es->heap, 0, ulength + 1);
2864
2865         lstrcpyA(utext, es->undo_text);
2866
2867         TRACE(edit, "before UNDO:insertion length = %d, deletion buffer = %s\n",
2868                      es->undo_insert_count, utext);
2869
2870         EDIT_EM_SetSel(wnd, es, es->undo_position, es->undo_position + es->undo_insert_count, FALSE);
2871         EDIT_EM_EmptyUndoBuffer(wnd, es);
2872         EDIT_EM_ReplaceSel(wnd, es, TRUE, utext);
2873         EDIT_EM_SetSel(wnd, es, es->undo_position, es->undo_position + es->undo_insert_count, FALSE);
2874         HeapFree(es->heap, 0, utext);
2875
2876         TRACE(edit, "after UNDO:insertion length = %d, deletion buffer = %s\n",
2877                         es->undo_insert_count, es->undo_text);
2878
2879         return TRUE;
2880 }
2881
2882
2883 /*********************************************************************
2884  *
2885  *      WM_CHAR
2886  *
2887  */
2888 static void EDIT_WM_Char(WND *wnd, EDITSTATE *es, CHAR c, DWORD key_data)
2889 {
2890         switch (c) {
2891         case '\r':
2892         case '\n':
2893                 if (es->style & ES_MULTILINE) {
2894                         if (es->style & ES_READONLY) {
2895                                 EDIT_MoveHome(wnd, es, FALSE);
2896                                 EDIT_MoveDown_ML(wnd, es, FALSE);
2897                         } else
2898                                 EDIT_EM_ReplaceSel(wnd, es, TRUE, "\r\n");
2899                 }
2900                 break;
2901         case '\t':
2902                 if ((es->style & ES_MULTILINE) && !(es->style & ES_READONLY))
2903                         EDIT_EM_ReplaceSel(wnd, es, TRUE, "\t");
2904                 break;
2905         default:
2906                 if (!(es->style & ES_READONLY) && ((BYTE)c >= ' ') && (c != 127)) {
2907                         char str[2];
2908                         str[0] = c;
2909                         str[1] = '\0';
2910                         EDIT_EM_ReplaceSel(wnd, es, TRUE, str);
2911                 }
2912                 break;
2913         }
2914 }
2915
2916
2917 /*********************************************************************
2918  *
2919  *      WM_COMMAND
2920  *
2921  */
2922 static void EDIT_WM_Command(WND *wnd, EDITSTATE *es, INT code, INT id, HWND control)
2923 {
2924         if (code || control)
2925                 return;
2926
2927         switch (id) {
2928                 case EM_UNDO:
2929                         EDIT_EM_Undo(wnd, es);
2930                         break;
2931                 case WM_CUT:
2932                         EDIT_WM_Cut(wnd, es);
2933                         break;
2934                 case WM_COPY:
2935                         EDIT_WM_Copy(wnd, es);
2936                         break;
2937                 case WM_PASTE:
2938                         EDIT_WM_Paste(wnd, es);
2939                         break;
2940                 case WM_CLEAR:
2941                         EDIT_WM_Clear(wnd, es);
2942                         break;
2943                 case EM_SETSEL:
2944                         EDIT_EM_SetSel(wnd, es, 0, -1, FALSE);
2945                         EDIT_EM_ScrollCaret(wnd, es);
2946                         break;
2947                 default:
2948                         ERR(edit, "unknown menu item, please report\n");
2949                         break;
2950         }
2951 }
2952
2953
2954 /*********************************************************************
2955  *
2956  *      WM_CONTEXTMENU
2957  *
2958  *      Note: the resource files resource/sysres_??.rc cannot define a
2959  *              single popup menu.  Hence we use a (dummy) menubar
2960  *              containing the single popup menu as its first item.
2961  *
2962  *      FIXME: the message identifiers have been chosen arbitrarily,
2963  *              hence we use MF_BYPOSITION.
2964  *              We might as well use the "real" values (anybody knows ?)
2965  *              The menu definition is in resources/sysres_??.rc.
2966  *              Once these are OK, we better use MF_BYCOMMAND here
2967  *              (as we do in EDIT_WM_Command()).
2968  *
2969  */
2970 static void EDIT_WM_ContextMenu(WND *wnd, EDITSTATE *es, HWND hwnd, INT x, INT y)
2971 {
2972         HMENU menu = LoadMenuIndirectA(SYSRES_GetResPtr(SYSRES_MENU_EDITMENU));
2973         HMENU popup = GetSubMenu(menu, 0);
2974         UINT start = es->selection_start;
2975         UINT end = es->selection_end;
2976
2977         ORDER_UINT(start, end);
2978
2979         /* undo */
2980         EnableMenuItem(popup, 0, MF_BYPOSITION | (EDIT_EM_CanUndo(wnd, es) ? MF_ENABLED : MF_GRAYED));
2981         /* cut */
2982         EnableMenuItem(popup, 2, MF_BYPOSITION | ((end - start) && !(es->style & ES_PASSWORD) ? MF_ENABLED : MF_GRAYED));
2983         /* copy */
2984         EnableMenuItem(popup, 3, MF_BYPOSITION | ((end - start) && !(es->style & ES_PASSWORD) ? MF_ENABLED : MF_GRAYED));
2985         /* paste */
2986         EnableMenuItem(popup, 4, MF_BYPOSITION | (IsClipboardFormatAvailable(CF_TEXT) ? MF_ENABLED : MF_GRAYED));
2987         /* delete */
2988         EnableMenuItem(popup, 5, MF_BYPOSITION | ((end - start) ? MF_ENABLED : MF_GRAYED));
2989         /* select all */
2990         EnableMenuItem(popup, 7, MF_BYPOSITION | (start || (end != lstrlenA(es->text)) ? MF_ENABLED : MF_GRAYED));
2991
2992         TrackPopupMenu(popup, TPM_LEFTALIGN | TPM_RIGHTBUTTON, x, y, 0, wnd->hwndSelf, NULL);
2993         DestroyMenu(menu);
2994 }
2995
2996
2997 /*********************************************************************
2998  *
2999  *      WM_COPY
3000  *
3001  */
3002 static void EDIT_WM_Copy(WND *wnd, EDITSTATE *es)
3003 {
3004         INT s = es->selection_start;
3005         INT e = es->selection_end;
3006         HGLOBAL hdst;
3007         LPSTR dst;
3008
3009         if (e == s)
3010                 return;
3011         ORDER_INT(s, e);
3012         hdst = GlobalAlloc(GMEM_MOVEABLE, (DWORD)(e - s + 1));
3013         dst = GlobalLock(hdst);
3014         lstrcpynA(dst, es->text + s, e - s + 1);
3015         GlobalUnlock(hdst);
3016         OpenClipboard(wnd->hwndSelf);
3017         EmptyClipboard();
3018         SetClipboardData(CF_TEXT, hdst);
3019         CloseClipboard();
3020 }
3021
3022
3023 /*********************************************************************
3024  *
3025  *      WM_CREATE
3026  *
3027  */
3028 static LRESULT EDIT_WM_Create(WND *wnd, EDITSTATE *es, LPCREATESTRUCTA cs)
3029 {
3030         /*
3031          *      To initialize some final structure members, we call some helper
3032          *      functions.  However, since the EDITSTATE is not consistent (i.e.
3033          *      not fully initialized), we should be very careful which
3034          *      functions can be called, and in what order.
3035          */
3036         EDIT_WM_SetFont(wnd, es, 0, FALSE);
3037     EDIT_EM_EmptyUndoBuffer(wnd, es);
3038
3039         if (cs->lpszName && *(cs->lpszName) != '\0') {
3040                 EDIT_EM_ReplaceSel(wnd, es, FALSE, cs->lpszName);
3041                 /* if we insert text to the editline, the text scrolls out of the window, as the caret is placed after the insert pos normally; thus we reset es->selection... to 0 and update caret */
3042                 es->selection_start = es->selection_end = 0;
3043                 EDIT_EM_ScrollCaret(wnd, es);
3044         }
3045         return 0;
3046 }
3047
3048
3049 /*********************************************************************
3050  *
3051  *      WM_DESTROY
3052  *
3053  */
3054 static void EDIT_WM_Destroy(WND *wnd, EDITSTATE *es)
3055 {
3056         if (es->hloc32) {
3057                 while (LocalUnlock(es->hloc32)) ;
3058                 LocalFree(es->hloc32);
3059         }
3060         if (es->hloc16) {
3061                 while (LOCAL_Unlock(wnd->hInstance, es->hloc16)) ;
3062                 LOCAL_Free(wnd->hInstance, es->hloc16);
3063         }
3064         HeapDestroy(es->heap);
3065         HeapFree(GetProcessHeap(), 0, es);
3066         *(EDITSTATE **)wnd->wExtra = NULL;
3067 }
3068
3069
3070 /*********************************************************************
3071  *
3072  *      WM_ERASEBKGND
3073  *
3074  */
3075 static LRESULT EDIT_WM_EraseBkGnd(WND *wnd, EDITSTATE *es, HDC dc)
3076 {
3077         HBRUSH brush;
3078         RECT rc;
3079
3080         if (!(brush = (HBRUSH)EDIT_SEND_CTLCOLOR(wnd, dc)))
3081                 brush = (HBRUSH)GetStockObject(WHITE_BRUSH);
3082
3083         GetClientRect(wnd->hwndSelf, &rc);
3084         IntersectClipRect(dc, rc.left, rc.top, rc.right, rc.bottom);
3085         GetClipBox(dc, &rc);
3086         /*
3087          *      FIXME:  specs say that we should UnrealizeObject() the brush,
3088          *              but the specs of UnrealizeObject() say that we shouldn't
3089          *              unrealize a stock object.  The default brush that
3090          *              DefWndProc() returns is ... a stock object.
3091          */
3092         FillRect(dc, &rc, brush);
3093         return -1;
3094 }
3095
3096
3097 /*********************************************************************
3098  *
3099  *      WM_GETTEXT
3100  *
3101  */
3102 static INT EDIT_WM_GetText(WND *wnd, EDITSTATE *es, INT count, LPSTR text)
3103 {
3104         INT len = lstrlenA(es->text);
3105
3106         if (count > len) {
3107                 lstrcpyA(text, es->text);
3108                 return len;
3109         } else
3110                 return -1;
3111 }
3112
3113
3114 /*********************************************************************
3115  *
3116  *      EDIT_HScroll_Hack
3117  *
3118  *      16 bit notepad needs this.  Actually it is not _our_ hack,
3119  *      it is notepad's.  Notepad is sending us scrollbar messages with
3120  *      undocumented parameters without us even having a scrollbar ... !?!?
3121  *
3122  */
3123 static LRESULT EDIT_HScroll_Hack(WND *wnd, EDITSTATE *es, INT action, INT pos, HWND scroll_bar)
3124 {
3125         INT dx = 0;
3126         INT fw = es->format_rect.right - es->format_rect.left;
3127         LRESULT ret = 0;
3128
3129         if (!(es->flags & EF_HSCROLL_HACK)) {
3130                 ERR(edit, "hacked WM_HSCROLL handler invoked\n");
3131                 ERR(edit, "      if you are _not_ running 16 bit notepad, please report\n");
3132                 ERR(edit, "      (this message is only displayed once per edit control)\n");
3133                 es->flags |= EF_HSCROLL_HACK;
3134         }
3135
3136         switch (action) {
3137         case SB_LINELEFT:
3138                 if (es->x_offset)
3139                         dx = -es->char_width;
3140                 break;
3141         case SB_LINERIGHT:
3142                 if (es->x_offset < es->text_width)
3143                         dx = es->char_width;
3144                 break;
3145         case SB_PAGELEFT:
3146                 if (es->x_offset)
3147                         dx = -fw / HSCROLL_FRACTION / es->char_width * es->char_width;
3148                 break;
3149         case SB_PAGERIGHT:
3150                 if (es->x_offset < es->text_width)
3151                         dx = fw / HSCROLL_FRACTION / es->char_width * es->char_width;
3152                 break;
3153         case SB_LEFT:
3154                 if (es->x_offset)
3155                         dx = -es->x_offset;
3156                 break;
3157         case SB_RIGHT:
3158                 if (es->x_offset < es->text_width)
3159                         dx = es->text_width - es->x_offset;
3160                 break;
3161         case SB_THUMBTRACK:
3162                 es->flags |= EF_HSCROLL_TRACK;
3163                 dx = pos * es->text_width / 100 - es->x_offset;
3164                 break;
3165         case SB_THUMBPOSITION:
3166                 es->flags &= ~EF_HSCROLL_TRACK;
3167                 if (!(dx = pos * es->text_width / 100 - es->x_offset))
3168                         EDIT_NOTIFY_PARENT(wnd, EN_HSCROLL, "EN_HSCROLL");
3169                 break;
3170         case SB_ENDSCROLL:
3171                 break;
3172
3173         /*
3174          *      FIXME : the next two are undocumented !
3175          *      Are we doing the right thing ?
3176          *      At least Win 3.1 Notepad makes use of EM_GETTHUMB this way,
3177          *      although it's also a regular control message.
3178          */
3179         case EM_GETTHUMB16:
3180                 ret = es->text_width ? es->x_offset * 100 / es->text_width : 0;
3181                 break;
3182         case EM_LINESCROLL16:
3183                 dx = pos;
3184                 break;
3185
3186         default:
3187                 ERR(edit, "undocumented (hacked) WM_HSCROLL parameter, please report\n");
3188                 return 0;
3189         }
3190         if (dx)
3191                 EDIT_EM_LineScroll(wnd, es, dx, 0);
3192         return ret;
3193 }
3194
3195
3196 /*********************************************************************
3197  *
3198  *      WM_HSCROLL
3199  *
3200  */
3201 static LRESULT EDIT_WM_HScroll(WND *wnd, EDITSTATE *es, INT action, INT pos, HWND scroll_bar)
3202 {
3203         INT dx;
3204         INT fw;
3205
3206         if (!(es->style & ES_MULTILINE))
3207                 return 0;
3208
3209         if (!(es->style & ES_AUTOHSCROLL))
3210                 return 0;
3211
3212         if (!(es->style & WS_HSCROLL))
3213                 return EDIT_HScroll_Hack(wnd, es, action, pos, scroll_bar);
3214
3215         dx = 0;
3216         fw = es->format_rect.right - es->format_rect.left;
3217         switch (action) {
3218         case SB_LINELEFT:
3219                 if (es->x_offset)
3220                         dx = -es->char_width;
3221                 break;
3222         case SB_LINERIGHT:
3223                 if (es->x_offset < es->text_width)
3224                         dx = es->char_width;
3225                 break;
3226         case SB_PAGELEFT:
3227                 if (es->x_offset)
3228                         dx = -fw / HSCROLL_FRACTION / es->char_width * es->char_width;
3229                 break;
3230         case SB_PAGERIGHT:
3231                 if (es->x_offset < es->text_width)
3232                         dx = fw / HSCROLL_FRACTION / es->char_width * es->char_width;
3233                 break;
3234         case SB_LEFT:
3235                 if (es->x_offset)
3236                         dx = -es->x_offset;
3237                 break;
3238         case SB_RIGHT:
3239                 if (es->x_offset < es->text_width)
3240                         dx = es->text_width - es->x_offset;
3241                 break;
3242         case SB_THUMBTRACK:
3243                 es->flags |= EF_HSCROLL_TRACK;
3244                 dx = pos - es->x_offset;
3245                 break;
3246         case SB_THUMBPOSITION:
3247                 es->flags &= ~EF_HSCROLL_TRACK;
3248                 if (!(dx = pos - es->x_offset)) {
3249                         SetScrollPos(wnd->hwndSelf, SB_HORZ, pos, TRUE);
3250                         EDIT_NOTIFY_PARENT(wnd, EN_HSCROLL, "EN_HSCROLL");
3251                 }
3252                 break;
3253         case SB_ENDSCROLL:
3254                 break;
3255
3256         default:
3257                 ERR(edit, "undocumented WM_HSCROLL parameter, please report\n");
3258                 return 0;
3259         }
3260         if (dx)
3261                 EDIT_EM_LineScroll(wnd, es, dx, 0);
3262         return 0;
3263 }
3264
3265
3266 /*********************************************************************
3267  *
3268  *      EDIT_CheckCombo
3269  *
3270  */
3271 static BOOL EDIT_CheckCombo(WND *wnd, UINT msg, INT key, DWORD key_data)
3272 {
3273         HWND hLBox;
3274
3275         if (WIDGETS_IsControl(wnd->parent, BIC32_COMBO) &&
3276                         (hLBox = COMBO_GetLBWindow(wnd->parent))) {
3277                 HWND hCombo = wnd->parent->hwndSelf;
3278                 BOOL bUIFlip = TRUE;
3279
3280                 TRACE(combo, "[%04x]: handling msg %04x (%04x)\n",
3281                              wnd->hwndSelf, (UINT16)msg, (UINT16)key);
3282
3283                 switch (msg) {
3284                 case WM_KEYDOWN: /* Handle F4 and arrow keys */
3285                         if (key != VK_F4) {
3286                                 bUIFlip = (BOOL)SendMessageA(hCombo, CB_GETEXTENDEDUI, 0, 0);
3287                                 if (SendMessageA(hCombo, CB_GETDROPPEDSTATE, 0, 0))
3288                                         bUIFlip = FALSE;
3289                         }
3290                         if (!bUIFlip)
3291                                 SendMessageA(hLBox, WM_KEYDOWN, (WPARAM)key, 0);
3292                         else {
3293                                 /* make sure ComboLBox pops up */
3294                                 SendMessageA(hCombo, CB_SETEXTENDEDUI, 0, 0);
3295                                 SendMessageA(hLBox, WM_KEYDOWN, VK_F4, 0);
3296                                 SendMessageA(hCombo, CB_SETEXTENDEDUI, 1, 0);
3297                         }
3298                         break;
3299                 case WM_SYSKEYDOWN: /* Handle Alt+up/down arrows */
3300                         bUIFlip = (BOOL)SendMessageA(hCombo, CB_GETEXTENDEDUI, 0, 0);
3301                         if (bUIFlip) {
3302                                 bUIFlip = (BOOL)SendMessageA(hCombo, CB_GETDROPPEDSTATE, 0, 0);
3303                                 SendMessageA(hCombo, CB_SHOWDROPDOWN, (bUIFlip) ? FALSE : TRUE, 0);
3304                         } else
3305                                 SendMessageA(hLBox, WM_KEYDOWN, VK_F4, 0);
3306                         break;
3307                 }
3308                 return TRUE;
3309         }
3310         return FALSE;
3311 }
3312
3313
3314 /*********************************************************************
3315  *
3316  *      WM_KEYDOWN
3317  *
3318  *      Handling of special keys that don't produce a WM_CHAR
3319  *      (i.e. non-printable keys) & Backspace & Delete
3320  *
3321  */
3322 static LRESULT EDIT_WM_KeyDown(WND *wnd, EDITSTATE *es, INT key, DWORD key_data)
3323 {
3324         BOOL shift;
3325         BOOL control;
3326
3327         if (GetKeyState(VK_MENU) & 0x8000)
3328                 return 0;
3329
3330         shift = GetKeyState(VK_SHIFT) & 0x8000;
3331         control = GetKeyState(VK_CONTROL) & 0x8000;
3332
3333         switch (key) {
3334         case VK_F4:
3335         case VK_UP:
3336                 if (EDIT_CheckCombo(wnd, WM_KEYDOWN, key, key_data))
3337                         break;
3338                 if (key == VK_F4)
3339                         break;
3340                 /* fall through */
3341         case VK_LEFT:
3342                 if ((es->style & ES_MULTILINE) && (key == VK_UP))
3343                         EDIT_MoveUp_ML(wnd, es, shift);
3344                 else
3345                         if (control)
3346                                 EDIT_MoveWordBackward(wnd, es, shift);
3347                         else
3348                                 EDIT_MoveBackward(wnd, es, shift);
3349                 break;
3350         case VK_DOWN:
3351                 if (EDIT_CheckCombo(wnd, WM_KEYDOWN, key, key_data))
3352                         break;
3353                 /* fall through */
3354         case VK_RIGHT:
3355                 if ((es->style & ES_MULTILINE) && (key == VK_DOWN))
3356                         EDIT_MoveDown_ML(wnd, es, shift);
3357                 else if (control)
3358                         EDIT_MoveWordForward(wnd, es, shift);
3359                 else
3360                         EDIT_MoveForward(wnd, es, shift);
3361                 break;
3362         case VK_HOME:
3363                 EDIT_MoveHome(wnd, es, shift);
3364                 break;
3365         case VK_END:
3366                 EDIT_MoveEnd(wnd, es, shift);
3367                 break;
3368         case VK_PRIOR:
3369                 if (es->style & ES_MULTILINE)
3370                         EDIT_MovePageUp_ML(wnd, es, shift);
3371                 break;
3372         case VK_NEXT:
3373                 if (es->style & ES_MULTILINE)
3374                         EDIT_MovePageDown_ML(wnd, es, shift);
3375                 break;
3376         case VK_BACK:
3377                 if (!(es->style & ES_READONLY) && !control) {
3378                         if (es->selection_start != es->selection_end)
3379                                 EDIT_WM_Clear(wnd, es);
3380                         else {
3381                                 /* delete character left of caret */
3382                                 EDIT_EM_SetSel(wnd, es, -1, 0, FALSE);
3383                                 EDIT_MoveBackward(wnd, es, TRUE);
3384                                 EDIT_WM_Clear(wnd, es);
3385                         }
3386                 }
3387                 break;
3388         case VK_DELETE:
3389                 if (!(es->style & ES_READONLY) && !(shift && control)) {
3390                         if (es->selection_start != es->selection_end) {
3391                                 if (shift)
3392                                         EDIT_WM_Cut(wnd, es);
3393                                 else
3394                                         EDIT_WM_Clear(wnd, es);
3395                         } else {
3396                                 if (shift) {
3397                                         /* delete character left of caret */
3398                                         EDIT_EM_SetSel(wnd, es, -1, 0, FALSE);
3399                                         EDIT_MoveBackward(wnd, es, TRUE);
3400                                         EDIT_WM_Clear(wnd, es);
3401                                 } else if (control) {
3402                                         /* delete to end of line */
3403                                         EDIT_EM_SetSel(wnd, es, -1, 0, FALSE);
3404                                         EDIT_MoveEnd(wnd, es, TRUE);
3405                                         EDIT_WM_Clear(wnd, es);
3406                                 } else {
3407                                         /* delete character right of caret */
3408                                         EDIT_EM_SetSel(wnd, es, -1, 0, FALSE);
3409                                         EDIT_MoveForward(wnd, es, TRUE);
3410                                         EDIT_WM_Clear(wnd, es);
3411                                 }
3412                         }
3413                 }
3414                 break;
3415         case VK_INSERT:
3416                 if (shift) {
3417                         if (!(es->style & ES_READONLY))
3418                                 EDIT_WM_Paste(wnd, es);
3419                 } else if (control)
3420                         EDIT_WM_Copy(wnd, es);
3421                 break;
3422         }
3423         return 0;
3424 }
3425
3426
3427 /*********************************************************************
3428  *
3429  *      WM_KILLFOCUS
3430  *
3431  */
3432 static LRESULT EDIT_WM_KillFocus(WND *wnd, EDITSTATE *es, HWND window_getting_focus)
3433 {
3434         es->flags &= ~EF_FOCUSED;
3435         DestroyCaret();
3436         if(!(es->style & ES_NOHIDESEL))
3437                 EDIT_InvalidateText(wnd, es, es->selection_start, es->selection_end);
3438         EDIT_NOTIFY_PARENT(wnd, EN_KILLFOCUS, "EN_KILLFOCUS");
3439         return 0;
3440 }
3441
3442
3443 /*********************************************************************
3444  *
3445  *      WM_LBUTTONDBLCLK
3446  *
3447  *      The caret position has been set on the WM_LBUTTONDOWN message
3448  *
3449  */
3450 static LRESULT EDIT_WM_LButtonDblClk(WND *wnd, EDITSTATE *es, DWORD keys, INT x, INT y)
3451 {
3452         INT s;
3453         INT e = es->selection_end;
3454         INT l;
3455         INT li;
3456         INT ll;
3457
3458         if (!(es->flags & EF_FOCUSED))
3459                 return 0;
3460
3461         l = EDIT_EM_LineFromChar(wnd, es, e);
3462         li = EDIT_EM_LineIndex(wnd, es, l);
3463         ll = EDIT_EM_LineLength(wnd, es, e);
3464         s = li + EDIT_CallWordBreakProc (wnd, es, li, e - li, ll, WB_LEFT);
3465         e = li + EDIT_CallWordBreakProc(wnd, es, li, e - li, ll, WB_RIGHT);
3466         EDIT_EM_SetSel(wnd, es, s, e, FALSE);
3467         EDIT_EM_ScrollCaret(wnd, es);
3468         return 0;
3469 }
3470
3471
3472 /*********************************************************************
3473  *
3474  *      WM_LBUTTONDOWN
3475  *
3476  */
3477 static LRESULT EDIT_WM_LButtonDown(WND *wnd, EDITSTATE *es, DWORD keys, INT x, INT y)
3478 {
3479         INT e;
3480         BOOL after_wrap;
3481
3482         if (!(es->flags & EF_FOCUSED))
3483                 return 0;
3484
3485         SetCapture(wnd->hwndSelf);
3486         EDIT_ConfinePoint(wnd, es, &x, &y);
3487         e = EDIT_CharFromPos(wnd, es, x, y, &after_wrap);
3488         EDIT_EM_SetSel(wnd, es, (keys & MK_SHIFT) ? es->selection_start : e, e, after_wrap);
3489         EDIT_EM_ScrollCaret(wnd, es);
3490         es->region_posx = es->region_posy = 0;
3491         SetTimer(wnd->hwndSelf, 0, 100, NULL);
3492         return 0;
3493 }
3494
3495
3496 /*********************************************************************
3497  *
3498  *      WM_LBUTTONUP
3499  *
3500  */
3501 static LRESULT EDIT_WM_LButtonUp(WND *wnd, EDITSTATE *es, DWORD keys, INT x, INT y)
3502 {
3503         if (GetCapture() == wnd->hwndSelf) {
3504                 KillTimer(wnd->hwndSelf, 0);
3505                 ReleaseCapture();
3506         }
3507         return 0;
3508 }
3509
3510
3511 /*********************************************************************
3512  *
3513  *      WM_MOUSEMOVE
3514  *
3515  */
3516 static LRESULT EDIT_WM_MouseMove(WND *wnd, EDITSTATE *es, DWORD keys, INT x, INT y)
3517 {
3518         INT e;
3519         BOOL after_wrap;
3520         INT prex, prey;
3521
3522         if (GetCapture() != wnd->hwndSelf)
3523                 return 0;
3524
3525         /*
3526          *      FIXME: gotta do some scrolling if outside client
3527          *              area.  Maybe reset the timer ?
3528          */
3529         prex = x; prey = y;
3530         EDIT_ConfinePoint(wnd, es, &x, &y);
3531         es->region_posx = (prex < x) ? -1 : ((prex > x) ? 1 : 0);
3532         es->region_posy = (prey < y) ? -1 : ((prey > y) ? 1 : 0);
3533         e = EDIT_CharFromPos(wnd, es, x, y, &after_wrap);
3534         EDIT_EM_SetSel(wnd, es, es->selection_start, e, after_wrap);
3535         return 0;
3536 }
3537
3538
3539 /*********************************************************************
3540  *
3541  *      WM_NCCREATE
3542  *
3543  */
3544 static LRESULT EDIT_WM_NCCreate(WND *wnd, LPCREATESTRUCTA cs)
3545 {
3546         EDITSTATE *es;
3547
3548         if (!(es = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*es))))
3549                 return FALSE;
3550         *(EDITSTATE **)wnd->wExtra = es;
3551
3552        /*
3553         *      Note: since the EDITSTATE has not been fully initialized yet,
3554         *            we can't use any API calls that may send
3555         *            WM_XXX messages before WM_NCCREATE is completed.
3556         */
3557
3558         if (!(es->heap = HeapCreate(0, 0x10000, 0)))
3559                 return FALSE;
3560         es->style = cs->style;
3561
3562         if ((es->style & WS_BORDER) && !(es->style & WS_DLGFRAME))
3563                 wnd->dwStyle &= ~WS_BORDER;
3564
3565         if (es->style & ES_MULTILINE) {
3566                 es->buffer_size = BUFSTART_MULTI;
3567                 es->buffer_limit = BUFLIMIT_MULTI;
3568                 if (es->style & WS_VSCROLL)
3569                         es->style |= ES_AUTOVSCROLL;
3570                 if (es->style & WS_HSCROLL)
3571                         es->style |= ES_AUTOHSCROLL;
3572                 es->style &= ~ES_PASSWORD;
3573                 if ((es->style & ES_CENTER) || (es->style & ES_RIGHT)) {
3574                         if (es->style & ES_RIGHT)
3575                                 es->style &= ~ES_CENTER;
3576                         es->style &= ~WS_HSCROLL;
3577                         es->style &= ~ES_AUTOHSCROLL;
3578                 }
3579
3580                 /* FIXME: for now, all multi line controls are AUTOVSCROLL */
3581                 es->style |= ES_AUTOVSCROLL;
3582         } else {
3583                 es->buffer_size = BUFSTART_SINGLE;
3584                 es->buffer_limit = BUFLIMIT_SINGLE;
3585                 es->style &= ~ES_CENTER;
3586                 es->style &= ~ES_RIGHT;
3587                 es->style &= ~WS_HSCROLL;
3588                 es->style &= ~WS_VSCROLL;
3589                 es->style &= ~ES_AUTOVSCROLL;
3590                 es->style &= ~ES_WANTRETURN;
3591                 if (es->style & ES_UPPERCASE) {
3592                         es->style &= ~ES_LOWERCASE;
3593                         es->style &= ~ES_NUMBER;
3594                 } else if (es->style & ES_LOWERCASE)
3595                         es->style &= ~ES_NUMBER;
3596                 if (es->style & ES_PASSWORD)
3597                         es->password_char = '*';
3598
3599                 /* FIXME: for now, all single line controls are AUTOHSCROLL */
3600                 es->style |= ES_AUTOHSCROLL;
3601         }
3602         if (!(es->text = HeapAlloc(es->heap, 0, es->buffer_size + 1)))
3603                 return FALSE;
3604         es->buffer_size = HeapSize(es->heap, 0, es->text) - 1;
3605         if (!(es->undo_text = HeapAlloc(es->heap, 0, es->buffer_size + 1)))
3606                 return FALSE;
3607         es->undo_buffer_size = HeapSize(es->heap, 0, es->undo_text) - 1;
3608         *es->text = '\0';
3609         if (es->style & ES_MULTILINE)
3610                 if (!(es->first_line_def = HeapAlloc(es->heap, HEAP_ZERO_MEMORY, sizeof(LINEDEF))))
3611                         return FALSE;
3612         es->line_count = 1;
3613
3614         return TRUE;
3615 }
3616
3617 /*********************************************************************
3618  *
3619  *      WM_PAINT
3620  *
3621  */
3622 static void EDIT_WM_Paint(WND *wnd, EDITSTATE *es)
3623 {
3624         PAINTSTRUCT ps;
3625         INT i;
3626         HDC dc;
3627         HFONT old_font = 0;
3628         RECT rc;
3629         RECT rcLine;
3630         RECT rcRgn;
3631         BOOL rev = IsWindowEnabled(wnd->hwndSelf) &&
3632                                 ((es->flags & EF_FOCUSED) ||
3633                                         (es->style & ES_NOHIDESEL));
3634
3635         if (es->flags & EF_UPDATE)
3636                 EDIT_NOTIFY_PARENT(wnd, EN_UPDATE, "EN_UPDATE");
3637
3638         dc = BeginPaint(wnd->hwndSelf, &ps);
3639         if(es->style & WS_BORDER) {
3640                 GetClientRect(wnd->hwndSelf, &rc);
3641                 if(es->style & ES_MULTILINE) {
3642                         if(es->style & WS_HSCROLL) rc.bottom++;
3643                         if(es->style & WS_VSCROLL) rc.right++;
3644                 }
3645                 Rectangle(dc, rc.left, rc.top, rc.right, rc.bottom);
3646         }
3647         IntersectClipRect(dc, es->format_rect.left,
3648                                 es->format_rect.top,
3649                                 es->format_rect.right,
3650                                 es->format_rect.bottom);
3651         if (es->style & ES_MULTILINE) {
3652                 GetClientRect(wnd->hwndSelf, &rc);
3653                 IntersectClipRect(dc, rc.left, rc.top, rc.right, rc.bottom);
3654         }
3655         if (es->font)
3656                 old_font = SelectObject(dc, es->font);
3657         EDIT_SEND_CTLCOLOR(wnd, dc);
3658         if (!IsWindowEnabled(wnd->hwndSelf))
3659                 SetTextColor(dc, GetSysColor(COLOR_GRAYTEXT));
3660         GetClipBox(dc, &rcRgn);
3661         if (es->style & ES_MULTILINE) {
3662                 INT vlc = (es->format_rect.bottom - es->format_rect.top) / es->line_height;
3663                 for (i = es->y_offset ; i <= MIN(es->y_offset + vlc, es->y_offset + es->line_count - 1) ; i++) {
3664                         EDIT_GetLineRect(wnd, es, i, 0, -1, &rcLine);
3665                         if (IntersectRect(&rc, &rcRgn, &rcLine))
3666                                 EDIT_PaintLine(wnd, es, dc, i, rev);
3667                 }
3668         } else {
3669                 EDIT_GetLineRect(wnd, es, 0, 0, -1, &rcLine);
3670                 if (IntersectRect(&rc, &rcRgn, &rcLine))
3671                         EDIT_PaintLine(wnd, es, dc, 0, rev);
3672         }
3673         if (es->font)
3674                 SelectObject(dc, old_font);
3675         if (es->flags & EF_FOCUSED)
3676                 EDIT_SetCaretPos(wnd, es, es->selection_end,
3677                                  es->flags & EF_AFTER_WRAP);
3678         EndPaint(wnd->hwndSelf, &ps);
3679         if ((es->style & WS_VSCROLL) && !(es->flags & EF_VSCROLL_TRACK)) {
3680                 INT vlc = (es->format_rect.bottom - es->format_rect.top) / es->line_height;
3681                 SCROLLINFO si;
3682                 si.cbSize       = sizeof(SCROLLINFO);
3683                 si.fMask        = SIF_PAGE | SIF_POS | SIF_RANGE | SIF_DISABLENOSCROLL;
3684                 si.nMin         = 0;
3685                 si.nMax         = es->line_count + vlc - 2;
3686                 si.nPage        = vlc;
3687                 si.nPos         = es->y_offset;
3688                 SetScrollInfo(wnd->hwndSelf, SB_VERT, &si, TRUE);
3689         }
3690         if ((es->style & WS_HSCROLL) && !(es->flags & EF_HSCROLL_TRACK)) {
3691                 SCROLLINFO si;
3692                 INT fw = es->format_rect.right - es->format_rect.left;
3693                 si.cbSize       = sizeof(SCROLLINFO);
3694                 si.fMask        = SIF_PAGE | SIF_POS | SIF_RANGE | SIF_DISABLENOSCROLL;
3695                 si.nMin         = 0;
3696                 si.nMax         = es->text_width + fw - 1;
3697                 si.nPage        = fw;
3698                 si.nPos         = es->x_offset;
3699                 SetScrollInfo(wnd->hwndSelf, SB_HORZ, &si, TRUE);
3700         }
3701
3702         if (es->flags & EF_UPDATE) {
3703                 es->flags &= ~EF_UPDATE;
3704                 EDIT_NOTIFY_PARENT(wnd, EN_CHANGE, "EN_CHANGE");
3705         }
3706 }
3707
3708
3709 /*********************************************************************
3710  *
3711  *      WM_PASTE
3712  *
3713  */
3714 static void EDIT_WM_Paste(WND *wnd, EDITSTATE *es)
3715 {
3716         HGLOBAL hsrc;
3717         LPSTR src;
3718
3719         OpenClipboard(wnd->hwndSelf);
3720         if ((hsrc = GetClipboardData(CF_TEXT))) {
3721                 src = (LPSTR)GlobalLock(hsrc);
3722                 EDIT_EM_ReplaceSel(wnd, es, TRUE, src);
3723                 GlobalUnlock(hsrc);
3724         }
3725         CloseClipboard();
3726 }
3727
3728
3729 /*********************************************************************
3730  *
3731  *      WM_SETFOCUS
3732  *
3733  */
3734 static void EDIT_WM_SetFocus(WND *wnd, EDITSTATE *es, HWND window_losing_focus)
3735 {
3736         es->flags |= EF_FOCUSED;
3737         CreateCaret(wnd->hwndSelf, 0, 2, es->line_height);
3738         EDIT_SetCaretPos(wnd, es, es->selection_end,
3739                          es->flags & EF_AFTER_WRAP);
3740         if(!(es->style & ES_NOHIDESEL))
3741                 EDIT_InvalidateText(wnd, es, es->selection_start, es->selection_end);
3742         ShowCaret(wnd->hwndSelf);
3743         EDIT_NOTIFY_PARENT(wnd, EN_SETFOCUS, "EN_SETFOCUS");
3744 }
3745
3746
3747 /*********************************************************************
3748  *
3749  *      WM_SETFONT
3750  *
3751  * With Win95 look the margins are set to default font value unless
3752  * the system font (font == 0) is being set, in which case they are left
3753  * unchanged.
3754  *
3755  */
3756 static void EDIT_WM_SetFont(WND *wnd, EDITSTATE *es, HFONT font, BOOL redraw)
3757 {
3758         TEXTMETRICA tm;
3759         HDC dc;
3760         HFONT old_font = 0;
3761
3762         es->font = font;
3763         dc = GetDC(wnd->hwndSelf);
3764         if (font)
3765                 old_font = SelectObject(dc, font);
3766         GetTextMetricsA(dc, &tm);
3767         es->line_height = tm.tmHeight;
3768         es->char_width = tm.tmAveCharWidth;
3769         if (font)
3770                 SelectObject(dc, old_font);
3771         ReleaseDC(wnd->hwndSelf, dc);
3772         if (font && (TWEAK_WineLook > WIN31_LOOK))
3773                 EDIT_EM_SetMargins(wnd, es, EC_LEFTMARGIN | EC_RIGHTMARGIN,
3774                                    EC_USEFONTINFO, EC_USEFONTINFO);
3775         if (es->style & ES_MULTILINE)
3776                 EDIT_BuildLineDefs_ML(wnd, es);
3777         else {
3778                 RECT r;
3779                 GetClientRect(wnd->hwndSelf, &r);
3780                 EDIT_SetRectNP(wnd, es, &r);
3781         }
3782         if (redraw)
3783                 InvalidateRect(wnd->hwndSelf, NULL, TRUE);
3784         if (es->flags & EF_FOCUSED) {
3785                 DestroyCaret();
3786                 CreateCaret(wnd->hwndSelf, 0, 2, es->line_height);
3787                 EDIT_SetCaretPos(wnd, es, es->selection_end,
3788                                  es->flags & EF_AFTER_WRAP);
3789                 ShowCaret(wnd->hwndSelf);
3790         }
3791 }
3792
3793
3794 /*********************************************************************
3795  *
3796  *      WM_SETTEXT
3797  *
3798  * NOTES
3799  *  For multiline controls (ES_MULTILINE), reception of WM_SETTEXT triggers:
3800  *  The modified flag is reset. No notifications are sent.
3801  *
3802  *  For single-line controls, reception of WM_SETTEXT triggers:
3803  *  The modified flag is reset. EN_UPDATE and EN_CHANGE notifications are sent.
3804  *
3805  */
3806 static void EDIT_WM_SetText(WND *wnd, EDITSTATE *es, LPCSTR text)
3807 {
3808         EDIT_EM_SetSel(wnd, es, 0, -1, FALSE);
3809         if (text) {
3810                 TRACE(edit, "\t'%s'\n", text);
3811                 EDIT_EM_ReplaceSel(wnd, es, FALSE, text);
3812         } else {
3813                 TRACE(edit, "\t<NULL>\n");
3814                 EDIT_EM_ReplaceSel(wnd, es, FALSE, "");
3815         }
3816         es->x_offset = 0;
3817         if (es->style & ES_MULTILINE) {
3818                 es->flags &= ~EF_UPDATE;
3819         } else {
3820                 es->flags |= EF_UPDATE;
3821         }
3822         es->flags &= ~EF_MODIFIED;
3823         EDIT_EM_SetSel(wnd, es, 0, 0, FALSE);
3824         EDIT_EM_ScrollCaret(wnd, es);
3825 }
3826
3827
3828 /*********************************************************************
3829  *
3830  *      WM_SIZE
3831  *
3832  */
3833 static void EDIT_WM_Size(WND *wnd, EDITSTATE *es, UINT action, INT width, INT height)
3834 {
3835         if ((action == SIZE_MAXIMIZED) || (action == SIZE_RESTORED)) {
3836                 RECT rc;
3837                 SetRect(&rc, 0, 0, width, height);
3838                 EDIT_SetRectNP(wnd, es, &rc);
3839                 InvalidateRect(wnd->hwndSelf, NULL, TRUE);
3840         }
3841 }
3842
3843
3844 /*********************************************************************
3845  *
3846  *      WM_SYSKEYDOWN
3847  *
3848  */
3849 static LRESULT EDIT_WM_SysKeyDown(WND *wnd, EDITSTATE *es, INT key, DWORD key_data)
3850 {
3851         if ((key == VK_BACK) && (key_data & 0x2000)) {
3852                 if (EDIT_EM_CanUndo(wnd, es))
3853                         EDIT_EM_Undo(wnd, es);
3854                 return 0;
3855         } else if (key == VK_UP || key == VK_DOWN)
3856                 if (EDIT_CheckCombo(wnd, WM_SYSKEYDOWN, key, key_data))
3857                         return 0;
3858         return DefWindowProcA(wnd->hwndSelf, WM_SYSKEYDOWN, (WPARAM)key, (LPARAM)key_data);
3859 }
3860
3861
3862 /*********************************************************************
3863  *
3864  *      WM_TIMER
3865  *
3866  */
3867 static void EDIT_WM_Timer(WND *wnd, EDITSTATE *es, INT id, TIMERPROC timer_proc)
3868 {
3869         if (es->region_posx < 0) {
3870                 EDIT_MoveBackward(wnd, es, TRUE);
3871         } else if (es->region_posx > 0) {
3872                 EDIT_MoveForward(wnd, es, TRUE);
3873         }
3874 /*
3875  *      FIXME: gotta do some vertical scrolling here, like
3876  *              EDIT_EM_LineScroll(wnd, 0, 1);
3877  */
3878 }
3879
3880
3881 /*********************************************************************
3882  *
3883  *      EDIT_VScroll_Hack
3884  *
3885  *      16 bit notepad needs this.  Actually it is not _our_ hack,
3886  *      it is notepad's.  Notepad is sending us scrollbar messages with
3887  *      undocumented parameters without us even having a scrollbar ... !?!?
3888  *
3889  */
3890 static LRESULT EDIT_VScroll_Hack(WND *wnd, EDITSTATE *es, INT action, INT pos, HWND scroll_bar)
3891 {
3892         INT dy = 0;
3893         LRESULT ret = 0;
3894
3895         if (!(es->flags & EF_VSCROLL_HACK)) {
3896                 ERR(edit, "hacked WM_VSCROLL handler invoked\n");
3897                 ERR(edit, "      if you are _not_ running 16 bit notepad, please report\n");
3898                 ERR(edit, "      (this message is only displayed once per edit control)\n");
3899                 es->flags |= EF_VSCROLL_HACK;
3900         }
3901
3902         switch (action) {
3903         case SB_LINEUP:
3904         case SB_LINEDOWN:
3905         case SB_PAGEUP:
3906         case SB_PAGEDOWN:
3907                 EDIT_EM_Scroll(wnd, es, action);
3908                 return 0;
3909         case SB_TOP:
3910                 dy = -es->y_offset;
3911                 break;
3912         case SB_BOTTOM:
3913                 dy = es->line_count - 1 - es->y_offset;
3914                 break;
3915         case SB_THUMBTRACK:
3916                 es->flags |= EF_VSCROLL_TRACK;
3917                 dy = (pos * (es->line_count - 1) + 50) / 100 - es->y_offset;
3918                 break;
3919         case SB_THUMBPOSITION:
3920                 es->flags &= ~EF_VSCROLL_TRACK;
3921                 if (!(dy = (pos * (es->line_count - 1) + 50) / 100 - es->y_offset))
3922                         EDIT_NOTIFY_PARENT(wnd, EN_VSCROLL, "EN_VSCROLL");
3923                 break;
3924         case SB_ENDSCROLL:
3925                 break;
3926
3927         /*
3928          *      FIXME : the next two are undocumented !
3929          *      Are we doing the right thing ?
3930          *      At least Win 3.1 Notepad makes use of EM_GETTHUMB this way,
3931          *      although it's also a regular control message.
3932          */
3933         case EM_GETTHUMB16:
3934                 ret = (es->line_count > 1) ? es->y_offset * 100 / (es->line_count - 1) : 0;
3935                 break;
3936         case EM_LINESCROLL16:
3937                 dy = pos;
3938                 break;
3939
3940         default:
3941                 ERR(edit, "undocumented (hacked) WM_VSCROLL parameter, please report\n");
3942                 return 0;
3943         }
3944         if (dy)
3945                 EDIT_EM_LineScroll(wnd, es, 0, dy);
3946         return ret;
3947 }
3948
3949
3950 /*********************************************************************
3951  *
3952  *      WM_VSCROLL
3953  *
3954  */
3955 static LRESULT EDIT_WM_VScroll(WND *wnd, EDITSTATE *es, INT action, INT pos, HWND scroll_bar)
3956 {
3957         INT dy;
3958
3959         if (!(es->style & ES_MULTILINE))
3960                 return 0;
3961
3962         if (!(es->style & ES_AUTOVSCROLL))
3963                 return 0;
3964
3965         if (!(es->style & WS_VSCROLL))
3966                 return EDIT_VScroll_Hack(wnd, es, action, pos, scroll_bar);
3967
3968         dy = 0;
3969         switch (action) {
3970         case SB_LINEUP:
3971         case SB_LINEDOWN:
3972         case SB_PAGEUP:
3973         case SB_PAGEDOWN:
3974                 EDIT_EM_Scroll(wnd, es, action);
3975                 return 0;
3976
3977         case SB_TOP:
3978                 dy = -es->y_offset;
3979                 break;
3980         case SB_BOTTOM:
3981                 dy = es->line_count - 1 - es->y_offset;
3982                 break;
3983         case SB_THUMBTRACK:
3984                 es->flags |= EF_VSCROLL_TRACK;
3985                 dy = pos - es->y_offset;
3986                 break;
3987         case SB_THUMBPOSITION:
3988                 es->flags &= ~EF_VSCROLL_TRACK;
3989                 if (!(dy = pos - es->y_offset)) {
3990                         SetScrollPos(wnd->hwndSelf, SB_VERT, pos, TRUE);
3991                         EDIT_NOTIFY_PARENT(wnd, EN_VSCROLL, "EN_VSCROLL");
3992                 }
3993                 break;
3994         case SB_ENDSCROLL:
3995                 break;
3996
3997         default:
3998                 ERR(edit, "undocumented WM_VSCROLL action %d, please report\n",
3999                         action);
4000                 return 0;
4001         }
4002         if (dy)
4003                 EDIT_EM_LineScroll(wnd, es, 0, dy);
4004         return 0;
4005 }