git.oblomov.eu Git - wine/blob - dlls/user/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  * This library is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU Lesser General Public
  11  * License as published by the Free Software Foundation; either
  12  * version 2.1 of the License, or (at your option) any later version.
  13  *
  14  * This library is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17  * Lesser General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU Lesser General Public
  20  * License along with this library; if not, write to the Free Software
  21  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  22  *
  23  * NOTES
  24  *
  25  * This code was audited for completeness against the documented features
  26  * of Comctl32.dll version 6.0 on Oct. 8, 2004, by Dimitrie O. Paun.
  27  *
  28  * Unless otherwise noted, we believe this code to be complete, as per
  29  * the specification mentioned above.
  30  * If you discover missing features, or bugs, please note them below.
  31  *
  32  * TODO:
  33  *   - EDITBALLOONTIP structure
  34  *   - EM_GETCUEBANNER/Edit_GetCueBannerText
  35  *   - EM_HIDEBALLOONTIP/Edit_HideBalloonTip
  36  *   - EM_SETCUEBANNER/Edit_SetCueBannerText
  37  *   - EM_SHOWBALLOONTIP/Edit_ShowBalloonTip
  38  *   - EM_GETIMESTATUS, EM_SETIMESTATUS
  39  *   - EN_ALIGN_LTR_EC
  40  *   - EN_ALIGN_RTL_EC
  41  *   - ES_OEMCONVERT
  42  *
  43  */
  44
  45 #include "config.h"
  46
  47 #include <stdarg.h>
  48 #include <string.h>
  49 #include <stdlib.h>
  50
  51 #include "windef.h"
  52 #include "winbase.h"
  53 #include "winnt.h"
  54 #include "wownt32.h"
  55 #include "win.h"
  56 #include "wine/winbase16.h"
  57 #include "wine/winuser16.h"
  58 #include "wine/unicode.h"
  59 #include "controls.h"
  60 #include "user_private.h"
  61 #include "wine/debug.h"
  62
  63 WINE_DEFAULT_DEBUG_CHANNEL(edit);
  64 WINE_DECLARE_DEBUG_CHANNEL(combo);
  65 WINE_DECLARE_DEBUG_CHANNEL(relay);
  66
  67 #define BUFLIMIT_MULTI          65534   /* maximum buffer size (not including '\0')
  68                                            FIXME: BTW, new specs say 65535 (do you dare ???) */
  69 #define BUFLIMIT_SINGLE         32766   /* maximum buffer size (not including '\0') */
  70 #define GROWLENGTH              32      /* buffers granularity in bytes: must be power of 2 */
  71 #define ROUND_TO_GROW(size)     (((size) + (GROWLENGTH - 1)) & ~(GROWLENGTH - 1))
  72 #define HSCROLL_FRACTION        3       /* scroll window by 1/3 width */
  73
  74 /*
  75  *      extra flags for EDITSTATE.flags field
  76  */
  77 #define EF_MODIFIED             0x0001  /* text has been modified */
  78 #define EF_FOCUSED              0x0002  /* we have input focus */
  79 #define EF_UPDATE               0x0004  /* notify parent of changed state */
  80 #define EF_VSCROLL_TRACK        0x0008  /* don't SetScrollPos() since we are tracking the thumb */
  81 #define EF_HSCROLL_TRACK        0x0010  /* don't SetScrollPos() since we are tracking the thumb */
  82 #define EF_AFTER_WRAP           0x0080  /* the caret is displayed after the last character of a
  83                                            wrapped line, instead of in front of the next character */
  84 #define EF_USE_SOFTBRK          0x0100  /* Enable soft breaks in text. */
  85
  86 typedef enum
  87 {
  88         END_0 = 0,                      /* line ends with terminating '\0' character */
  89         END_WRAP,                       /* line is wrapped */
  90         END_HARD,                       /* line ends with a hard return '\r\n' */
  91         END_SOFT,                       /* line ends with a soft return '\r\r\n' */
  92         END_RICH                        /* line ends with a single '\n' */
  93 } LINE_END;
  94
  95 typedef struct tagLINEDEF {
  96         INT length;                     /* bruto length of a line in bytes */
  97         INT net_length;                 /* netto length of a line in visible characters */
  98         LINE_END ending;
  99         INT width;                      /* width of the line in pixels */
 100         INT index;                      /* line index into the buffer */
 101         struct tagLINEDEF *next;
 102 } LINEDEF;
 103
 104 typedef struct
 105 {
 106         BOOL is_unicode;                /* how the control was created */
 107         LPWSTR text;                    /* the actual contents of the control */
 108         UINT buffer_size;               /* the size of the buffer in characters */
 109         UINT buffer_limit;              /* the maximum size to which the buffer may grow in characters */
 110         HFONT font;                     /* NULL means standard system font */
 111         INT x_offset;                   /* scroll offset        for multi lines this is in pixels
 112                                                                 for single lines it's in characters */
 113         INT line_height;                /* height of a screen line in pixels */
 114         INT char_width;                 /* average character width in pixels */
 115         DWORD style;                    /* sane version of wnd->dwStyle */
 116         WORD flags;                     /* flags that are not in es->style or wnd->flags (EF_XXX) */
 117         INT undo_insert_count;          /* number of characters inserted in sequence */
 118         UINT undo_position;             /* character index of the insertion and deletion */
 119         LPWSTR undo_text;               /* deleted text */
 120         UINT undo_buffer_size;          /* size of the deleted text buffer */
 121         INT selection_start;            /* == selection_end if no selection */
 122         INT selection_end;              /* == current caret position */
 123         WCHAR password_char;            /* == 0 if no password char, and for multi line controls */
 124         INT left_margin;                /* in pixels */
 125         INT right_margin;               /* in pixels */
 126         RECT format_rect;
 127         INT text_width;                 /* width of the widest line in pixels for multi line controls
 128                                            and just line width for single line controls */
 129         INT region_posx;                /* Position of cursor relative to region: */
 130         INT region_posy;                /* -1: to left, 0: within, 1: to right */
 131         EDITWORDBREAKPROC16 word_break_proc16;
 132         void *word_break_proc;          /* 32-bit word break proc: ANSI or Unicode */
 133         INT line_count;                 /* number of lines */
 134         INT y_offset;                   /* scroll offset in number of lines */
 135         BOOL bCaptureState;             /* flag indicating whether mouse was captured */
 136         BOOL bEnableState;              /* flag keeping the enable state */
 137         HWND hwndSelf;                  /* the our window handle */
 138         HWND hwndParent;                /* Handle of parent for sending EN_* messages.
 139                                            Even if parent will change, EN_* messages
 140                                            should be sent to the first parent. */
 141         HWND hwndListBox;               /* handle of ComboBox's listbox or NULL */
 142         /*
 143          *      only for multi line controls
 144          */
 145         INT lock_count;                 /* amount of re-entries in the EditWndProc */
 146         INT tabs_count;
 147         LPINT tabs;
 148         LINEDEF *first_line_def;        /* linked list of (soft) linebreaks */
 149         HLOCAL hloc32W;                 /* our unicode local memory block */
 150         HLOCAL16 hloc16;                /* alias for 16-bit control receiving EM_GETHANDLE16
 151                                            or EM_SETHANDLE16 */
 152         HLOCAL hloc32A;                 /* alias for ANSI control receiving EM_GETHANDLE
 153                                            or EM_SETHANDLE */
 154 } EDITSTATE;
 155
 156
 157 #define SWAP_UINT32(x,y) do { UINT temp = (UINT)(x); (x) = (UINT)(y); (y) = temp; } while(0)
 158 #define ORDER_UINT(x,y) do { if ((UINT)(y) < (UINT)(x)) SWAP_UINT32((x),(y)); } while(0)
 159
 160 /* used for disabled or read-only edit control */
 161 #define EDIT_NOTIFY_PARENT(es, wNotifyCode) \
 162         do \
 163         { /* Notify parent which has created this edit control */ \
 164             TRACE("notification " #wNotifyCode " sent to hwnd=%p\n", es->hwndParent); \
 165             SendMessageW(es->hwndParent, WM_COMMAND, \
 166                      MAKEWPARAM(GetWindowLongPtrW((es->hwndSelf),GWLP_ID), wNotifyCode), \
 167                      (LPARAM)(es->hwndSelf)); \
 168         } while(0)
 169
 170 /*********************************************************************
 171  *
 172  *      Declarations
 173  *
 174  */
 175
 176 /*
 177  *      These functions have trivial implementations
 178  *      We still like to call them internally
 179  *      "static inline" makes them more like macro's
 180  */
 181 static inline BOOL      EDIT_EM_CanUndo(EDITSTATE *es);
 182 static inline void      EDIT_EM_EmptyUndoBuffer(EDITSTATE *es);
 183 static inline void      EDIT_WM_Clear(EDITSTATE *es);
 184 static inline void      EDIT_WM_Cut(EDITSTATE *es);
 185
 186 /*
 187  *      Helper functions only valid for one type of control
 188  */
 189 static void     EDIT_BuildLineDefs_ML(EDITSTATE *es, INT iStart, INT iEnd, INT delta, HRGN hrgn);
 190 static void     EDIT_CalcLineWidth_SL(EDITSTATE *es);
 191 static LPWSTR   EDIT_GetPasswordPointer_SL(EDITSTATE *es);
 192 static void     EDIT_MoveDown_ML(EDITSTATE *es, BOOL extend);
 193 static void     EDIT_MovePageDown_ML(EDITSTATE *es, BOOL extend);
 194 static void     EDIT_MovePageUp_ML(EDITSTATE *es, BOOL extend);
 195 static void     EDIT_MoveUp_ML(EDITSTATE *es, BOOL extend);
 196 /*
 197  *      Helper functions valid for both single line _and_ multi line controls
 198  */
 199 static INT      EDIT_CallWordBreakProc(EDITSTATE *es, INT start, INT index, INT count, INT action);
 200 static INT      EDIT_CharFromPos(EDITSTATE *es, INT x, INT y, LPBOOL after_wrap);
 201 static void     EDIT_ConfinePoint(EDITSTATE *es, LPINT x, LPINT y);
 202 static void     EDIT_GetLineRect(EDITSTATE *es, INT line, INT scol, INT ecol, LPRECT rc);
 203 static void     EDIT_InvalidateText(EDITSTATE *es, INT start, INT end);
 204 static void     EDIT_LockBuffer(EDITSTATE *es);
 205 static BOOL     EDIT_MakeFit(EDITSTATE *es, UINT size);
 206 static BOOL     EDIT_MakeUndoFit(EDITSTATE *es, UINT size);
 207 static void     EDIT_MoveBackward(EDITSTATE *es, BOOL extend);
 208 static void     EDIT_MoveEnd(EDITSTATE *es, BOOL extend);
 209 static void     EDIT_MoveForward(EDITSTATE *es, BOOL extend);
 210 static void     EDIT_MoveHome(EDITSTATE *es, BOOL extend);
 211 static void     EDIT_MoveWordBackward(EDITSTATE *es, BOOL extend);
 212 static void     EDIT_MoveWordForward(EDITSTATE *es, BOOL extend);
 213 static void     EDIT_PaintLine(EDITSTATE *es, HDC hdc, INT line, BOOL rev);
 214 static INT      EDIT_PaintText(EDITSTATE *es, HDC hdc, INT x, INT y, INT line, INT col, INT count, BOOL rev);
 215 static void     EDIT_SetCaretPos(EDITSTATE *es, INT pos, BOOL after_wrap);
 216 static void     EDIT_AdjustFormatRect(EDITSTATE *es);
 217 static void     EDIT_SetRectNP(EDITSTATE *es, LPRECT lprc);
 218 static void     EDIT_UnlockBuffer(EDITSTATE *es, BOOL force);
 219 static void     EDIT_UpdateScrollInfo(EDITSTATE *es);
 220 static INT CALLBACK EDIT_WordBreakProc(LPWSTR s, INT index, INT count, INT action);
 221 /*
 222  *      EM_XXX message handlers
 223  */
 224 static LRESULT  EDIT_EM_CharFromPos(EDITSTATE *es, INT x, INT y);
 225 static BOOL     EDIT_EM_FmtLines(EDITSTATE *es, BOOL add_eol);
 226 static HLOCAL   EDIT_EM_GetHandle(EDITSTATE *es);
 227 static HLOCAL16 EDIT_EM_GetHandle16(EDITSTATE *es);
 228 static INT      EDIT_EM_GetLine(EDITSTATE *es, INT line, LPWSTR dst, BOOL unicode);
 229 static LRESULT  EDIT_EM_GetSel(EDITSTATE *es, PUINT start, PUINT end);
 230 static LRESULT  EDIT_EM_GetThumb(EDITSTATE *es);
 231 static INT      EDIT_EM_LineFromChar(EDITSTATE *es, INT index);
 232 static INT      EDIT_EM_LineIndex(EDITSTATE *es, INT line);
 233 static INT      EDIT_EM_LineLength(EDITSTATE *es, INT index);
 234 static BOOL     EDIT_EM_LineScroll(EDITSTATE *es, INT dx, INT dy);
 235 static BOOL     EDIT_EM_LineScroll_internal(EDITSTATE *es, INT dx, INT dy);
 236 static LRESULT  EDIT_EM_PosFromChar(EDITSTATE *es, INT index, BOOL after_wrap);
 237 static void     EDIT_EM_ReplaceSel(EDITSTATE *es, BOOL can_undo, LPCWSTR lpsz_replace, BOOL send_update, BOOL honor_limit);
 238 static LRESULT  EDIT_EM_Scroll(EDITSTATE *es, INT action);
 239 static void     EDIT_EM_ScrollCaret(EDITSTATE *es);
 240 static void     EDIT_EM_SetHandle(EDITSTATE *es, HLOCAL hloc);
 241 static void     EDIT_EM_SetHandle16(EDITSTATE *es, HLOCAL16 hloc);
 242 static void     EDIT_EM_SetLimitText(EDITSTATE *es, INT limit);
 243 static void     EDIT_EM_SetMargins(EDITSTATE *es, INT action, INT left, INT right, BOOL repaint);
 244 static void     EDIT_EM_SetPasswordChar(EDITSTATE *es, WCHAR c);
 245 static void     EDIT_EM_SetSel(EDITSTATE *es, UINT start, UINT end, BOOL after_wrap);
 246 static BOOL     EDIT_EM_SetTabStops(EDITSTATE *es, INT count, LPINT tabs);
 247 static BOOL     EDIT_EM_SetTabStops16(EDITSTATE *es, INT count, LPINT16 tabs);
 248 static void     EDIT_EM_SetWordBreakProc(EDITSTATE *es, void *wbp);
 249 static void     EDIT_EM_SetWordBreakProc16(EDITSTATE *es, EDITWORDBREAKPROC16 wbp);
 250 static BOOL     EDIT_EM_Undo(EDITSTATE *es);
 251 /*
 252  *      WM_XXX message handlers
 253  */
 254 static void     EDIT_WM_Char(EDITSTATE *es, WCHAR c);
 255 static void     EDIT_WM_Command(EDITSTATE *es, INT code, INT id, HWND conrtol);
 256 static void     EDIT_WM_ContextMenu(EDITSTATE *es, INT x, INT y);
 257 static void     EDIT_WM_Copy(EDITSTATE *es);
 258 static LRESULT  EDIT_WM_Create(EDITSTATE *es, LPCWSTR name);
 259 static LRESULT  EDIT_WM_Destroy(EDITSTATE *es);
 260 static LRESULT  EDIT_WM_EraseBkGnd(EDITSTATE *es, HDC dc);
 261 static INT      EDIT_WM_GetText(EDITSTATE *es, INT count, LPWSTR dst, BOOL unicode);
 262 static LRESULT  EDIT_WM_HScroll(EDITSTATE *es, INT action, INT pos);
 263 static LRESULT  EDIT_WM_KeyDown(EDITSTATE *es, INT key);
 264 static LRESULT  EDIT_WM_KillFocus(EDITSTATE *es);
 265 static LRESULT  EDIT_WM_LButtonDblClk(EDITSTATE *es);
 266 static LRESULT  EDIT_WM_LButtonDown(EDITSTATE *es, DWORD keys, INT x, INT y);
 267 static LRESULT  EDIT_WM_LButtonUp(EDITSTATE *es);
 268 static LRESULT  EDIT_WM_MButtonDown(EDITSTATE *es);
 269 static LRESULT  EDIT_WM_MouseMove(EDITSTATE *es, INT x, INT y);
 270 static LRESULT  EDIT_WM_NCCreate(HWND hwnd, LPCREATESTRUCTW lpcs, BOOL unicode);
 271 static void     EDIT_WM_Paint(EDITSTATE *es, HDC hdc);
 272 static void     EDIT_WM_Paste(EDITSTATE *es);
 273 static void     EDIT_WM_SetFocus(EDITSTATE *es);
 274 static void     EDIT_WM_SetFont(EDITSTATE *es, HFONT font, BOOL redraw);
 275 static void     EDIT_WM_SetText(EDITSTATE *es, LPCWSTR text, BOOL unicode);
 276 static void     EDIT_WM_Size(EDITSTATE *es, UINT action, INT width, INT height);
 277 static LRESULT  EDIT_WM_StyleChanged(EDITSTATE *es, WPARAM which, const STYLESTRUCT *style);
 278 static LRESULT  EDIT_WM_SysKeyDown(EDITSTATE *es, INT key, DWORD key_data);
 279 static void     EDIT_WM_Timer(EDITSTATE *es);
 280 static LRESULT  EDIT_WM_VScroll(EDITSTATE *es, INT action, INT pos);
 281 static void     EDIT_UpdateText(EDITSTATE *es, LPRECT rc, BOOL bErase);
 282 static void     EDIT_UpdateTextRegion(EDITSTATE *es, HRGN hrgn, BOOL bErase);
 283
 284 LRESULT WINAPI EditWndProcA(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
 285 LRESULT WINAPI EditWndProcW(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
 286
 287 /*********************************************************************
 288  * edit class descriptor
 289  */
 290 const struct builtin_class_descr EDIT_builtin_class =
 291 {
 292     "Edit",               /* name */
 293     CS_DBLCLKS | CS_PARENTDC,   /* style */
 294     EditWndProcA,         /* procA */
 295     EditWndProcW,         /* procW */
 296     sizeof(EDITSTATE *),  /* extra */
 297     IDC_IBEAM,            /* cursor */
 298     0                     /* brush */
 299 };
 300
 301
 302 /*********************************************************************
 303  *
 304  *      EM_CANUNDO
 305  *
 306  */
 307 static inline BOOL EDIT_EM_CanUndo(EDITSTATE *es)
 308 {
 309         return (es->undo_insert_count || strlenW(es->undo_text));
 310 }
 311
 312
 313 /*********************************************************************
 314  *
 315  *      EM_EMPTYUNDOBUFFER
 316  *
 317  */
 318 static inline void EDIT_EM_EmptyUndoBuffer(EDITSTATE *es)
 319 {
 320         es->undo_insert_count = 0;
 321         *es->undo_text = '\0';
 322 }
 323
 324
 325 /*********************************************************************
 326  *
 327  *      WM_CLEAR
 328  *
 329  */
 330 static inline void EDIT_WM_Clear(EDITSTATE *es)
 331 {
 332         static const WCHAR empty_stringW[] = {0};
 333
 334         /* Protect read-only edit control from modification */
 335         if(es->style & ES_READONLY)
 336             return;
 337
 338         EDIT_EM_ReplaceSel(es, TRUE, empty_stringW, TRUE, TRUE);
 339 }
 340
 341
 342 /*********************************************************************
 343  *
 344  *      WM_CUT
 345  *
 346  */
 347 static inline void EDIT_WM_Cut(EDITSTATE *es)
 348 {
 349         EDIT_WM_Copy(es);
 350         EDIT_WM_Clear(es);
 351 }
 352
 353
 354 /**********************************************************************
 355  *         get_app_version
 356  *
 357  * Returns the window version in case Wine emulates a later version
 358  * of windows than the application expects.
 359  *
 360  * In a number of cases when windows runs an application that was
 361  * designed for an earlier windows version, windows reverts
 362  * to "old" behaviour of that earlier version.
 363  *
 364  * An example is a disabled  edit control that needs to be painted.
 365  * Old style behaviour is to send a WM_CTLCOLOREDIT message. This was
 366  * changed in Win95, NT4.0 by a WM_CTLCOLORSTATIC message _only_ for
 367  * applications with an expected version 0f 4.0 or higher.
 368  *
 369  */
 370 static DWORD get_app_version(void)
 371 {
 372     static DWORD version;
 373     if (!version)
 374     {
 375         DWORD dwEmulatedVersion;
 376         OSVERSIONINFOW info;
 377         DWORD dwProcVersion = GetProcessVersion(0);
 378
 379         info.dwOSVersionInfoSize = sizeof(OSVERSIONINFOW);
 380         GetVersionExW( &info );
 381         dwEmulatedVersion = MAKELONG( info.dwMinorVersion, info.dwMajorVersion );
 382         /* FIXME: this may not be 100% correct; see discussion on the
 383          * wine developer list in Nov 1999 */
 384         version = dwProcVersion < dwEmulatedVersion ? dwProcVersion : dwEmulatedVersion;
 385     }
 386     return version;
 387 }
 388
 389
 390 static HBRUSH EDIT_NotifyCtlColor(EDITSTATE *es, HDC hdc)
 391 {
 392         UINT msg;
 393
 394         if ( get_app_version() >= 0x40000 && (!es->bEnableState || (es->style & ES_READONLY)))
 395                 msg = WM_CTLCOLORSTATIC;
 396         else
 397                 msg = WM_CTLCOLOREDIT;
 398
 399         /* why do we notify to es->hwndParent, and we send this one to GetParent()? */
 400         return (HBRUSH)SendMessageW(GetParent(es->hwndSelf), msg, (WPARAM)hdc, (LPARAM)es->hwndSelf);
 401 }
 402
 403 static inline LRESULT DefWindowProcT(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam, BOOL unicode)
 404 {
 405         if(unicode)
 406                 return DefWindowProcW(hwnd, msg, wParam, lParam);
 407         else
 408                 return DefWindowProcA(hwnd, msg, wParam, lParam);
 409 }
 410
 411 /*********************************************************************
 412  *
 413  *      EditWndProc_common
 414  *
 415  *      The messages are in the order of the actual integer values
 416  *      (which can be found in include/windows.h)
 417  *      Wherever possible the 16 bit versions are converted to
 418  *      the 32 bit ones, so that we can 'fall through' to the
 419  *      helper functions.  These are mostly 32 bit (with a few
 420  *      exceptions, clearly indicated by a '16' extension to their
 421  *      names).
 422  *
 423  */
 424 static LRESULT WINAPI EditWndProc_common( HWND hwnd, UINT msg,
 425                                           WPARAM wParam, LPARAM lParam, BOOL unicode )
 426 {
 427         EDITSTATE *es = (EDITSTATE *)GetWindowLongW( hwnd, 0 );
 428         LRESULT result = 0;
 429
 430         TRACE("hwnd=%p msg=%x (%s) wparam=%x lparam=%lx\n", hwnd, msg, SPY_GetMsgName(msg, hwnd), wParam, lParam);
 431
 432         if (!es && msg != WM_NCCREATE)
 433                 return DefWindowProcT(hwnd, msg, wParam, lParam, unicode);
 434
 435         if (es && (msg != WM_DESTROY)) EDIT_LockBuffer(es);
 436
 437         switch (msg) {
 438         case EM_GETSEL16:
 439                 wParam = 0;
 440                 lParam = 0;
 441                 /* fall through */
 442         case EM_GETSEL:
 443                 result = EDIT_EM_GetSel(es, (PUINT)wParam, (PUINT)lParam);
 444                 break;
 445
 446         case EM_SETSEL16:
 447                 if ((short)LOWORD(lParam) == -1)
 448                         EDIT_EM_SetSel(es, (UINT)-1, 0, FALSE);
 449                 else
 450                         EDIT_EM_SetSel(es, LOWORD(lParam), HIWORD(lParam), FALSE);
 451                 if (!wParam)
 452                         EDIT_EM_ScrollCaret(es);
 453                 result = 1;
 454                 break;
 455         case EM_SETSEL:
 456                 EDIT_EM_SetSel(es, wParam, lParam, FALSE);
 457                 EDIT_EM_ScrollCaret(es);
 458                 result = 1;
 459                 break;
 460
 461         case EM_GETRECT16:
 462                 if (lParam)
 463                 {
 464                     RECT16 *r16 = MapSL(lParam);
 465                     r16->left   = es->format_rect.left;
 466                     r16->top    = es->format_rect.top;
 467                     r16->right  = es->format_rect.right;
 468                     r16->bottom = es->format_rect.bottom;
 469                 }
 470                 break;
 471         case EM_GETRECT:
 472                 if (lParam)
 473                         CopyRect((LPRECT)lParam, &es->format_rect);
 474                 break;
 475
 476         case EM_SETRECT16:
 477                 if ((es->style & ES_MULTILINE) && lParam) {
 478                         RECT rc;
 479                         RECT16 *r16 = MapSL(lParam);
 480                         rc.left   = r16->left;
 481                         rc.top    = r16->top;
 482                         rc.right  = r16->right;
 483                         rc.bottom = r16->bottom;
 484                         EDIT_SetRectNP(es, &rc);
 485                         EDIT_UpdateText(es, NULL, TRUE);
 486                 }
 487                 break;
 488         case EM_SETRECT:
 489                 if ((es->style & ES_MULTILINE) && lParam) {
 490                         EDIT_SetRectNP(es, (LPRECT)lParam);
 491                         EDIT_UpdateText(es, NULL, TRUE);
 492                 }
 493                 break;
 494
 495         case EM_SETRECTNP16:
 496                 if ((es->style & ES_MULTILINE) && lParam) {
 497                         RECT rc;
 498                         RECT16 *r16 = MapSL(lParam);
 499                         rc.left   = r16->left;
 500                         rc.top    = r16->top;
 501                         rc.right  = r16->right;
 502                         rc.bottom = r16->bottom;
 503                         EDIT_SetRectNP(es, &rc);
 504                 }
 505                 break;
 506         case EM_SETRECTNP:
 507                 if ((es->style & ES_MULTILINE) && lParam)
 508                         EDIT_SetRectNP(es, (LPRECT)lParam);
 509                 break;
 510
 511         case EM_SCROLL16:
 512         case EM_SCROLL:
 513                 result = EDIT_EM_Scroll(es, (INT)wParam);
 514                 break;
 515
 516         case EM_LINESCROLL16:
 517                 wParam = (WPARAM)(INT)(SHORT)HIWORD(lParam);
 518                 lParam = (LPARAM)(INT)(SHORT)LOWORD(lParam);
 519                 /* fall through */
 520         case EM_LINESCROLL:
 521                 result = (LRESULT)EDIT_EM_LineScroll(es, (INT)wParam, (INT)lParam);
 522                 break;
 523
 524         case EM_SCROLLCARET16:
 525         case EM_SCROLLCARET:
 526                 EDIT_EM_ScrollCaret(es);
 527                 result = 1;
 528                 break;
 529
 530         case EM_GETMODIFY16:
 531         case EM_GETMODIFY:
 532                 result = ((es->flags & EF_MODIFIED) != 0);
 533                 break;
 534
 535         case EM_SETMODIFY16:
 536         case EM_SETMODIFY:
 537                 if (wParam)
 538                         es->flags |= EF_MODIFIED;
 539                 else
 540                         es->flags &= ~(EF_MODIFIED | EF_UPDATE);  /* reset pending updates */
 541                 break;
 542
 543         case EM_GETLINECOUNT16:
 544         case EM_GETLINECOUNT:
 545                 result = (es->style & ES_MULTILINE) ? es->line_count : 1;
 546                 break;
 547
 548         case EM_LINEINDEX16:
 549                 if ((INT16)wParam == -1)
 550                         wParam = (WPARAM)-1;
 551                 /* fall through */
 552         case EM_LINEINDEX:
 553                 result = (LRESULT)EDIT_EM_LineIndex(es, (INT)wParam);
 554                 break;
 555
 556         case EM_SETHANDLE16:
 557                 EDIT_EM_SetHandle16(es, (HLOCAL16)wParam);
 558                 break;
 559         case EM_SETHANDLE:
 560                 EDIT_EM_SetHandle(es, (HLOCAL)wParam);
 561                 break;
 562
 563         case EM_GETHANDLE16:
 564                 result = (LRESULT)EDIT_EM_GetHandle16(es);
 565                 break;
 566         case EM_GETHANDLE:
 567                 result = (LRESULT)EDIT_EM_GetHandle(es);
 568                 break;
 569
 570         case EM_GETTHUMB16:
 571         case EM_GETTHUMB:
 572                 result = EDIT_EM_GetThumb(es);
 573                 break;
 574
 575         /* these messages missing from specs */
 576         case WM_USER+15:
 577         case 0x00bf:
 578         case WM_USER+16:
 579         case 0x00c0:
 580         case WM_USER+19:
 581         case 0x00c3:
 582         case WM_USER+26:
 583         case 0x00ca:
 584                 FIXME("undocumented message 0x%x, please report\n", msg);
 585                 result = DefWindowProcW(hwnd, msg, wParam, lParam);
 586                 break;
 587
 588         case EM_LINELENGTH16:
 589         case EM_LINELENGTH:
 590                 result = (LRESULT)EDIT_EM_LineLength(es, (INT)wParam);
 591                 break;
 592
 593         case EM_REPLACESEL16:
 594                 lParam = (LPARAM)MapSL(lParam);
 595                 unicode = FALSE;  /* 16-bit message is always ascii */
 596                 /* fall through */
 597         case EM_REPLACESEL:
 598         {
 599                 LPWSTR textW;
 600
 601                 if(unicode)
 602                     textW = (LPWSTR)lParam;
 603                 else
 604                 {
 605                     LPSTR textA = (LPSTR)lParam;
 606                     INT countW = MultiByteToWideChar(CP_ACP, 0, textA, -1, NULL, 0);
 607                     if((textW = HeapAlloc(GetProcessHeap(), 0, countW * sizeof(WCHAR))))
 608                         MultiByteToWideChar(CP_ACP, 0, textA, -1, textW, countW);
 609                 }
 610
 611                 EDIT_EM_ReplaceSel(es, (BOOL)wParam, textW, TRUE, TRUE);
 612                 result = 1;
 613
 614                 if(!unicode)
 615                     HeapFree(GetProcessHeap(), 0, textW);
 616                 break;
 617         }
 618
 619         case EM_GETLINE16:
 620                 lParam = (LPARAM)MapSL(lParam);
 621                 unicode = FALSE;  /* 16-bit message is always ascii */
 622                 /* fall through */
 623         case EM_GETLINE:
 624                 result = (LRESULT)EDIT_EM_GetLine(es, (INT)wParam, (LPWSTR)lParam, unicode);
 625                 break;
 626
 627         case EM_LIMITTEXT16:
 628         case EM_SETLIMITTEXT:
 629                 EDIT_EM_SetLimitText(es, (INT)wParam);
 630                 break;
 631
 632         case EM_CANUNDO16:
 633         case EM_CANUNDO:
 634                 result = (LRESULT)EDIT_EM_CanUndo(es);
 635                 break;
 636
 637         case EM_UNDO16:
 638         case EM_UNDO:
 639         case WM_UNDO:
 640                 result = (LRESULT)EDIT_EM_Undo(es);
 641                 break;
 642
 643         case EM_FMTLINES16:
 644         case EM_FMTLINES:
 645                 result = (LRESULT)EDIT_EM_FmtLines(es, (BOOL)wParam);
 646                 break;
 647
 648         case EM_LINEFROMCHAR16:
 649         case EM_LINEFROMCHAR:
 650                 result = (LRESULT)EDIT_EM_LineFromChar(es, (INT)wParam);
 651                 break;
 652
 653         case EM_SETTABSTOPS16:
 654                 result = (LRESULT)EDIT_EM_SetTabStops16(es, (INT)wParam, MapSL(lParam));
 655                 break;
 656         case EM_SETTABSTOPS:
 657                 result = (LRESULT)EDIT_EM_SetTabStops(es, (INT)wParam, (LPINT)lParam);
 658                 break;
 659
 660         case EM_SETPASSWORDCHAR16:
 661                 unicode = FALSE;  /* 16-bit message is always ascii */
 662                 /* fall through */
 663         case EM_SETPASSWORDCHAR:
 664         {
 665                 WCHAR charW = 0;
 666
 667                 if(unicode)
 668                     charW = (WCHAR)wParam;
 669                 else
 670                 {
 671                     CHAR charA = wParam;
 672                     MultiByteToWideChar(CP_ACP, 0, &charA, 1, &charW, 1);
 673                 }
 674
 675                 EDIT_EM_SetPasswordChar(es, charW);
 676                 break;
 677         }
 678
 679         case EM_EMPTYUNDOBUFFER16:
 680         case EM_EMPTYUNDOBUFFER:
 681                 EDIT_EM_EmptyUndoBuffer(es);
 682                 break;
 683
 684         case EM_GETFIRSTVISIBLELINE16:
 685                 result = es->y_offset;
 686                 break;
 687         case EM_GETFIRSTVISIBLELINE:
 688                 result = (es->style & ES_MULTILINE) ? es->y_offset : es->x_offset;
 689                 break;
 690
 691         case EM_SETREADONLY16:
 692         case EM_SETREADONLY:
 693                 if (wParam) {
 694                     SetWindowLongW( hwnd, GWL_STYLE,
 695                                     GetWindowLongW( hwnd, GWL_STYLE ) | ES_READONLY );
 696                     es->style |= ES_READONLY;
 697                 } else {
 698                     SetWindowLongW( hwnd, GWL_STYLE,
 699                                     GetWindowLongW( hwnd, GWL_STYLE ) & ~ES_READONLY );
 700                     es->style &= ~ES_READONLY;
 701                 }
 702                 result = 1;
 703                 break;
 704
 705         case EM_SETWORDBREAKPROC16:
 706                 EDIT_EM_SetWordBreakProc16(es, (EDITWORDBREAKPROC16)lParam);
 707                 break;
 708         case EM_SETWORDBREAKPROC:
 709                 EDIT_EM_SetWordBreakProc(es, (void *)lParam);
 710                 break;
 711
 712         case EM_GETWORDBREAKPROC16:
 713                 result = (LRESULT)es->word_break_proc16;
 714                 break;
 715         case EM_GETWORDBREAKPROC:
 716                 result = (LRESULT)es->word_break_proc;
 717                 break;
 718
 719         case EM_GETPASSWORDCHAR16:
 720                 unicode = FALSE;  /* 16-bit message is always ascii */
 721                 /* fall through */
 722         case EM_GETPASSWORDCHAR:
 723         {
 724                 if(unicode)
 725                     result = es->password_char;
 726                 else
 727                 {
 728                     WCHAR charW = es->password_char;
 729                     CHAR charA = 0;
 730                     WideCharToMultiByte(CP_ACP, 0, &charW, 1, &charA, 1, NULL, NULL);
 731                     result = charA;
 732                 }
 733                 break;
 734         }
 735
 736         /* The following EM_xxx are new to win95 and don't exist for 16 bit */
 737
 738         case EM_SETMARGINS:
 739                 EDIT_EM_SetMargins(es, (INT)wParam, (short)LOWORD(lParam), (short)HIWORD(lParam), TRUE);
 740                 break;
 741
 742         case EM_GETMARGINS:
 743                 result = MAKELONG(es->left_margin, es->right_margin);
 744                 break;
 745
 746         case EM_GETLIMITTEXT:
 747                 result = es->buffer_limit;
 748                 break;
 749
 750         case EM_POSFROMCHAR:
 751                 result = strlenW(es->text);
 752                 if ((INT)wParam >= result) result = -1;
 753                 else result = EDIT_EM_PosFromChar(es, (INT)wParam, FALSE);
 754                 break;
 755
 756         case EM_CHARFROMPOS:
 757                 result = EDIT_EM_CharFromPos(es, (short)LOWORD(lParam), (short)HIWORD(lParam));
 758                 break;
 759
 760         /* End of the EM_ messages which were in numerical order; what order
 761          * are these in?  vaguely alphabetical?
 762          */
 763
 764         case WM_NCCREATE:
 765                 result = EDIT_WM_NCCreate(hwnd, (LPCREATESTRUCTW)lParam, unicode);
 766                 break;
 767
 768         case WM_DESTROY:
 769                 result = EDIT_WM_Destroy(es);
 770                 es = NULL;
 771                 break;
 772
 773         case WM_GETDLGCODE:
 774                 result = DLGC_HASSETSEL | DLGC_WANTCHARS | DLGC_WANTARROWS;
 775
 776                 if (es->style & ES_MULTILINE)
 777                 {
 778                    result |= DLGC_WANTALLKEYS;
 779                    break;
 780                 }
 781
 782                 if (lParam && (((LPMSG)lParam)->message == WM_KEYDOWN))
 783                 {
 784                    int vk = (int)((LPMSG)lParam)->wParam;
 785
 786                    if (es->hwndListBox && (vk == VK_RETURN || vk == VK_ESCAPE))
 787                    {
 788                       if (SendMessageW(GetParent(hwnd), CB_GETDROPPEDSTATE, 0, 0))
 789                          result |= DLGC_WANTMESSAGE;
 790                    }
 791                 }
 792                 break;
 793
 794         case WM_IME_CHAR:
 795             if (!unicode)
 796             {
 797                 WCHAR charW;
 798                 CHAR  strng[2];
 799
 800                 strng[0] = wParam >> 8;
 801                 strng[1] = wParam & 0xff;
 802                 if (strng[0]) MultiByteToWideChar(CP_ACP, 0, strng, 2, &charW, 1);
 803                 else MultiByteToWideChar(CP_ACP, 0, &strng[1], 1, &charW, 1);
 804                 EDIT_WM_Char(es, charW);
 805                 break;
 806             }
 807             /* fall through */
 808         case WM_CHAR:
 809         {
 810                 WCHAR charW;
 811
 812                 if(unicode)
 813                     charW = wParam;
 814                 else
 815                 {
 816                     CHAR charA = wParam;
 817                     MultiByteToWideChar(CP_ACP, 0, &charA, 1, &charW, 1);
 818                 }
 819
 820                 if ((charW == VK_RETURN || charW == VK_ESCAPE) && es->hwndListBox)
 821                 {
 822                    if (SendMessageW(GetParent(hwnd), CB_GETDROPPEDSTATE, 0, 0))
 823                       SendMessageW(GetParent(hwnd), WM_KEYDOWN, charW, 0);
 824                    break;
 825                 }
 826                 EDIT_WM_Char(es, charW);
 827                 break;
 828         }
 829
 830         case WM_CLEAR:
 831                 EDIT_WM_Clear(es);
 832                 break;
 833
 834         case WM_COMMAND:
 835                 EDIT_WM_Command(es, HIWORD(wParam), LOWORD(wParam), (HWND)lParam);
 836                 break;
 837
 838         case WM_CONTEXTMENU:
 839                 EDIT_WM_ContextMenu(es, (short)LOWORD(lParam), (short)HIWORD(lParam));
 840                 break;
 841
 842         case WM_COPY:
 843                 EDIT_WM_Copy(es);
 844                 break;
 845
 846         case WM_CREATE:
 847                 if(unicode)
 848                     result = EDIT_WM_Create(es, ((LPCREATESTRUCTW)lParam)->lpszName);
 849                 else
 850                 {
 851                     LPCSTR nameA = ((LPCREATESTRUCTA)lParam)->lpszName;
 852                     LPWSTR nameW = NULL;
 853                     if(nameA)
 854                     {
 855                         INT countW = MultiByteToWideChar(CP_ACP, 0, nameA, -1, NULL, 0);
 856                         if((nameW = HeapAlloc(GetProcessHeap(), 0, countW * sizeof(WCHAR))))
 857                             MultiByteToWideChar(CP_ACP, 0, nameA, -1, nameW, countW);
 858                     }
 859                     result = EDIT_WM_Create(es, nameW);
 860                     HeapFree(GetProcessHeap(), 0, nameW);
 861                 }
 862                 break;
 863
 864         case WM_CUT:
 865                 EDIT_WM_Cut(es);
 866                 break;
 867
 868         case WM_ENABLE:
 869                 es->bEnableState = (BOOL) wParam;
 870                 EDIT_UpdateText(es, NULL, TRUE);
 871                 break;
 872
 873         case WM_ERASEBKGND:
 874                 result = EDIT_WM_EraseBkGnd(es, (HDC)wParam);
 875                 break;
 876
 877         case WM_GETFONT:
 878                 result = (LRESULT)es->font;
 879                 break;
 880
 881         case WM_GETTEXT:
 882                 result = (LRESULT)EDIT_WM_GetText(es, (INT)wParam, (LPWSTR)lParam, unicode);
 883                 break;
 884
 885         case WM_GETTEXTLENGTH:
 886                 if (unicode) result = strlenW(es->text);
 887                 else result = WideCharToMultiByte( CP_ACP, 0, es->text, strlenW(es->text),
 888                                                    NULL, 0, NULL, NULL );
 889                 break;
 890
 891         case WM_HSCROLL:
 892                 result = EDIT_WM_HScroll(es, LOWORD(wParam), (short)HIWORD(wParam));
 893                 break;
 894
 895         case WM_KEYDOWN:
 896                 result = EDIT_WM_KeyDown(es, (INT)wParam);
 897                 break;
 898
 899         case WM_KILLFOCUS:
 900                 result = EDIT_WM_KillFocus(es);
 901                 break;
 902
 903         case WM_LBUTTONDBLCLK:
 904                 result = EDIT_WM_LButtonDblClk(es);
 905                 break;
 906
 907         case WM_LBUTTONDOWN:
 908                 result = EDIT_WM_LButtonDown(es, wParam, (short)LOWORD(lParam), (short)HIWORD(lParam));
 909                 break;
 910
 911         case WM_LBUTTONUP:
 912                 result = EDIT_WM_LButtonUp(es);
 913                 break;
 914
 915         case WM_MBUTTONDOWN:
 916                 result = EDIT_WM_MButtonDown(es);
 917                 break;
 918
 919         case WM_MOUSEMOVE:
 920                 result = EDIT_WM_MouseMove(es, (short)LOWORD(lParam), (short)HIWORD(lParam));
 921                 break;
 922
 923         case WM_PAINT:
 924                 EDIT_WM_Paint(es, (HDC)wParam);
 925                 break;
 926
 927         case WM_PASTE:
 928                 EDIT_WM_Paste(es);
 929                 break;
 930
 931         case WM_SETFOCUS:
 932                 EDIT_WM_SetFocus(es);
 933                 break;
 934
 935         case WM_SETFONT:
 936                 EDIT_WM_SetFont(es, (HFONT)wParam, LOWORD(lParam) != 0);
 937                 break;
 938
 939         case WM_SETREDRAW:
 940                 /* FIXME: actually set an internal flag and behave accordingly */
 941                 break;
 942
 943         case WM_SETTEXT:
 944                 EDIT_WM_SetText(es, (LPCWSTR)lParam, unicode);
 945                 result = TRUE;
 946                 break;
 947
 948         case WM_SIZE:
 949                 EDIT_WM_Size(es, (UINT)wParam, LOWORD(lParam), HIWORD(lParam));
 950                 break;
 951
 952         case WM_STYLECHANGED:
 953                 result = EDIT_WM_StyleChanged(es, wParam, (const STYLESTRUCT *)lParam);
 954                 break;
 955
 956         case WM_STYLECHANGING:
 957                 result = 0; /* See EDIT_WM_StyleChanged */
 958                 break;
 959
 960         case WM_SYSKEYDOWN:
 961                 result = EDIT_WM_SysKeyDown(es, (INT)wParam, (DWORD)lParam);
 962                 break;
 963
 964         case WM_TIMER:
 965                 EDIT_WM_Timer(es);
 966                 break;
 967
 968         case WM_VSCROLL:
 969                 result = EDIT_WM_VScroll(es, LOWORD(wParam), (short)HIWORD(wParam));
 970                 break;
 971
 972         case WM_MOUSEWHEEL:
 973                 {
 974                     int gcWheelDelta = 0;
 975                     UINT pulScrollLines = 3;
 976                     SystemParametersInfoW(SPI_GETWHEELSCROLLLINES,0, &pulScrollLines, 0);
 977
 978                     if (wParam & (MK_SHIFT | MK_CONTROL)) {
 979                         result = DefWindowProcW(hwnd, msg, wParam, lParam);
 980                         break;
 981                     }
 982                     gcWheelDelta -= GET_WHEEL_DELTA_WPARAM(wParam);
 983                     if (abs(gcWheelDelta) >= WHEEL_DELTA && pulScrollLines)
 984                     {
 985                         int cLineScroll= (int) min((UINT) es->line_count, pulScrollLines);
 986                         cLineScroll *= (gcWheelDelta / WHEEL_DELTA);
 987                         result = EDIT_EM_LineScroll(es, 0, cLineScroll);
 988                     }
 989                 }
 990                 break;
 991         default:
 992                 result = DefWindowProcT(hwnd, msg, wParam, lParam, unicode);
 993                 break;
 994         }
 995
 996         if (es) EDIT_UnlockBuffer(es, FALSE);
 997
 998         TRACE("hwnd=%p msg=%x (%s) -- 0x%08lx\n", hwnd, msg, SPY_GetMsgName(msg, hwnd), result);
 999
1000         return result;
1001 }
1002
1003 /*********************************************************************
1004  *
1005  *      EditWndProcW   (USER32.@)
1006  */
1007 LRESULT WINAPI EditWndProcW(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
1008 {
1009     return EditWndProc_common(hWnd, uMsg, wParam, lParam, TRUE);
1010 }
1011
1012 /*********************************************************************
1013  *
1014  *      EditWndProc   (USER32.@)
1015  */
1016 LRESULT WINAPI EditWndProcA(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
1017 {
1018     return EditWndProc_common(hWnd, uMsg, wParam, lParam, FALSE);
1019 }
1020
1021 /*********************************************************************
1022  *
1023  *      EDIT_BuildLineDefs_ML
1024  *
1025  *      Build linked list of text lines.
1026  *      Lines can end with '\0' (last line), a character (if it is wrapped),
1027  *      a soft return '\r\r\n' or a hard return '\r\n'
1028  *
1029  */
1030 static void EDIT_BuildLineDefs_ML(EDITSTATE *es, INT istart, INT iend, INT delta, HRGN hrgn)
1031 {
1032         HDC dc;
1033         HFONT old_font = 0;
1034         LPWSTR current_position, cp;
1035         INT fw;
1036         LINEDEF *current_line;
1037         LINEDEF *previous_line;
1038         LINEDEF *start_line;
1039         INT line_index = 0, nstart_line = 0, nstart_index = 0;
1040         INT line_count = es->line_count;
1041         INT orig_net_length;
1042         RECT rc;
1043
1044         if (istart == iend && delta == 0)
1045                 return;
1046
1047         dc = GetDC(es->hwndSelf);
1048         if (es->font)
1049                 old_font = SelectObject(dc, es->font);
1050
1051         previous_line = NULL;
1052         current_line = es->first_line_def;
1053
1054         /* Find starting line. istart must lie inside an existing line or
1055          * at the end of buffer */
1056         do {
1057                 if (istart < current_line->index + current_line->length ||
1058                                 current_line->ending == END_0)
1059                         break;
1060
1061                 previous_line = current_line;
1062                 current_line = current_line->next;
1063                 line_index++;
1064         } while (current_line);
1065
1066         if (!current_line) /* Error occurred start is not inside previous buffer */
1067         {
1068                 FIXME(" modification occurred outside buffer\n");
1069                 ReleaseDC(es->hwndSelf, dc);
1070                 return;
1071         }
1072
1073         /* Remember start of modifications in order to calculate update region */
1074         nstart_line = line_index;
1075         nstart_index = current_line->index;
1076
1077         /* We must start to reformat from the previous line since the modifications
1078          * may have caused the line to wrap upwards. */
1079         if (!(es->style & ES_AUTOHSCROLL) && line_index > 0)
1080         {
1081                 line_index--;
1082                 current_line = previous_line;
1083         }
1084         start_line = current_line;
1085
1086         fw = es->format_rect.right - es->format_rect.left;
1087         current_position = es->text + current_line->index;
1088         do {
1089                 if (current_line != start_line)
1090                 {
1091                         if (!current_line || current_line->index + delta > current_position - es->text)
1092                         {
1093                                 /* The buffer has been expanded, create a new line and
1094                                    insert it into the link list */
1095                                 LINEDEF *new_line = HeapAlloc(GetProcessHeap(), 0, sizeof(LINEDEF));
1096                                 new_line->next = previous_line->next;
1097                                 previous_line->next = new_line;
1098                                 current_line = new_line;
1099                                 es->line_count++;
1100                         }
1101                         else if (current_line->index + delta < current_position - es->text)
1102                         {
1103                                 /* The previous line merged with this line so we delete this extra entry */
1104                                 previous_line->next = current_line->next;
1105                                 HeapFree(GetProcessHeap(), 0, current_line);
1106                                 current_line = previous_line->next;
1107                                 es->line_count--;
1108                                 continue;
1109                         }
1110                         else /* current_line->index + delta == current_position */
1111                         {
1112                                 if (current_position - es->text > iend)
1113                                         break; /* We reached end of line modifications */
1114                                 /* else recalulate this line */
1115                         }
1116                 }
1117
1118                 current_line->index = current_position - es->text;
1119                 orig_net_length = current_line->net_length;
1120
1121                 /* Find end of line */
1122                 cp = current_position;
1123                 while (*cp) {
1124                     if (*cp == '\n') break;
1125                         if ((*cp == '\r') && (*(cp + 1) == '\n'))
1126                                 break;
1127                         cp++;
1128                 }
1129
1130                 /* Mark type of line termination */
1131                 if (!(*cp)) {
1132                         current_line->ending = END_0;
1133                         current_line->net_length = strlenW(current_position);
1134                 } else if ((cp > current_position) && (*(cp - 1) == '\r')) {
1135                         current_line->ending = END_SOFT;
1136                         current_line->net_length = cp - current_position - 1;
1137                 } else if (*cp == '\n') {
1138                         current_line->ending = END_RICH;
1139                         current_line->net_length = cp - current_position;
1140                 } else {
1141                         current_line->ending = END_HARD;
1142                         current_line->net_length = cp - current_position;
1143                 }
1144
1145                 /* Calculate line width */
1146                 current_line->width = (INT)LOWORD(GetTabbedTextExtentW(dc,
1147                                         current_position, current_line->net_length,
1148                                         es->tabs_count, es->tabs));
1149
1150                 /* FIXME: check here for lines that are too wide even in AUTOHSCROLL (> 32767 ???) */
1151                 if (!(es->style & ES_AUTOHSCROLL)) {
1152                    if (current_line->width > fw) {
1153                         INT next = 0;
1154                         INT prev;
1155                         do {
1156                                 prev = next;
1157                                 next = EDIT_CallWordBreakProc(es, current_position - es->text,
1158                                                 prev + 1, current_line->net_length, WB_RIGHT);
1159                                 current_line->width = (INT)LOWORD(GetTabbedTextExtentW(dc,
1160                                                         current_position, next, es->tabs_count, es->tabs));
1161                         } while (current_line->width <= fw);
1162                         if (!prev) { /* Didn't find a line break so force a break */
1163                                 next = 0;
1164                                 do {
1165                                         prev = next;
1166                                         next++;
1167                                         current_line->width = (INT)LOWORD(GetTabbedTextExtentW(dc,
1168                                                                 current_position, next, es->tabs_count, es->tabs));
1169                                 } while (current_line->width <= fw);
1170                                 if (!prev)
1171                                         prev = 1;
1172                         }
1173
1174                         /* If the first line we are calculating, wrapped before istart, we must
1175                          * adjust istart in order for this to be reflected in the update region. */
1176                         if (current_line->index == nstart_index && istart > current_line->index + prev)
1177                                 istart = current_line->index + prev;
1178                         /* else if we are updating the previous line before the first line we
1179                          * are re-calculating and it expanded */
1180                         else if (current_line == start_line &&
1181                                         current_line->index != nstart_index && orig_net_length < prev)
1182                         {
1183                           /* Line expanded due to an upwards line wrap so we must partially include
1184                            * previous line in update region */
1185                                 nstart_line = line_index;
1186                                 nstart_index = current_line->index;
1187                                 istart = current_line->index + orig_net_length;
1188                         }
1189
1190                         current_line->net_length = prev;
1191                         current_line->ending = END_WRAP;
1192                         current_line->width = (INT)LOWORD(GetTabbedTextExtentW(dc, current_position,
1193                                         current_line->net_length, es->tabs_count, es->tabs));
1194                     }
1195                     else if (orig_net_length <  current_line->net_length  &&
1196                         current_line == start_line &&
1197                         current_line->index != nstart_index) {
1198                         /* The previous line expanded but it's still not as wide as the client rect */
1199                         /* The expansion is due to an upwards line wrap so we must partially include
1200                            it in the update region */
1201                         nstart_line = line_index;
1202                         nstart_index = current_line->index;
1203                         istart = current_line->index + orig_net_length;
1204                     }
1205                 }
1206
1207
1208                 /* Adjust length to include line termination */
1209                 switch (current_line->ending) {
1210                 case END_SOFT:
1211                         current_line->length = current_line->net_length + 3;
1212                         break;
1213                 case END_RICH:
1214                         current_line->length = current_line->net_length + 1;
1215                         break;
1216                 case END_HARD:
1217                         current_line->length = current_line->net_length + 2;
1218                         break;
1219                 case END_WRAP:
1220                 case END_0:
1221                         current_line->length = current_line->net_length;
1222                         break;
1223                 }
1224                 es->text_width = max(es->text_width, current_line->width);
1225                 current_position += current_line->length;
1226                 previous_line = current_line;
1227                 current_line = current_line->next;
1228                 line_index++;
1229         } while (previous_line->ending != END_0);
1230
1231         /* Finish adjusting line indexes by delta or remove hanging lines */
1232         if (previous_line->ending == END_0)
1233         {
1234                 LINEDEF *pnext = NULL;
1235
1236                 previous_line->next = NULL;
1237                 while (current_line)
1238                 {
1239                         pnext = current_line->next;
1240                         HeapFree(GetProcessHeap(), 0, current_line);
1241                         current_line = pnext;
1242                         es->line_count--;
1243                 }
1244         }
1245         else if (delta != 0)
1246         {
1247                 while (current_line)
1248                 {
1249                         current_line->index += delta;
1250                         current_line = current_line->next;
1251                 }
1252         }
1253
1254         /* Calculate rest of modification rectangle */
1255         if (hrgn)
1256         {
1257                 HRGN tmphrgn;
1258            /*
1259                 * We calculate two rectangles. One for the first line which may have
1260                 * an indent with respect to the format rect. The other is a format-width
1261                 * rectangle that spans the rest of the lines that changed or moved.
1262                 */
1263                 rc.top = es->format_rect.top + nstart_line * es->line_height -
1264                         (es->y_offset * es->line_height); /* Adjust for vertical scrollbar */
1265                 rc.bottom = rc.top + es->line_height;
1266                 if ((es->style & ES_CENTER) || (es->style & ES_RIGHT))
1267                         rc.left = es->format_rect.left;
1268                 else
1269                         rc.left = es->format_rect.left + (INT)LOWORD(GetTabbedTextExtentW(dc,
1270                                         es->text + nstart_index, istart - nstart_index,
1271                                         es->tabs_count, es->tabs)) - es->x_offset; /* Adjust for horz scroll */
1272                 rc.right = es->format_rect.right;
1273                 SetRectRgn(hrgn, rc.left, rc.top, rc.right, rc.bottom);
1274
1275                 rc.top = rc.bottom;
1276                 rc.left = es->format_rect.left;
1277                 rc.right = es->format_rect.right;
1278            /*
1279                 * If lines were added or removed we must re-paint the remainder of the
1280             * lines since the remaining lines were either shifted up or down.
1281                 */
1282                 if (line_count < es->line_count) /* We added lines */
1283                         rc.bottom = es->line_count * es->line_height;
1284                 else if (line_count > es->line_count) /* We removed lines */
1285                         rc.bottom = line_count * es->line_height;
1286                 else
1287                         rc.bottom = line_index * es->line_height;
1288                 rc.bottom += es->format_rect.top;
1289                 rc.bottom -= (es->y_offset * es->line_height); /* Adjust for vertical scrollbar */
1290                 tmphrgn = CreateRectRgn(rc.left, rc.top, rc.right, rc.bottom);
1291                 CombineRgn(hrgn, hrgn, tmphrgn, RGN_OR);
1292                 DeleteObject(tmphrgn);
1293         }
1294
1295         if (es->font)
1296                 SelectObject(dc, old_font);
1297
1298         ReleaseDC(es->hwndSelf, dc);
1299 }
1300
1301 /*********************************************************************
1302  *
1303  *      EDIT_CalcLineWidth_SL
1304  *
1305  */
1306 static void EDIT_CalcLineWidth_SL(EDITSTATE *es)
1307 {
1308         SIZE size;
1309         LPWSTR text;
1310         HDC dc;
1311         HFONT old_font = 0;
1312
1313         text = EDIT_GetPasswordPointer_SL(es);
1314
1315         dc = GetDC(es->hwndSelf);
1316         if (es->font)
1317                 old_font = SelectObject(dc, es->font);
1318
1319         GetTextExtentPoint32W(dc, text, strlenW(text), &size);
1320
1321         if (es->font)
1322                 SelectObject(dc, old_font);
1323         ReleaseDC(es->hwndSelf, dc);
1324
1325         if (es->style & ES_PASSWORD)
1326                 HeapFree(GetProcessHeap(), 0, text);
1327
1328         es->text_width = size.cx;
1329 }
1330
1331 /*********************************************************************
1332  *
1333  *      EDIT_CallWordBreakProc
1334  *
1335  *      Call appropriate WordBreakProc (internal or external).
1336  *
1337  *      Note: The "start" argument should always be an index referring
1338  *              to es->text.  The actual wordbreak proc might be
1339  *              16 bit, so we can't always pass any 32 bit LPSTR.
1340  *              Hence we assume that es->text is the buffer that holds
1341  *              the string under examination (we can decide this for ourselves).
1342  *
1343  */
1344 static INT EDIT_CallWordBreakProc(EDITSTATE *es, INT start, INT index, INT count, INT action)
1345 {
1346         INT ret;
1347
1348         if (es->word_break_proc16) {
1349             HGLOBAL16 hglob16;
1350             SEGPTR segptr;
1351             INT countA;
1352             WORD args[5];
1353             DWORD result;
1354
1355             countA = WideCharToMultiByte(CP_ACP, 0, es->text + start, count, NULL, 0, NULL, NULL);
1356             hglob16 = GlobalAlloc16(GMEM_MOVEABLE | GMEM_ZEROINIT, countA);
1357             segptr = K32WOWGlobalLock16(hglob16);
1358             WideCharToMultiByte(CP_ACP, 0, es->text + start, count, MapSL(segptr), countA, NULL, NULL);
1359             args[4] = SELECTOROF(segptr);
1360             args[3] = OFFSETOF(segptr);
1361             args[2] = index;
1362             args[1] = countA;
1363             args[0] = action;
1364             WOWCallback16Ex((DWORD)es->word_break_proc16, WCB16_PASCAL, sizeof(args), args, &result);
1365             ret = LOWORD(result);
1366             GlobalUnlock16(hglob16);
1367             GlobalFree16(hglob16);
1368         }
1369         else if (es->word_break_proc)
1370         {
1371             if(es->is_unicode)
1372             {
1373                 EDITWORDBREAKPROCW wbpW = (EDITWORDBREAKPROCW)es->word_break_proc;
1374
1375                 TRACE_(relay)("(UNICODE wordbrk=%p,str=%s,idx=%d,cnt=%d,act=%d)\n",
1376                         es->word_break_proc, debugstr_wn(es->text + start, count), index, count, action);
1377                 ret = wbpW(es->text + start, index, count, action);
1378             }
1379             else
1380             {
1381                 EDITWORDBREAKPROCA wbpA = (EDITWORDBREAKPROCA)es->word_break_proc;
1382                 INT countA;
1383                 CHAR *textA;
1384
1385                 countA = WideCharToMultiByte(CP_ACP, 0, es->text + start, count, NULL, 0, NULL, NULL);
1386                 textA = HeapAlloc(GetProcessHeap(), 0, countA);
1387                 WideCharToMultiByte(CP_ACP, 0, es->text + start, count, textA, countA, NULL, NULL);
1388                 TRACE_(relay)("(ANSI wordbrk=%p,str=%s,idx=%d,cnt=%d,act=%d)\n",
1389                         es->word_break_proc, debugstr_an(textA, countA), index, countA, action);
1390                 ret = wbpA(textA, index, countA, action);
1391                 HeapFree(GetProcessHeap(), 0, textA);
1392             }
1393         }
1394         else
1395             ret = EDIT_WordBreakProc(es->text + start, index, count, action);
1396
1397         return ret;
1398 }
1399
1400
1401 /*********************************************************************
1402  *
1403  *      EDIT_CharFromPos
1404  *
1405  *      Beware: This is not the function called on EM_CHARFROMPOS
1406  *              The position _can_ be outside the formatting / client
1407  *              rectangle
1408  *              The return value is only the character index
1409  *
1410  */
1411 static INT EDIT_CharFromPos(EDITSTATE *es, INT x, INT y, LPBOOL after_wrap)
1412 {
1413         INT index;
1414         HDC dc;
1415         HFONT old_font = 0;
1416         INT x_high = 0, x_low = 0;
1417
1418         if (es->style & ES_MULTILINE) {
1419                 INT line = (y - es->format_rect.top) / es->line_height + es->y_offset;
1420                 INT line_index = 0;
1421                 LINEDEF *line_def = es->first_line_def;
1422                 INT low, high;
1423                 while ((line > 0) && line_def->next) {
1424                         line_index += line_def->length;
1425                         line_def = line_def->next;
1426                         line--;
1427                 }
1428                 x += es->x_offset - es->format_rect.left;
1429                 if (es->style & ES_RIGHT)
1430                         x -= (es->format_rect.right - es->format_rect.left) - line_def->width;
1431                 else if (es->style & ES_CENTER)
1432                         x -= ((es->format_rect.right - es->format_rect.left) - line_def->width) / 2;
1433                 if (x >= line_def->width) {
1434                         if (after_wrap)
1435                                 *after_wrap = (line_def->ending == END_WRAP);
1436                         return line_index + line_def->net_length;
1437                 }
1438                 if (x <= 0) {
1439                         if (after_wrap)
1440                                 *after_wrap = FALSE;
1441                         return line_index;
1442                 }
1443                 dc = GetDC(es->hwndSelf);
1444                 if (es->font)
1445                         old_font = SelectObject(dc, es->font);
1446                     low = line_index;
1447                     high = line_index + line_def->net_length + 1;
1448                     while (low < high - 1)
1449                     {
1450                         INT mid = (low + high) / 2;
1451                         INT x_now = LOWORD(GetTabbedTextExtentW(dc, es->text + line_index, mid - line_index, es->tabs_count, es->tabs));
1452                         if (x_now > x) {
1453                             high = mid;
1454                             x_high = x_now;
1455                         } else {
1456                             low = mid;
1457                             x_low = x_now;
1458                         }
1459                     }
1460                     if (abs(x_high - x) + 1 <= abs(x_low - x))
1461                         index = high;
1462                     else
1463                         index = low;
1464
1465                 if (after_wrap)
1466                         *after_wrap = ((index == line_index + line_def->net_length) &&
1467                                                         (line_def->ending == END_WRAP));
1468         } else {
1469                 LPWSTR text;
1470                 SIZE size;
1471                 if (after_wrap)
1472                         *after_wrap = FALSE;
1473                 x -= es->format_rect.left;
1474                 if (!x)
1475                         return es->x_offset;
1476
1477                 if (!es->x_offset)
1478                 {
1479                         INT indent = (es->format_rect.right - es->format_rect.left) - es->text_width;
1480                         if (es->style & ES_RIGHT)
1481                                 x -= indent;
1482                         else if (es->style & ES_CENTER)
1483                                 x -= indent / 2;
1484                 }
1485
1486                 text = EDIT_GetPasswordPointer_SL(es);
1487                 dc = GetDC(es->hwndSelf);
1488                 if (es->font)
1489                         old_font = SelectObject(dc, es->font);
1490                 if (x < 0)
1491                 {
1492                     INT low = 0;
1493                     INT high = es->x_offset;
1494                     while (low < high - 1)
1495                     {
1496                         INT mid = (low + high) / 2;
1497                         GetTextExtentPoint32W( dc, text + mid,
1498                                                es->x_offset - mid, &size );
1499                         if (size.cx > -x) {
1500                             low = mid;
1501                             x_low = size.cx;
1502                         } else {
1503                             high = mid;
1504                             x_high = size.cx;
1505                         }
1506                     }
1507                     if (abs(x_high + x) <= abs(x_low + x) + 1)
1508                         index = high;
1509                     else
1510                         index = low;
1511                 }
1512                 else
1513                 {
1514                     INT low = es->x_offset;
1515                     INT high = strlenW(es->text) + 1;
1516                     while (low < high - 1)
1517                     {
1518                         INT mid = (low + high) / 2;
1519                         GetTextExtentPoint32W( dc, text + es->x_offset,
1520                                                mid - es->x_offset, &size );
1521                         if (size.cx > x) {
1522                                high = mid;
1523                                x_high = size.cx;
1524                         } else {
1525                                low = mid;
1526                                x_low = size.cx;
1527                        }
1528                     }
1529                    if (abs(x_high - x) <= abs(x_low - x) + 1)
1530                        index = high;
1531                    else
1532                        index = low;
1533                 }
1534                 if (es->style & ES_PASSWORD)
1535                         HeapFree(GetProcessHeap(), 0, text);
1536         }
1537         if (es->font)
1538                 SelectObject(dc, old_font);
1539         ReleaseDC(es->hwndSelf, dc);
1540         return index;
1541 }
1542
1543
1544 /*********************************************************************
1545  *
1546  *      EDIT_ConfinePoint
1547  *
1548  *      adjusts the point to be within the formatting rectangle
1549  *      (so CharFromPos returns the nearest _visible_ character)
1550  *
1551  */
1552 static void EDIT_ConfinePoint(EDITSTATE *es, LPINT x, LPINT y)
1553 {
1554         *x = min(max(*x, es->format_rect.left), es->format_rect.right - 1);
1555         *y = min(max(*y, es->format_rect.top), es->format_rect.bottom - 1);
1556 }
1557
1558
1559 /*********************************************************************
1560  *
1561  *      EDIT_GetLineRect
1562  *
1563  *      Calculates the bounding rectangle for a line from a starting
1564  *      column to an ending column.
1565  *
1566  */
1567 static void EDIT_GetLineRect(EDITSTATE *es, INT line, INT scol, INT ecol, LPRECT rc)
1568 {
1569         INT line_index =  EDIT_EM_LineIndex(es, line);
1570
1571         if (es->style & ES_MULTILINE)
1572                 rc->top = es->format_rect.top + (line - es->y_offset) * es->line_height;
1573         else
1574                 rc->top = es->format_rect.top;
1575         rc->bottom = rc->top + es->line_height;
1576         rc->left = (scol == 0) ? es->format_rect.left : (short)LOWORD(EDIT_EM_PosFromChar(es, line_index + scol, TRUE));
1577         rc->right = (ecol == -1) ? es->format_rect.right : (short)LOWORD(EDIT_EM_PosFromChar(es, line_index + ecol, TRUE));
1578 }
1579
1580
1581 /*********************************************************************
1582  *
1583  *      EDIT_GetPasswordPointer_SL
1584  *
1585  *      note: caller should free the (optionally) allocated buffer
1586  *
1587  */
1588 static LPWSTR EDIT_GetPasswordPointer_SL(EDITSTATE *es)
1589 {
1590         if (es->style & ES_PASSWORD) {
1591                 INT len = strlenW(es->text);
1592                 LPWSTR text = HeapAlloc(GetProcessHeap(), 0, (len + 1) * sizeof(WCHAR));
1593                 text[len] = '\0';
1594                 while(len) text[--len] = es->password_char;
1595                 return text;
1596         } else
1597                 return es->text;
1598 }
1599
1600
1601 /*********************************************************************
1602  *
1603  *      EDIT_LockBuffer
1604  *
1605  *      This acts as a LocalLock16(), but it locks only once.  This way
1606  *      you can call it whenever you like, without unlocking.
1607  *
1608  *      Initially the edit control allocates a HLOCAL32 buffer
1609  *      (32 bit linear memory handler).  However, 16 bit application
1610  *      might send an EM_GETHANDLE message and expect a HLOCAL16 (16 bit SEG:OFF
1611  *      handler).  From that moment on we have to keep using this 16 bit memory
1612  *      handler, because it is supposed to be valid at all times after EM_GETHANDLE.
1613  *      What we do is create a HLOCAL16 buffer, copy the text, and do pointer
1614  *      conversion.
1615  *
1616  */
1617 static void EDIT_LockBuffer(EDITSTATE *es)
1618 {
1619         STACK16FRAME* stack16 = MapSL((SEGPTR)NtCurrentTeb()->WOW32Reserved);
1620         HINSTANCE16 hInstance = GetWindowLongPtrW( es->hwndSelf, GWLP_HINSTANCE );
1621         HANDLE16 oldDS = stack16->ds;
1622
1623         if (!es->text) {
1624             CHAR *textA = NULL;
1625             UINT countA = 0;
1626             BOOL _16bit = FALSE;
1627
1628             if(es->hloc32W)
1629             {
1630                 if(es->hloc32A)
1631                 {
1632                     TRACE("Synchronizing with 32-bit ANSI buffer\n");
1633                     textA = LocalLock(es->hloc32A);
1634                     countA = strlen(textA) + 1;
1635                 }
1636                 else if(es->hloc16)
1637                 {
1638                     TRACE("Synchronizing with 16-bit ANSI buffer\n");
1639                     stack16->ds = hInstance;
1640                     textA = MapSL(LocalLock16(es->hloc16));
1641                     stack16->ds = oldDS;
1642                     countA = strlen(textA) + 1;
1643                     _16bit = TRUE;
1644                 }
1645             }
1646             else {
1647                 ERR("no buffer ... please report\n");
1648                 return;
1649             }
1650
1651             if(textA)
1652             {
1653                 HLOCAL hloc32W_new;
1654                 UINT countW_new = MultiByteToWideChar(CP_ACP, 0, textA, countA, NULL, 0);
1655                 TRACE("%d bytes translated to %d WCHARs\n", countA, countW_new);
1656                 if(countW_new > es->buffer_size + 1)
1657                 {
1658                     UINT alloc_size = ROUND_TO_GROW(countW_new * sizeof(WCHAR));
1659                     TRACE("Resizing 32-bit UNICODE buffer from %d+1 to %d WCHARs\n", es->buffer_size, countW_new);
1660                     hloc32W_new = LocalReAlloc(es->hloc32W, alloc_size, LMEM_MOVEABLE | LMEM_ZEROINIT);
1661                     if(hloc32W_new)
1662                     {
1663                         es->hloc32W = hloc32W_new;
1664                         es->buffer_size = LocalSize(hloc32W_new)/sizeof(WCHAR) - 1;
1665                         TRACE("Real new size %d+1 WCHARs\n", es->buffer_size);
1666                     }
1667                     else
1668                         WARN("FAILED! Will synchronize partially\n");
1669                 }
1670             }
1671
1672             /*TRACE("Locking 32-bit UNICODE buffer\n");*/
1673             es->text = LocalLock(es->hloc32W);
1674
1675             if(textA)
1676             {
1677                 MultiByteToWideChar(CP_ACP, 0, textA, countA, es->text, es->buffer_size + 1);
1678                 if(_16bit)
1679                 {
1680                     stack16->ds = hInstance;
1681                     LocalUnlock16(es->hloc16);
1682                     stack16->ds = oldDS;
1683                 }
1684                 else
1685                     LocalUnlock(es->hloc32A);
1686             }
1687         }
1688         es->lock_count++;
1689 }
1690
1691
1692 /*********************************************************************
1693  *
1694  *      EDIT_SL_InvalidateText
1695  *
1696  *      Called from EDIT_InvalidateText().
1697  *      Does the job for single-line controls only.
1698  *
1699  */
1700 static void EDIT_SL_InvalidateText(EDITSTATE *es, INT start, INT end)
1701 {
1702         RECT line_rect;
1703         RECT rc;
1704
1705         EDIT_GetLineRect(es, 0, start, end, &line_rect);
1706         if (IntersectRect(&rc, &line_rect, &es->format_rect))
1707                 EDIT_UpdateText(es, &rc, TRUE);
1708 }
1709
1710
1711 /*********************************************************************
1712  *
1713  *      EDIT_ML_InvalidateText
1714  *
1715  *      Called from EDIT_InvalidateText().
1716  *      Does the job for multi-line controls only.
1717  *
1718  */
1719 static void EDIT_ML_InvalidateText(EDITSTATE *es, INT start, INT end)
1720 {
1721         INT vlc = (es->format_rect.bottom - es->format_rect.top) / es->line_height;
1722         INT sl = EDIT_EM_LineFromChar(es, start);
1723         INT el = EDIT_EM_LineFromChar(es, end);
1724         INT sc;
1725         INT ec;
1726         RECT rc1;
1727         RECT rcWnd;
1728         RECT rcLine;
1729         RECT rcUpdate;
1730         INT l;
1731
1732         if ((el < es->y_offset) || (sl > es->y_offset + vlc))
1733                 return;
1734
1735         sc = start - EDIT_EM_LineIndex(es, sl);
1736         ec = end - EDIT_EM_LineIndex(es, el);
1737         if (sl < es->y_offset) {
1738                 sl = es->y_offset;
1739                 sc = 0;
1740         }
1741         if (el > es->y_offset + vlc) {
1742                 el = es->y_offset + vlc;
1743                 ec = EDIT_EM_LineLength(es, EDIT_EM_LineIndex(es, el));
1744         }
1745         GetClientRect(es->hwndSelf, &rc1);
1746         IntersectRect(&rcWnd, &rc1, &es->format_rect);
1747         if (sl == el) {
1748                 EDIT_GetLineRect(es, sl, sc, ec, &rcLine);
1749                 if (IntersectRect(&rcUpdate, &rcWnd, &rcLine))
1750                         EDIT_UpdateText(es, &rcUpdate, TRUE);
1751         } else {
1752                 EDIT_GetLineRect(es, sl, sc,
1753                                 EDIT_EM_LineLength(es,
1754                                         EDIT_EM_LineIndex(es, sl)),
1755                                 &rcLine);
1756                 if (IntersectRect(&rcUpdate, &rcWnd, &rcLine))
1757                         EDIT_UpdateText(es, &rcUpdate, TRUE);
1758                 for (l = sl + 1 ; l < el ; l++) {
1759                         EDIT_GetLineRect(es, l, 0,
1760                                 EDIT_EM_LineLength(es,
1761                                         EDIT_EM_LineIndex(es, l)),
1762                                 &rcLine);
1763                         if (IntersectRect(&rcUpdate, &rcWnd, &rcLine))
1764                                 EDIT_UpdateText(es, &rcUpdate, TRUE);
1765                 }
1766                 EDIT_GetLineRect(es, el, 0, ec, &rcLine);
1767                 if (IntersectRect(&rcUpdate, &rcWnd, &rcLine))
1768                         EDIT_UpdateText(es, &rcUpdate, TRUE);
1769         }
1770 }
1771
1772
1773 /*********************************************************************
1774  *
1775  *      EDIT_InvalidateText
1776  *
1777  *      Invalidate the text from offset start upto, but not including,
1778  *      offset end.  Useful for (re)painting the selection.
1779  *      Regions outside the linewidth are not invalidated.
1780  *      end == -1 means end == TextLength.
1781  *      start and end need not be ordered.
1782  *
1783  */
1784 static void EDIT_InvalidateText(EDITSTATE *es, INT start, INT end)
1785 {
1786         if (end == start)
1787                 return;
1788
1789         if (end == -1)
1790                 end = strlenW(es->text);
1791
1792         if (end < start) {
1793             INT tmp = start;
1794             start = end;
1795             end = tmp;
1796         }
1797
1798         if (es->style & ES_MULTILINE)
1799                 EDIT_ML_InvalidateText(es, start, end);
1800         else
1801                 EDIT_SL_InvalidateText(es, start, end);
1802 }
1803
1804
1805 /*********************************************************************
1806  *
1807  *      EDIT_MakeFit
1808  *
1809  * Try to fit size + 1 characters in the buffer.
1810  */
1811 static BOOL EDIT_MakeFit(EDITSTATE *es, UINT size)
1812 {
1813         HLOCAL hNew32W;
1814
1815         if (size <= es->buffer_size)
1816                 return TRUE;
1817
1818         TRACE("trying to ReAlloc to %d+1 characters\n", size);
1819
1820         /* Force edit to unlock it's buffer. es->text now NULL */
1821         EDIT_UnlockBuffer(es, TRUE);
1822
1823         if (es->hloc32W) {
1824             UINT alloc_size = ROUND_TO_GROW((size + 1) * sizeof(WCHAR));
1825             if ((hNew32W = LocalReAlloc(es->hloc32W, alloc_size, LMEM_MOVEABLE | LMEM_ZEROINIT))) {
1826                 TRACE("Old 32 bit handle %p, new handle %p\n", es->hloc32W, hNew32W);
1827                 es->hloc32W = hNew32W;
1828                 es->buffer_size = LocalSize(hNew32W)/sizeof(WCHAR) - 1;
1829             }
1830         }
1831
1832         EDIT_LockBuffer(es);
1833
1834         if (es->buffer_size < size) {
1835                 WARN("FAILED !  We now have %d+1\n", es->buffer_size);
1836                 EDIT_NOTIFY_PARENT(es, EN_ERRSPACE);
1837                 return FALSE;
1838         } else {
1839                 TRACE("We now have %d+1\n", es->buffer_size);
1840                 return TRUE;
1841         }
1842 }
1843
1844
1845 /*********************************************************************
1846  *
1847  *      EDIT_MakeUndoFit
1848  *
1849  *      Try to fit size + 1 bytes in the undo buffer.
1850  *
1851  */
1852 static BOOL EDIT_MakeUndoFit(EDITSTATE *es, UINT size)
1853 {
1854         UINT alloc_size;
1855
1856         if (size <= es->undo_buffer_size)
1857                 return TRUE;
1858
1859         TRACE("trying to ReAlloc to %d+1\n", size);
1860
1861         alloc_size = ROUND_TO_GROW((size + 1) * sizeof(WCHAR));
1862         if ((es->undo_text = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, es->undo_text, alloc_size))) {
1863                 es->undo_buffer_size = alloc_size/sizeof(WCHAR) - 1;
1864                 return TRUE;
1865         }
1866         else
1867         {
1868                 WARN("FAILED !  We now have %d+1\n", es->undo_buffer_size);
1869                 return FALSE;
1870         }
1871 }
1872
1873
1874 /*********************************************************************
1875  *
1876  *      EDIT_MoveBackward
1877  *
1878  */
1879 static void EDIT_MoveBackward(EDITSTATE *es, BOOL extend)
1880 {
1881         INT e = es->selection_end;
1882
1883         if (e) {
1884                 e--;
1885                 if ((es->style & ES_MULTILINE) && e &&
1886                                 (es->text[e - 1] == '\r') && (es->text[e] == '\n')) {
1887                         e--;
1888                         if (e && (es->text[e - 1] == '\r'))
1889                                 e--;
1890                 }
1891         }
1892         EDIT_EM_SetSel(es, extend ? es->selection_start : e, e, FALSE);
1893         EDIT_EM_ScrollCaret(es);
1894 }
1895
1896
1897 /*********************************************************************
1898  *
1899  *      EDIT_MoveDown_ML
1900  *
1901  *      Only for multi line controls
1902  *      Move the caret one line down, on a column with the nearest
1903  *      x coordinate on the screen (might be a different column).
1904  *
1905  */
1906 static void EDIT_MoveDown_ML(EDITSTATE *es, BOOL extend)
1907 {
1908         INT s = es->selection_start;
1909         INT e = es->selection_end;
1910         BOOL after_wrap = (es->flags & EF_AFTER_WRAP);
1911         LRESULT pos = EDIT_EM_PosFromChar(es, e, after_wrap);
1912         INT x = (short)LOWORD(pos);
1913         INT y = (short)HIWORD(pos);
1914
1915         e = EDIT_CharFromPos(es, x, y + es->line_height, &after_wrap);
1916         if (!extend)
1917                 s = e;
1918         EDIT_EM_SetSel(es, s, e, after_wrap);
1919         EDIT_EM_ScrollCaret(es);
1920 }
1921
1922
1923 /*********************************************************************
1924  *
1925  *      EDIT_MoveEnd
1926  *
1927  */
1928 static void EDIT_MoveEnd(EDITSTATE *es, BOOL extend)
1929 {
1930         BOOL after_wrap = FALSE;
1931         INT e;
1932
1933         /* Pass a high value in x to make sure of receiving the end of the line */
1934         if (es->style & ES_MULTILINE)
1935                 e = EDIT_CharFromPos(es, 0x3fffffff,
1936                         HIWORD(EDIT_EM_PosFromChar(es, es->selection_end, es->flags & EF_AFTER_WRAP)), &after_wrap);
1937         else
1938                 e = strlenW(es->text);
1939         EDIT_EM_SetSel(es, extend ? es->selection_start : e, e, after_wrap);
1940         EDIT_EM_ScrollCaret(es);
1941 }
1942
1943
1944 /*********************************************************************
1945  *
1946  *      EDIT_MoveForward
1947  *
1948  */
1949 static void EDIT_MoveForward(EDITSTATE *es, BOOL extend)
1950 {
1951         INT e = es->selection_end;
1952
1953         if (es->text[e]) {
1954                 e++;
1955                 if ((es->style & ES_MULTILINE) && (es->text[e - 1] == '\r')) {
1956                         if (es->text[e] == '\n')
1957                                 e++;
1958                         else if ((es->text[e] == '\r') && (es->text[e + 1] == '\n'))
1959                                 e += 2;
1960                 }
1961         }
1962         EDIT_EM_SetSel(es, extend ? es->selection_start : e, e, FALSE);
1963         EDIT_EM_ScrollCaret(es);
1964 }
1965
1966
1967 /*********************************************************************
1968  *
1969  *      EDIT_MoveHome
1970  *
1971  *      Home key: move to beginning of line.
1972  *
1973  */
1974 static void EDIT_MoveHome(EDITSTATE *es, BOOL extend)
1975 {
1976         INT e;
1977
1978         /* Pass the x_offset in x to make sure of receiving the first position of the line */
1979         if (es->style & ES_MULTILINE)
1980                 e = EDIT_CharFromPos(es, -es->x_offset,
1981                         HIWORD(EDIT_EM_PosFromChar(es, es->selection_end, es->flags & EF_AFTER_WRAP)), NULL);
1982         else
1983                 e = 0;
1984         EDIT_EM_SetSel(es, extend ? es->selection_start : e, e, FALSE);
1985         EDIT_EM_ScrollCaret(es);
1986 }
1987
1988
1989 /*********************************************************************
1990  *
1991  *      EDIT_MovePageDown_ML
1992  *
1993  *      Only for multi line controls
1994  *      Move the caret one page down, on a column with the nearest
1995  *      x coordinate on the screen (might be a different column).
1996  *
1997  */
1998 static void EDIT_MovePageDown_ML(EDITSTATE *es, BOOL extend)
1999 {
2000         INT s = es->selection_start;
2001         INT e = es->selection_end;
2002         BOOL after_wrap = (es->flags & EF_AFTER_WRAP);
2003         LRESULT pos = EDIT_EM_PosFromChar(es, e, after_wrap);
2004         INT x = (short)LOWORD(pos);
2005         INT y = (short)HIWORD(pos);
2006
2007         e = EDIT_CharFromPos(es, x,
2008                 y + (es->format_rect.bottom - es->format_rect.top),
2009                 &after_wrap);
2010         if (!extend)
2011                 s = e;
2012         EDIT_EM_SetSel(es, s, e, after_wrap);
2013         EDIT_EM_ScrollCaret(es);
2014 }
2015
2016
2017 /*********************************************************************
2018  *
2019  *      EDIT_MovePageUp_ML
2020  *
2021  *      Only for multi line controls
2022  *      Move the caret one page up, on a column with the nearest
2023  *      x coordinate on the screen (might be a different column).
2024  *
2025  */
2026 static void EDIT_MovePageUp_ML(EDITSTATE *es, BOOL extend)
2027 {
2028         INT s = es->selection_start;
2029         INT e = es->selection_end;
2030         BOOL after_wrap = (es->flags & EF_AFTER_WRAP);
2031         LRESULT pos = EDIT_EM_PosFromChar(es, e, after_wrap);
2032         INT x = (short)LOWORD(pos);
2033         INT y = (short)HIWORD(pos);
2034
2035         e = EDIT_CharFromPos(es, x,
2036                 y - (es->format_rect.bottom - es->format_rect.top),
2037                 &after_wrap);
2038         if (!extend)
2039                 s = e;
2040         EDIT_EM_SetSel(es, s, e, after_wrap);
2041         EDIT_EM_ScrollCaret(es);
2042 }
2043
2044
2045 /*********************************************************************
2046  *
2047  *      EDIT_MoveUp_ML
2048  *
2049  *      Only for multi line controls
2050  *      Move the caret one line up, on a column with the nearest
2051  *      x coordinate on the screen (might be a different column).
2052  *
2053  */
2054 static void EDIT_MoveUp_ML(EDITSTATE *es, BOOL extend)
2055 {
2056         INT s = es->selection_start;
2057         INT e = es->selection_end;
2058         BOOL after_wrap = (es->flags & EF_AFTER_WRAP);
2059         LRESULT pos = EDIT_EM_PosFromChar(es, e, after_wrap);
2060         INT x = (short)LOWORD(pos);
2061         INT y = (short)HIWORD(pos);
2062
2063         e = EDIT_CharFromPos(es, x, y - es->line_height, &after_wrap);
2064         if (!extend)
2065                 s = e;
2066         EDIT_EM_SetSel(es, s, e, after_wrap);
2067         EDIT_EM_ScrollCaret(es);
2068 }
2069
2070
2071 /*********************************************************************
2072  *
2073  *      EDIT_MoveWordBackward
2074  *
2075  */
2076 static void EDIT_MoveWordBackward(EDITSTATE *es, BOOL extend)
2077 {
2078         INT s = es->selection_start;
2079         INT e = es->selection_end;
2080         INT l;
2081         INT ll;
2082         INT li;
2083
2084         l = EDIT_EM_LineFromChar(es, e);
2085         ll = EDIT_EM_LineLength(es, e);
2086         li = EDIT_EM_LineIndex(es, l);
2087         if (e - li == 0) {
2088                 if (l) {
2089                         li = EDIT_EM_LineIndex(es, l - 1);
2090                         e = li + EDIT_EM_LineLength(es, li);
2091                 }
2092         } else {
2093                 e = li + (INT)EDIT_CallWordBreakProc(es,
2094                                 li, e - li, ll, WB_LEFT);
2095         }
2096         if (!extend)
2097                 s = e;
2098         EDIT_EM_SetSel(es, s, e, FALSE);
2099         EDIT_EM_ScrollCaret(es);
2100 }
2101
2102
2103 /*********************************************************************
2104  *
2105  *      EDIT_MoveWordForward
2106  *
2107  */
2108 static void EDIT_MoveWordForward(EDITSTATE *es, BOOL extend)
2109 {
2110         INT s = es->selection_start;
2111         INT e = es->selection_end;
2112         INT l;
2113         INT ll;
2114         INT li;
2115
2116         l = EDIT_EM_LineFromChar(es, e);
2117         ll = EDIT_EM_LineLength(es, e);
2118         li = EDIT_EM_LineIndex(es, l);
2119         if (e - li == ll) {
2120                 if ((es->style & ES_MULTILINE) && (l != es->line_count - 1))
2121                         e = EDIT_EM_LineIndex(es, l + 1);
2122         } else {
2123                 e = li + EDIT_CallWordBreakProc(es,
2124                                 li, e - li + 1, ll, WB_RIGHT);
2125         }
2126         if (!extend)
2127                 s = e;
2128         EDIT_EM_SetSel(es, s, e, FALSE);
2129         EDIT_EM_ScrollCaret(es);
2130 }
2131
2132
2133 /*********************************************************************
2134  *
2135  *      EDIT_PaintLine
2136  *
2137  */
2138 static void EDIT_PaintLine(EDITSTATE *es, HDC dc, INT line, BOOL rev)
2139 {
2140         INT s = es->selection_start;
2141         INT e = es->selection_end;
2142         INT li;
2143         INT ll;
2144         INT x;
2145         INT y;
2146         LRESULT pos;
2147
2148         if (es->style & ES_MULTILINE) {
2149                 INT vlc = (es->format_rect.bottom - es->format_rect.top) / es->line_height;
2150                 if ((line < es->y_offset) || (line > es->y_offset + vlc) || (line >= es->line_count))
2151                         return;
2152         } else if (line)
2153                 return;
2154
2155         TRACE("line=%d\n", line);
2156
2157         pos = EDIT_EM_PosFromChar(es, EDIT_EM_LineIndex(es, line), FALSE);
2158         x = (short)LOWORD(pos);
2159         y = (short)HIWORD(pos);
2160         li = EDIT_EM_LineIndex(es, line);
2161         ll = EDIT_EM_LineLength(es, li);
2162         s = min(es->selection_start, es->selection_end);
2163         e = max(es->selection_start, es->selection_end);
2164         s = min(li + ll, max(li, s));
2165         e = min(li + ll, max(li, e));
2166         if (rev && (s != e) &&
2167                         ((es->flags & EF_FOCUSED) || (es->style & ES_NOHIDESEL))) {
2168                 x += EDIT_PaintText(es, dc, x, y, line, 0, s - li, FALSE);
2169                 x += EDIT_PaintText(es, dc, x, y, line, s - li, e - s, TRUE);
2170                 x += EDIT_PaintText(es, dc, x, y, line, e - li, li + ll - e, FALSE);
2171         } else
2172                 x += EDIT_PaintText(es, dc, x, y, line, 0, ll, FALSE);
2173 }
2174
2175
2176 /*********************************************************************
2177  *
2178  *      EDIT_PaintText
2179  *
2180  */
2181 static INT EDIT_PaintText(EDITSTATE *es, HDC dc, INT x, INT y, INT line, INT col, INT count, BOOL rev)
2182 {
2183         COLORREF BkColor;
2184         COLORREF TextColor;
2185         INT ret;
2186         INT li;
2187         INT BkMode;
2188         SIZE size;
2189
2190         if (!count)
2191                 return 0;
2192         BkMode = GetBkMode(dc);
2193         BkColor = GetBkColor(dc);
2194         TextColor = GetTextColor(dc);
2195         if (rev) {
2196                 SetBkColor(dc, GetSysColor(COLOR_HIGHLIGHT));
2197                 SetTextColor(dc, GetSysColor(COLOR_HIGHLIGHTTEXT));
2198                 SetBkMode( dc, OPAQUE);
2199         }
2200         li = EDIT_EM_LineIndex(es, line);
2201         if (es->style & ES_MULTILINE) {
2202                 ret = (INT)LOWORD(TabbedTextOutW(dc, x, y, es->text + li + col, count,
2203                                         es->tabs_count, es->tabs, es->format_rect.left - es->x_offset));
2204         } else {
2205                 LPWSTR text = EDIT_GetPasswordPointer_SL(es);
2206                 TextOutW(dc, x, y, text + li + col, count);
2207                 GetTextExtentPoint32W(dc, text + li + col, count, &size);
2208                 ret = size.cx;
2209                 if (es->style & ES_PASSWORD)
2210                         HeapFree(GetProcessHeap(), 0, text);
2211         }
2212         if (rev) {
2213                 SetBkColor(dc, BkColor);
2214                 SetTextColor(dc, TextColor);
2215                 SetBkMode( dc, BkMode);
2216         }
2217         return ret;
2218 }
2219
2220
2221 /*********************************************************************
2222  *
2223  *      EDIT_SetCaretPos
2224  *
2225  */
2226 static void EDIT_SetCaretPos(EDITSTATE *es, INT pos,
2227                              BOOL after_wrap)
2228 {
2229         LRESULT res = EDIT_EM_PosFromChar(es, pos, after_wrap);
2230         TRACE("%d - %dx%d\n", pos, (short)LOWORD(res), (short)HIWORD(res));
2231         SetCaretPos((short)LOWORD(res), (short)HIWORD(res));
2232 }
2233
2234
2235 /*********************************************************************
2236  *
2237  *      EDIT_AdjustFormatRect
2238  *
2239  *      Adjusts the format rectangle for the current font and the
2240  *      current client rectangle.
2241  *
2242  */
2243 static void EDIT_AdjustFormatRect(EDITSTATE *es)
2244 {
2245         RECT ClientRect;
2246
2247         es->format_rect.right = max(es->format_rect.right, es->format_rect.left + es->char_width);
2248         if (es->style & ES_MULTILINE)
2249         {
2250             INT fw, vlc, max_x_offset, max_y_offset;
2251
2252             vlc = (es->format_rect.bottom - es->format_rect.top) / es->line_height;
2253             es->format_rect.bottom = es->format_rect.top + max(1, vlc) * es->line_height;
2254
2255             /* correct es->x_offset */
2256             fw = es->format_rect.right - es->format_rect.left;
2257             max_x_offset = es->text_width - fw;
2258             if(max_x_offset < 0) max_x_offset = 0;
2259             if(es->x_offset > max_x_offset)
2260                 es->x_offset = max_x_offset;
2261
2262             /* correct es->y_offset */
2263             max_y_offset = es->line_count - vlc;
2264             if(max_y_offset < 0) max_y_offset = 0;
2265             if(es->y_offset > max_y_offset)
2266                 es->y_offset = max_y_offset;
2267
2268             /* force scroll info update */
2269             EDIT_UpdateScrollInfo(es);
2270         }
2271         else
2272         /* Windows doesn't care to fix text placement for SL controls */
2273                 es->format_rect.bottom = es->format_rect.top + es->line_height;
2274
2275         /* Always stay within the client area */
2276         GetClientRect(es->hwndSelf, &ClientRect);
2277         es->format_rect.bottom = min(es->format_rect.bottom, ClientRect.bottom);
2278
2279         if ((es->style & ES_MULTILINE) && !(es->style & ES_AUTOHSCROLL))
2280                 EDIT_BuildLineDefs_ML(es, 0, strlenW(es->text), 0, NULL);
2281
2282         EDIT_SetCaretPos(es, es->selection_end, es->flags & EF_AFTER_WRAP);
2283 }
2284
2285
2286 /*********************************************************************
2287  *
2288  *      EDIT_SetRectNP
2289  *
2290  *      note:   this is not (exactly) the handler called on EM_SETRECTNP
2291  *              it is also used to set the rect of a single line control
2292  *
2293  */
2294 static void EDIT_SetRectNP(EDITSTATE *es, LPRECT rc)
2295 {
2296         LONG_PTR ExStyle;
2297
2298         CopyRect(&es->format_rect, rc);
2299         ExStyle = GetWindowLongPtrW(es->hwndSelf, GWL_EXSTYLE);
2300         if ((es->style & WS_POPUP) && !(ExStyle & WS_EX_CLIENTEDGE)) {
2301                 if (es->style & WS_BORDER) {
2302                         INT bw = GetSystemMetrics(SM_CXBORDER) + 1;
2303                         es->format_rect.left += bw;
2304                         es->format_rect.right -= bw;
2305                         if (es->line_height + 2 * bw <=
2306                         es->format_rect.bottom - es->format_rect.top) {
2307                                 es->format_rect.top += bw;
2308                                 es->format_rect.bottom -= bw;
2309                         }
2310                 }
2311         } else {
2312                 if (es->line_height + 2 <=
2313                         es->format_rect.bottom - es->format_rect.top) {
2314                         es->format_rect.top++;
2315                         es->format_rect.bottom--;
2316                 }
2317                 es->format_rect.left++;
2318                 es->format_rect.right--;
2319         }
2320
2321         es->format_rect.left += es->left_margin;
2322         es->format_rect.right -= es->right_margin;
2323         EDIT_AdjustFormatRect(es);
2324 }
2325
2326
2327 /*********************************************************************
2328  *
2329  *      EDIT_UnlockBuffer
2330  *
2331  */
2332 static void EDIT_UnlockBuffer(EDITSTATE *es, BOOL force)
2333 {
2334
2335         /* Edit window might be already destroyed */
2336         if(!IsWindow(es->hwndSelf))
2337         {
2338             WARN("edit hwnd %p already destroyed\n", es->hwndSelf);
2339             return;
2340         }
2341
2342         if (!es->lock_count) {
2343                 ERR("lock_count == 0 ... please report\n");
2344                 return;
2345         }
2346         if (!es->text) {
2347                 ERR("es->text == 0 ... please report\n");
2348                 return;
2349         }
2350
2351         if (force || (es->lock_count == 1)) {
2352             if (es->hloc32W) {
2353                 CHAR *textA = NULL;
2354                 UINT countA = 0;
2355                 UINT countW = strlenW(es->text) + 1;
2356                 STACK16FRAME* stack16 = NULL;
2357                 HANDLE16 oldDS = 0;
2358
2359                 if(es->hloc32A)
2360                 {
2361                     UINT countA_new = WideCharToMultiByte(CP_ACP, 0, es->text, countW, NULL, 0, NULL, NULL);
2362                     TRACE("Synchronizing with 32-bit ANSI buffer\n");
2363                     TRACE("%d WCHARs translated to %d bytes\n", countW, countA_new);
2364                     countA = LocalSize(es->hloc32A);
2365                     if(countA_new > countA)
2366                     {
2367                         HLOCAL hloc32A_new;
2368                         UINT alloc_size = ROUND_TO_GROW(countA_new);
2369                         TRACE("Resizing 32-bit ANSI buffer from %d to %d bytes\n", countA, alloc_size);
2370                         hloc32A_new = LocalReAlloc(es->hloc32A, alloc_size, LMEM_MOVEABLE | LMEM_ZEROINIT);
2371                         if(hloc32A_new)
2372                         {
2373                             es->hloc32A = hloc32A_new;
2374                             countA = LocalSize(hloc32A_new);
2375                             TRACE("Real new size %d bytes\n", countA);
2376                         }
2377                         else
2378                             WARN("FAILED! Will synchronize partially\n");
2379                     }
2380                     textA = LocalLock(es->hloc32A);
2381                 }
2382                 else if(es->hloc16)
2383                 {
2384                     UINT countA_new = WideCharToMultiByte(CP_ACP, 0, es->text, countW, NULL, 0, NULL, NULL);
2385
2386                     TRACE("Synchronizing with 16-bit ANSI buffer\n");
2387                     TRACE("%d WCHARs translated to %d bytes\n", countW, countA_new);
2388
2389                     stack16 = MapSL((SEGPTR)NtCurrentTeb()->WOW32Reserved);
2390                     oldDS = stack16->ds;
2391                     stack16->ds = GetWindowLongPtrW( es->hwndSelf, GWLP_HINSTANCE );
2392
2393                     countA = LocalSize16(es->hloc16);
2394                     if(countA_new > countA)
2395                     {
2396                         HLOCAL16 hloc16_new;
2397                         UINT alloc_size = ROUND_TO_GROW(countA_new);
2398                         TRACE("Resizing 16-bit ANSI buffer from %d to %d bytes\n", countA, alloc_size);
2399                         hloc16_new = LocalReAlloc16(es->hloc16, alloc_size, LMEM_MOVEABLE | LMEM_ZEROINIT);
2400                         if(hloc16_new)
2401                         {
2402                             es->hloc16 = hloc16_new;
2403                             countA = LocalSize16(hloc16_new);
2404                             TRACE("Real new size %d bytes\n", countA);
2405                         }
2406                         else
2407                             WARN("FAILED! Will synchronize partially\n");
2408                     }
2409                     textA = MapSL(LocalLock16(es->hloc16));
2410                 }
2411
2412                 if(textA)
2413                 {
2414                     WideCharToMultiByte(CP_ACP, 0, es->text, countW, textA, countA, NULL, NULL);
2415                     if(stack16)
2416                         LocalUnlock16(es->hloc16);
2417                     else
2418                         LocalUnlock(es->hloc32A);
2419                 }
2420
2421                 if (stack16) stack16->ds = oldDS;
2422                 LocalUnlock(es->hloc32W);
2423                 es->text = NULL;
2424             }
2425             else {
2426                 ERR("no buffer ... please report\n");
2427                 return;
2428             }
2429         }
2430         es->lock_count--;
2431 }
2432
2433
2434 /*********************************************************************
2435  *
2436  *      EDIT_UpdateScrollInfo
2437  *
2438  */
2439 static void EDIT_UpdateScrollInfo(EDITSTATE *es)
2440 {
2441     if ((es->style & WS_VSCROLL) && !(es->flags & EF_VSCROLL_TRACK))
2442     {
2443         SCROLLINFO si;
2444         si.cbSize       = sizeof(SCROLLINFO);
2445         si.fMask        = SIF_PAGE | SIF_POS | SIF_RANGE | SIF_DISABLENOSCROLL;
2446         si.nMin         = 0;
2447         si.nMax         = es->line_count - 1;
2448         si.nPage        = (es->format_rect.bottom - es->format_rect.top) / es->line_height;
2449         si.nPos         = es->y_offset;
2450         TRACE("SB_VERT, nMin=%d, nMax=%d, nPage=%d, nPos=%d\n",
2451                 si.nMin, si.nMax, si.nPage, si.nPos);
2452         SetScrollInfo(es->hwndSelf, SB_VERT, &si, TRUE);
2453     }
2454
2455     if ((es->style & WS_HSCROLL) && !(es->flags & EF_HSCROLL_TRACK))
2456     {
2457         SCROLLINFO si;
2458         si.cbSize       = sizeof(SCROLLINFO);
2459         si.fMask        = SIF_PAGE | SIF_POS | SIF_RANGE | SIF_DISABLENOSCROLL;
2460         si.nMin         = 0;
2461         si.nMax         = es->text_width - 1;
2462         si.nPage        = es->format_rect.right - es->format_rect.left;
2463         si.nPos         = es->x_offset;
2464         TRACE("SB_HORZ, nMin=%d, nMax=%d, nPage=%d, nPos=%d\n",
2465                 si.nMin, si.nMax, si.nPage, si.nPos);
2466         SetScrollInfo(es->hwndSelf, SB_HORZ, &si, TRUE);
2467     }
2468 }
2469
2470 /*********************************************************************
2471  *
2472  *      EDIT_WordBreakProc
2473  *
2474  *      Find the beginning of words.
2475  *      Note:   unlike the specs for a WordBreakProc, this function only
2476  *              allows to be called without linebreaks between s[0] upto
2477  *              s[count - 1].  Remember it is only called
2478  *              internally, so we can decide this for ourselves.
2479  *
2480  */
2481 static INT CALLBACK EDIT_WordBreakProc(LPWSTR s, INT index, INT count, INT action)
2482 {
2483         INT ret = 0;
2484
2485         TRACE("s=%p, index=%d, count=%d, action=%d\n", s, index, count, action);
2486
2487         if(!s) return 0;
2488
2489         switch (action) {
2490         case WB_LEFT:
2491                 if (!count)
2492                         break;
2493                 if (index)
2494                         index--;
2495                 if (s[index] == ' ') {
2496                         while (index && (s[index] == ' '))
2497                                 index--;
2498                         if (index) {
2499                                 while (index && (s[index] != ' '))
2500                                         index--;
2501                                 if (s[index] == ' ')
2502                                         index++;
2503                         }
2504                 } else {
2505                         while (index && (s[index] != ' '))
2506                                 index--;
2507                         if (s[index] == ' ')
2508                                 index++;
2509                 }
2510                 ret = index;
2511                 break;
2512         case WB_RIGHT:
2513                 if (!count)
2514                         break;
2515                 if (index)
2516                         index--;
2517                 if (s[index] == ' ')
2518                         while ((index < count) && (s[index] == ' ')) index++;
2519                 else {
2520                         while (s[index] && (s[index] != ' ') && (index < count))
2521                                 index++;
2522                         while ((s[index] == ' ') && (index < count)) index++;
2523                 }
2524                 ret = index;
2525                 break;
2526         case WB_ISDELIMITER:
2527                 ret = (s[index] == ' ');
2528                 break;
2529         default:
2530                 ERR("unknown action code, please report !\n");
2531                 break;
2532         }
2533         return ret;
2534 }
2535
2536
2537 /*********************************************************************
2538  *
2539  *      EM_CHARFROMPOS
2540  *
2541  *      returns line number (not index) in high-order word of result.
2542  *      NB : Q137805 is unclear about this. POINT * pointer in lParam apply
2543  *      to Richedit, not to the edit control. Original documentation is valid.
2544  *      FIXME: do the specs mean to return -1 if outside client area or
2545  *              if outside formatting rectangle ???
2546  *
2547  */
2548 static LRESULT EDIT_EM_CharFromPos(EDITSTATE *es, INT x, INT y)
2549 {
2550         POINT pt;
2551         RECT rc;
2552         INT index;
2553
2554         pt.x = x;
2555         pt.y = y;
2556         GetClientRect(es->hwndSelf, &rc);
2557         if (!PtInRect(&rc, pt))
2558                 return -1;
2559
2560         index = EDIT_CharFromPos(es, x, y, NULL);
2561         return MAKELONG(index, EDIT_EM_LineFromChar(es, index));
2562 }
2563
2564
2565 /*********************************************************************
2566  *
2567  *      EM_FMTLINES
2568  *
2569  * Enable or disable soft breaks.
2570  *
2571  * This means: insert or remove the soft linebreak character (\r\r\n).
2572  * Take care to check if the text still fits the buffer after insertion.
2573  * If not, notify with EN_ERRSPACE.
2574  *
2575  */
2576 static BOOL EDIT_EM_FmtLines(EDITSTATE *es, BOOL add_eol)
2577 {
2578         es->flags &= ~EF_USE_SOFTBRK;
2579         if (add_eol) {
2580                 es->flags |= EF_USE_SOFTBRK;
2581                 FIXME("soft break enabled, not implemented\n");
2582         }
2583         return add_eol;
2584 }
2585
2586
2587 /*********************************************************************
2588  *
2589  *      EM_GETHANDLE
2590  *
2591  *      Hopefully this won't fire back at us.
2592  *      We always start with a fixed buffer in the local heap.
2593  *      Despite of the documentation says that the local heap is used
2594  *      only if DS_LOCALEDIT flag is set, NT and 2000 always allocate
2595  *      buffer on the local heap.
2596  *
2597  */
2598 static HLOCAL EDIT_EM_GetHandle(EDITSTATE *es)
2599 {
2600         HLOCAL hLocal;
2601
2602         if (!(es->style & ES_MULTILINE))
2603                 return 0;
2604
2605         if(es->is_unicode)
2606             hLocal = es->hloc32W;
2607         else
2608         {
2609             if(!es->hloc32A)
2610             {
2611                 CHAR *textA;
2612                 UINT countA, alloc_size;
2613                 TRACE("Allocating 32-bit ANSI alias buffer\n");
2614                 countA = WideCharToMultiByte(CP_ACP, 0, es->text, -1, NULL, 0, NULL, NULL);
2615                 alloc_size = ROUND_TO_GROW(countA);
2616                 if(!(es->hloc32A = LocalAlloc(LMEM_MOVEABLE | LMEM_ZEROINIT, alloc_size)))
2617                 {
2618                     ERR("Could not allocate %d bytes for 32-bit ANSI alias buffer\n", alloc_size);
2619                     return 0;
2620                 }
2621                 textA = LocalLock(es->hloc32A);
2622                 WideCharToMultiByte(CP_ACP, 0, es->text, -1, textA, countA, NULL, NULL);
2623                 LocalUnlock(es->hloc32A);
2624             }
2625             hLocal = es->hloc32A;
2626         }
2627
2628         TRACE("Returning %p, LocalSize() = %ld\n", hLocal, LocalSize(hLocal));
2629         return hLocal;
2630 }
2631
2632
2633 /*********************************************************************
2634  *
2635  *      EM_GETHANDLE16
2636  *
2637  *      Hopefully this won't fire back at us.
2638  *      We always start with a buffer in 32 bit linear memory.
2639  *      However, with this message a 16 bit application requests
2640  *      a handle of 16 bit local heap memory, where it expects to find
2641  *      the text.
2642  *      It's a pitty that from this moment on we have to use this
2643  *      local heap, because applications may rely on the handle
2644  *      in the future.
2645  *
2646  *      In this function we'll try to switch to local heap.
2647  */
2648 static HLOCAL16 EDIT_EM_GetHandle16(EDITSTATE *es)
2649 {
2650         CHAR *textA;
2651         UINT countA, alloc_size;
2652         STACK16FRAME* stack16;
2653         HANDLE16 oldDS;
2654
2655         if (!(es->style & ES_MULTILINE))
2656                 return 0;
2657
2658         if (es->hloc16)
2659                 return es->hloc16;
2660
2661         stack16 = MapSL((SEGPTR)NtCurrentTeb()->WOW32Reserved);
2662         oldDS = stack16->ds;
2663         stack16->ds = GetWindowLongPtrW( es->hwndSelf, GWLP_HINSTANCE );
2664
2665         if (!LocalHeapSize16()) {
2666
2667                 if (!LocalInit16(stack16->ds, 0, GlobalSize16(stack16->ds))) {
2668                         ERR("could not initialize local heap\n");
2669                         goto done;
2670                 }
2671                 TRACE("local heap initialized\n");
2672         }
2673
2674         countA = WideCharToMultiByte(CP_ACP, 0, es->text, -1, NULL, 0, NULL, NULL);
2675         alloc_size = ROUND_TO_GROW(countA);
2676
2677         TRACE("Allocating 16-bit ANSI alias buffer\n");
2678         if (!(es->hloc16 = LocalAlloc16(LMEM_MOVEABLE | LMEM_ZEROINIT, alloc_size))) {
2679                 ERR("could not allocate new 16 bit buffer\n");
2680                 goto done;
2681         }
2682
2683         if (!(textA = MapSL(LocalLock16( es->hloc16)))) {
2684                 ERR("could not lock new 16 bit buffer\n");
2685                 LocalFree16(es->hloc16);
2686                 es->hloc16 = 0;
2687                 goto done;
2688         }
2689
2690         WideCharToMultiByte(CP_ACP, 0, es->text, -1, textA, countA, NULL, NULL);
2691         LocalUnlock16(es->hloc16);
2692
2693         TRACE("Returning %04X, LocalSize() = %d\n", es->hloc16, LocalSize16(es->hloc16));
2694
2695 done:
2696         stack16->ds = oldDS;
2697         return es->hloc16;
2698 }
2699
2700
2701 /*********************************************************************
2702  *
2703  *      EM_GETLINE
2704  *
2705  */
2706 static INT EDIT_EM_GetLine(EDITSTATE *es, INT line, LPWSTR dst, BOOL unicode)
2707 {
2708         LPWSTR src;
2709         INT line_len, dst_len;
2710         INT i;
2711
2712         if (es->style & ES_MULTILINE) {
2713                 if (line >= es->line_count)
2714                         return 0;
2715         } else
2716                 line = 0;
2717         i = EDIT_EM_LineIndex(es, line);
2718         src = es->text + i;
2719         line_len = EDIT_EM_LineLength(es, i);
2720         dst_len = *(WORD *)dst;
2721         if(unicode)
2722         {
2723             if(dst_len <= line_len)
2724             {
2725                 memcpy(dst, src, dst_len * sizeof(WCHAR));
2726                 return dst_len;
2727             }
2728             else /* Append 0 if enough space */
2729             {
2730                 memcpy(dst, src, line_len * sizeof(WCHAR));
2731                 dst[line_len] = 0;
2732                 return line_len;
2733             }
2734         }
2735         else
2736         {
2737             INT ret = WideCharToMultiByte(CP_ACP, 0, src, line_len, (LPSTR)dst, dst_len, NULL, NULL);
2738             if(!ret) /* Insufficient buffer size */
2739                 return dst_len;
2740             if(ret < dst_len) /* Append 0 if enough space */
2741                 ((LPSTR)dst)[ret] = 0;
2742             return ret;
2743         }
2744 }
2745
2746
2747 /*********************************************************************
2748  *
2749  *      EM_GETSEL
2750  *
2751  */
2752 static LRESULT EDIT_EM_GetSel(EDITSTATE *es, PUINT start, PUINT end)
2753 {
2754         UINT s = es->selection_start;
2755         UINT e = es->selection_end;
2756
2757         ORDER_UINT(s, e);
2758         if (start)
2759                 *start = s;
2760         if (end)
2761                 *end = e;
2762         return MAKELONG(s, e);
2763 }
2764
2765
2766 /*********************************************************************
2767  *
2768  *      EM_GETTHUMB
2769  *
2770  *      FIXME: is this right ?  (or should it be only VSCROLL)
2771  *      (and maybe only for edit controls that really have their
2772  *      own scrollbars) (and maybe only for multiline controls ?)
2773  *      All in all: very poorly documented
2774  *
2775  */
2776 static LRESULT EDIT_EM_GetThumb(EDITSTATE *es)
2777 {
2778         return MAKELONG(EDIT_WM_VScroll(es, EM_GETTHUMB16, 0),
2779                 EDIT_WM_HScroll(es, EM_GETTHUMB16, 0));
2780 }
2781
2782
2783 /*********************************************************************
2784  *
2785  *      EM_LINEFROMCHAR
2786  *
2787  */
2788 static INT EDIT_EM_LineFromChar(EDITSTATE *es, INT index)
2789 {
2790         INT line;
2791         LINEDEF *line_def;
2792
2793         if (!(es->style & ES_MULTILINE))
2794                 return 0;
2795         if (index > (INT)strlenW(es->text))
2796                 return es->line_count - 1;
2797         if (index == -1)
2798                 index = min(es->selection_start, es->selection_end);
2799
2800         line = 0;
2801         line_def = es->first_line_def;
2802         index -= line_def->length;
2803         while ((index >= 0) && line_def->next) {
2804                 line++;
2805                 line_def = line_def->next;
2806                 index -= line_def->length;
2807         }
2808         return line;
2809 }
2810
2811
2812 /*********************************************************************
2813  *
2814  *      EM_LINEINDEX
2815  *
2816  */
2817 static INT EDIT_EM_LineIndex(EDITSTATE *es, INT line)
2818 {
2819         INT line_index;
2820         LINEDEF *line_def;
2821
2822         if (!(es->style & ES_MULTILINE))
2823                 return 0;
2824         if (line >= es->line_count)
2825                 return -1;
2826
2827         line_index = 0;
2828         line_def = es->first_line_def;
2829         if (line == -1) {
2830                 INT index = es->selection_end - line_def->length;
2831                 while ((index >= 0) && line_def->next) {
2832                         line_index += line_def->length;
2833                         line_def = line_def->next;
2834                         index -= line_def->length;
2835                 }
2836         } else {
2837                 while (line > 0) {
2838                         line_index += line_def->length;
2839                         line_def = line_def->next;
2840                         line--;
2841                 }
2842         }
2843         return line_index;
2844 }
2845
2846
2847 /*********************************************************************
2848  *
2849  *      EM_LINELENGTH
2850  *
2851  */
2852 static INT EDIT_EM_LineLength(EDITSTATE *es, INT index)
2853 {
2854         LINEDEF *line_def;
2855
2856         if (!(es->style & ES_MULTILINE))
2857                 return strlenW(es->text);
2858
2859         if (index == -1) {
2860                 /* get the number of remaining non-selected chars of selected lines */
2861                 INT32 l; /* line number */
2862                 INT32 li; /* index of first char in line */
2863                 INT32 count;
2864                 l = EDIT_EM_LineFromChar(es, es->selection_start);
2865                 /* # chars before start of selection area */
2866                 count = es->selection_start - EDIT_EM_LineIndex(es, l);
2867                 l = EDIT_EM_LineFromChar(es, es->selection_end);
2868                 /* # chars after end of selection */
2869                 li = EDIT_EM_LineIndex(es, l);
2870                 count += li + EDIT_EM_LineLength(es, li) - es->selection_end;
2871                 return count;
2872         }
2873         line_def = es->first_line_def;
2874         index -= line_def->length;
2875         while ((index >= 0) && line_def->next) {
2876                 line_def = line_def->next;
2877                 index -= line_def->length;
2878         }
2879         return line_def->net_length;
2880 }
2881
2882
2883 /*********************************************************************
2884  *
2885  *      EM_LINESCROLL
2886  *
2887  *      NOTE: dx is in average character widths, dy - in lines;
2888  *
2889  */
2890 static BOOL EDIT_EM_LineScroll(EDITSTATE *es, INT dx, INT dy)
2891 {
2892         if (!(es->style & ES_MULTILINE))
2893                 return FALSE;
2894
2895         dx *= es->char_width;
2896         return EDIT_EM_LineScroll_internal(es, dx, dy);
2897 }
2898
2899 /*********************************************************************
2900  *
2901  *      EDIT_EM_LineScroll_internal
2902  *
2903  *      Version of EDIT_EM_LineScroll for internal use.
2904  *      It doesn't refuse if ES_MULTILINE is set and assumes that
2905  *      dx is in pixels, dy - in lines.
2906  *
2907  */
2908 static BOOL EDIT_EM_LineScroll_internal(EDITSTATE *es, INT dx, INT dy)
2909 {
2910         INT nyoff;
2911         INT x_offset_in_pixels;
2912         INT lines_per_page = (es->format_rect.bottom - es->format_rect.top) /
2913                               es->line_height;
2914
2915         if (es->style & ES_MULTILINE)
2916         {
2917             x_offset_in_pixels = es->x_offset;
2918         }
2919         else
2920         {
2921             dy = 0;
2922             x_offset_in_pixels = (short)LOWORD(EDIT_EM_PosFromChar(es, es->x_offset, FALSE));
2923         }
2924
2925         if (-dx > x_offset_in_pixels)
2926                 dx = -x_offset_in_pixels;
2927         if (dx > es->text_width - x_offset_in_pixels)
2928                 dx = es->text_width - x_offset_in_pixels;
2929         nyoff = max(0, es->y_offset + dy);
2930         if (nyoff >= es->line_count - lines_per_page)
2931                 nyoff = max(0, es->line_count - lines_per_page);
2932         dy = (es->y_offset - nyoff) * es->line_height;
2933         if (dx || dy) {
2934                 RECT rc1;
2935                 RECT rc;
2936
2937                 es->y_offset = nyoff;
2938                 if(es->style & ES_MULTILINE)
2939                     es->x_offset += dx;
2940                 else
2941                     es->x_offset += dx / es->char_width;
2942
2943                 GetClientRect(es->hwndSelf, &rc1);
2944                 IntersectRect(&rc, &rc1, &es->format_rect);
2945                 ScrollWindowEx(es->hwndSelf, -dx, dy,
2946                                 NULL, &rc, NULL, NULL, SW_INVALIDATE);
2947                 /* force scroll info update */
2948                 EDIT_UpdateScrollInfo(es);
2949         }
2950         if (dx && !(es->flags & EF_HSCROLL_TRACK))
2951                 EDIT_NOTIFY_PARENT(es, EN_HSCROLL);
2952         if (dy && !(es->flags & EF_VSCROLL_TRACK))
2953                 EDIT_NOTIFY_PARENT(es, EN_VSCROLL);
2954         return TRUE;
2955 }
2956
2957
2958 /*********************************************************************
2959  *
2960  *      EM_POSFROMCHAR
2961  *
2962  */
2963 static LRESULT EDIT_EM_PosFromChar(EDITSTATE *es, INT index, BOOL after_wrap)
2964 {
2965         INT len = strlenW(es->text);
2966         INT l;
2967         INT li;
2968         INT x;
2969         INT y = 0;
2970         INT w;
2971         INT lw = 0;
2972         INT ll = 0;
2973         HDC dc;
2974         HFONT old_font = 0;
2975         SIZE size;
2976         LINEDEF *line_def;
2977
2978         index = min(index, len);
2979         dc = GetDC(es->hwndSelf);
2980         if (es->font)
2981                 old_font = SelectObject(dc, es->font);
2982         if (es->style & ES_MULTILINE) {
2983                 l = EDIT_EM_LineFromChar(es, index);
2984                 y = (l - es->y_offset) * es->line_height;
2985                 li = EDIT_EM_LineIndex(es, l);
2986                 if (after_wrap && (li == index) && l) {
2987                         INT l2 = l - 1;
2988                         line_def = es->first_line_def;
2989                         while (l2) {
2990                                 line_def = line_def->next;
2991                                 l2--;
2992                         }
2993                         if (line_def->ending == END_WRAP) {
2994                                 l--;
2995                                 y -= es->line_height;
2996                                 li = EDIT_EM_LineIndex(es, l);
2997                         }
2998                 }
2999
3000                 line_def = es->first_line_def;
3001                 while (line_def->index != li)
3002                         line_def = line_def->next;
3003
3004                 ll = line_def->net_length;
3005                 lw = line_def->width;
3006
3007                 w = es->format_rect.right - es->format_rect.left;
3008                 if (es->style & ES_RIGHT)
3009                 {
3010                         x = LOWORD(GetTabbedTextExtentW(dc, es->text + li + (index - li), ll - (index - li),
3011                                 es->tabs_count, es->tabs)) - es->x_offset;
3012                         x = w - x;
3013                 }
3014                 else if (es->style & ES_CENTER)
3015                 {
3016                         x = LOWORD(GetTabbedTextExtentW(dc, es->text + li, index - li,
3017                                 es->tabs_count, es->tabs)) - es->x_offset;
3018                         x += (w - lw) / 2;
3019                 }
3020                 else /* ES_LEFT */
3021                 {
3022                     x = LOWORD(GetTabbedTextExtentW(dc, es->text + li, index - li,
3023                                 es->tabs_count, es->tabs)) - es->x_offset;
3024                 }
3025         } else {
3026                 LPWSTR text = EDIT_GetPasswordPointer_SL(es);
3027                 if (index < es->x_offset) {
3028                         GetTextExtentPoint32W(dc, text + index,
3029                                         es->x_offset - index, &size);
3030                         x = -size.cx;
3031                 } else {
3032                         GetTextExtentPoint32W(dc, text + es->x_offset,
3033                                         index - es->x_offset, &size);
3034                          x = size.cx;
3035
3036                         if (!es->x_offset && (es->style & (ES_RIGHT | ES_CENTER)))
3037                         {
3038                                 w = es->format_rect.right - es->format_rect.left;
3039                                 if (w > es->text_width)
3040                                 {
3041                                         if (es->style & ES_RIGHT)
3042                                                 x += w - es->text_width;
3043                                         else if (es->style & ES_CENTER)
3044                                                 x += (w - es->text_width) / 2;
3045                                 }
3046                         }
3047                 }
3048                 y = 0;
3049                 if (es->style & ES_PASSWORD)
3050                         HeapFree(GetProcessHeap(), 0, text);
3051         }
3052         x += es->format_rect.left;
3053         y += es->format_rect.top;
3054         if (es->font)
3055                 SelectObject(dc, old_font);
3056         ReleaseDC(es->hwndSelf, dc);
3057         return MAKELONG((INT16)x, (INT16)y);
3058 }
3059
3060
3061 /*********************************************************************
3062  *
3063  *      EM_REPLACESEL
3064  *
3065  *      FIXME: handle ES_NUMBER and ES_OEMCONVERT here
3066  *
3067  */
3068 static void EDIT_EM_ReplaceSel(EDITSTATE *es, BOOL can_undo, LPCWSTR lpsz_replace, BOOL send_update, BOOL honor_limit)
3069 {
3070         UINT strl = strlenW(lpsz_replace);
3071         UINT tl = strlenW(es->text);
3072         UINT utl;
3073         UINT s;
3074         UINT e;
3075         UINT i;
3076         UINT size;
3077         LPWSTR p;
3078         HRGN hrgn = 0;
3079         LPWSTR buf = NULL;
3080         UINT bufl = 0;
3081
3082         TRACE("%s, can_undo %d, send_update %d\n",
3083             debugstr_w(lpsz_replace), can_undo, send_update);
3084
3085         s = es->selection_start;
3086         e = es->selection_end;
3087
3088         if ((s == e) && !strl)
3089                 return;
3090
3091         ORDER_UINT(s, e);
3092
3093         size = tl - (e - s) + strl;
3094         if (!size)
3095                 es->text_width = 0;
3096
3097         /* Issue the EN_MAXTEXT notification and continue with replacing text
3098          * such that buffer limit is honored. */
3099         if ((honor_limit) && (es->buffer_limit > 0) && (size > es->buffer_limit)) {
3100                 EDIT_NOTIFY_PARENT(es, EN_MAXTEXT);
3101                 strl = es->buffer_limit - (tl - (e-s));
3102         }
3103
3104         if (!EDIT_MakeFit(es, tl - (e - s) + strl))
3105                 return;
3106
3107         if (e != s) {
3108                 /* there is something to be deleted */
3109                 TRACE("deleting stuff.\n");
3110                 bufl = e - s;
3111                 buf = HeapAlloc(GetProcessHeap(), 0, (bufl + 1) * sizeof(WCHAR));
3112                 if (!buf) return;
3113                 memcpy(buf, es->text + s, bufl * sizeof(WCHAR));
3114                 buf[bufl] = 0; /* ensure 0 termination */
3115                 /* now delete */
3116                 strcpyW(es->text + s, es->text + e);
3117         }
3118         if (strl) {
3119                 /* there is an insertion */
3120                 tl = strlenW(es->text);
3121                 TRACE("inserting stuff (tl %d, strl %d, selstart %d ('%s'), text '%s')\n", tl, strl, s, debugstr_w(es->text + s), debugstr_w(es->text));
3122                 for (p = es->text + tl ; p >= es->text + s ; p--)
3123                         p[strl] = p[0];
3124                 for (i = 0 , p = es->text + s ; i < strl ; i++)
3125                         p[i] = lpsz_replace[i];
3126                 if(es->style & ES_UPPERCASE)
3127                         CharUpperBuffW(p, strl);
3128                 else if(es->style & ES_LOWERCASE)
3129                         CharLowerBuffW(p, strl);
3130         }
3131         if (es->style & ES_MULTILINE)
3132         {
3133                 INT st = min(es->selection_start, es->selection_end);
3134                 INT vlc = (es->format_rect.bottom - es->format_rect.top) / es->line_height;
3135
3136                 hrgn = CreateRectRgn(0, 0, 0, 0);
3137                 EDIT_BuildLineDefs_ML(es, st, st + strl,
3138                                 strl - abs(es->selection_end - es->selection_start), hrgn);
3139                 /* if text is too long undo all changes */
3140                 if (honor_limit && !(es->style & ES_AUTOVSCROLL) && (es->line_count > vlc)) {
3141                         if (strl)
3142                                 strcpyW(es->text + e, es->text + e + strl);
3143                         if (e != s)
3144                                 for (i = 0 , p = es->text ; i < e - s ; i++)
3145                                         p[i + s] = buf[i];
3146                         EDIT_BuildLineDefs_ML(es, s, e,
3147                                 abs(es->selection_end - es->selection_start) - strl, hrgn);
3148                         strl = 0;
3149                         e = s;
3150                         hrgn = CreateRectRgn(0, 0, 0, 0);
3151                         EDIT_NOTIFY_PARENT(es, EN_MAXTEXT);
3152                 }
3153         }
3154         else {
3155                 INT fw = es->format_rect.right - es->format_rect.left;
3156                 EDIT_CalcLineWidth_SL(es);
3157                 /* remove chars that don't fit */
3158                 if (honor_limit && !(es->style & ES_AUTOHSCROLL) && (es->text_width > fw)) {
3159                         while ((es->text_width > fw) && s + strl >= s) {
3160                                 strcpyW(es->text + s + strl - 1, es->text + s + strl);
3161                                 strl--;
3162                                 EDIT_CalcLineWidth_SL(es);
3163                         }
3164                         EDIT_NOTIFY_PARENT(es, EN_MAXTEXT);
3165                 }
3166         }
3167
3168         if (e != s) {
3169                 if (can_undo) {
3170                         utl = strlenW(es->undo_text);
3171                         if (!es->undo_insert_count && (*es->undo_text && (s == es->undo_position))) {
3172                                 /* undo-buffer is extended to the right */
3173                                 EDIT_MakeUndoFit(es, utl + e - s);
3174                                 memcpy(es->undo_text + utl, buf, (e - s)*sizeof(WCHAR));
3175                                 (es->undo_text + utl)[e - s] = 0; /* ensure 0 termination */
3176                         } else if (!es->undo_insert_count && (*es->undo_text && (e == es->undo_position))) {
3177                                 /* undo-buffer is extended to the left */
3178                                 EDIT_MakeUndoFit(es, utl + e - s);
3179                                 for (p = es->undo_text + utl ; p >= es->undo_text ; p--)
3180                                         p[e - s] = p[0];
3181                                 for (i = 0 , p = es->undo_text ; i < e - s ; i++)
3182                                         p[i] = buf[i];
3183                                 es->undo_position = s;
3184                         } else {
3185                                 /* new undo-buffer */
3186                                 EDIT_MakeUndoFit(es, e - s);
3187                                 memcpy(es->undo_text, buf, (e - s)*sizeof(WCHAR));
3188                                 es->undo_text[e - s] = 0; /* ensure 0 termination */
3189                                 es->undo_position = s;
3190                         }
3191                         /* any deletion makes the old insertion-undo invalid */
3192                         es->undo_insert_count = 0;
3193                 } else
3194                         EDIT_EM_EmptyUndoBuffer(es);
3195         }
3196         if (strl) {
3197                 if (can_undo) {
3198                         if ((s == es->undo_position) ||
3199                                 ((es->undo_insert_count) &&
3200                                 (s == es->undo_position + es->undo_insert_count)))
3201                                 /*
3202                                  * insertion is new and at delete position or
3203                                  * an extension to either left or right
3204                                  */
3205                                 es->undo_insert_count += strl;
3206                         else {
3207                                 /* new insertion undo */
3208                                 es->undo_position = s;
3209                                 es->undo_insert_count = strl;
3210                                 /* new insertion makes old delete-buffer invalid */
3211                                 *es->undo_text = '\0';
3212                         }
3213                 } else
3214                         EDIT_EM_EmptyUndoBuffer(es);
3215         }
3216
3217         if (bufl)
3218                 HeapFree(GetProcessHeap(), 0, buf);
3219
3220         s += strl;
3221
3222         /* If text has been deleted and we're right or center aligned then scroll rightward */
3223         if (es->style & (ES_RIGHT | ES_CENTER))
3224         {
3225                 INT delta = strl - abs(es->selection_end - es->selection_start);
3226
3227                 if (delta < 0 && es->x_offset)
3228                 {
3229                         if (abs(delta) > es->x_offset)
3230                                 es->x_offset = 0;
3231                         else
3232                                 es->x_offset += delta;
3233                 }
3234         }
3235
3236         EDIT_EM_SetSel(es, s, s, FALSE);
3237         es->flags |= EF_MODIFIED;
3238         if (send_update) es->flags |= EF_UPDATE;
3239         if (hrgn)
3240         {
3241                 EDIT_UpdateTextRegion(es, hrgn, TRUE);
3242                 DeleteObject(hrgn);
3243         }
3244         else
3245             EDIT_UpdateText(es, NULL, TRUE);
3246
3247         EDIT_EM_ScrollCaret(es);
3248
3249         /* force scroll info update */
3250         EDIT_UpdateScrollInfo(es);
3251
3252
3253         if(send_update || (es->flags & EF_UPDATE))
3254         {
3255             es->flags &= ~EF_UPDATE;
3256             EDIT_NOTIFY_PARENT(es, EN_CHANGE);
3257         }
3258 }
3259
3260
3261 /*********************************************************************
3262  *
3263  *      EM_SCROLL
3264  *
3265  */
3266 static LRESULT EDIT_EM_Scroll(EDITSTATE *es, INT action)
3267 {
3268         INT dy;
3269
3270         if (!(es->style & ES_MULTILINE))
3271                 return (LRESULT)FALSE;
3272
3273         dy = 0;
3274
3275         switch (action) {
3276         case SB_LINEUP:
3277                 if (es->y_offset)
3278                         dy = -1;
3279                 break;
3280         case SB_LINEDOWN:
3281                 if (es->y_offset < es->line_count - 1)
3282                         dy = 1;
3283                 break;
3284         case SB_PAGEUP:
3285                 if (es->y_offset)
3286                         dy = -(es->format_rect.bottom - es->format_rect.top) / es->line_height;
3287                 break;
3288         case SB_PAGEDOWN:
3289                 if (es->y_offset < es->line_count - 1)
3290                         dy = (es->format_rect.bottom - es->format_rect.top) / es->line_height;
3291                 break;
3292         default:
3293                 return (LRESULT)FALSE;
3294         }
3295         if (dy) {
3296             INT vlc = (es->format_rect.bottom - es->format_rect.top) / es->line_height;
3297             /* check if we are going to move too far */
3298             if(es->y_offset + dy > es->line_count - vlc)
3299                 dy = es->line_count - vlc - es->y_offset;
3300
3301             /* Notification is done in EDIT_EM_LineScroll */
3302             if(dy)
3303                 EDIT_EM_LineScroll(es, 0, dy);
3304         }
3305         return MAKELONG((INT16)dy, (BOOL16)TRUE);
3306 }
3307
3308
3309 /*********************************************************************
3310  *
3311  *      EM_SCROLLCARET
3312  *
3313  */
3314 static void EDIT_EM_ScrollCaret(EDITSTATE *es)
3315 {
3316         if (es->style & ES_MULTILINE) {
3317                 INT l;
3318                 INT li;
3319                 INT vlc;
3320                 INT ww;
3321                 INT cw = es->char_width;
3322                 INT x;
3323                 INT dy = 0;
3324                 INT dx = 0;
3325
3326                 l = EDIT_EM_LineFromChar(es, es->selection_end);
3327                 li = EDIT_EM_LineIndex(es, l);
3328                 x = (short)LOWORD(EDIT_EM_PosFromChar(es, es->selection_end, es->flags & EF_AFTER_WRAP));
3329                 vlc = (es->format_rect.bottom - es->format_rect.top) / es->line_height;
3330                 if (l >= es->y_offset + vlc)
3331                         dy = l - vlc + 1 - es->y_offset;
3332                 if (l < es->y_offset)
3333                         dy = l - es->y_offset;
3334                 ww = es->format_rect.right - es->format_rect.left;
3335                 if (x < es->format_rect.left)
3336                         dx = x - es->format_rect.left - ww / HSCROLL_FRACTION / cw * cw;
3337                 if (x > es->format_rect.right)
3338                         dx = x - es->format_rect.left - (HSCROLL_FRACTION - 1) * ww / HSCROLL_FRACTION / cw * cw;
3339                 if (dy || dx || (es->y_offset && (es->line_count - es->y_offset < vlc)))
3340                 {
3341                     /* check if we are going to move too far */
3342                     if(es->x_offset + dx + ww > es->text_width)
3343                         dx = es->text_width - ww - es->x_offset;
3344                     if(dx || dy || (es->y_offset && (es->line_count - es->y_offset < vlc)))
3345                         EDIT_EM_LineScroll_internal(es, dx, dy);
3346                 }
3347         } else {
3348                 INT x;
3349                 INT goal;
3350                 INT format_width;
3351
3352                 x = (short)LOWORD(EDIT_EM_PosFromChar(es, es->selection_end, FALSE));
3353                 format_width = es->format_rect.right - es->format_rect.left;
3354                 if (x < es->format_rect.left) {
3355                         goal = es->format_rect.left + format_width / HSCROLL_FRACTION;
3356                         do {
3357                                 es->x_offset--;
3358                                 x = (short)LOWORD(EDIT_EM_PosFromChar(es, es->selection_end, FALSE));
3359                         } while ((x < goal) && es->x_offset);
3360                         /* FIXME: use ScrollWindow() somehow to improve performance */
3361                         EDIT_UpdateText(es, NULL, TRUE);
3362                 } else if (x > es->format_rect.right) {
3363                         INT x_last;
3364                         INT len = strlenW(es->text);
3365                         goal = es->format_rect.right - format_width / HSCROLL_FRACTION;
3366                         do {
3367                                 es->x_offset++;
3368                                 x = (short)LOWORD(EDIT_EM_PosFromChar(es, es->selection_end, FALSE));
3369                                 x_last = (short)LOWORD(EDIT_EM_PosFromChar(es, len, FALSE));
3370                         } while ((x > goal) && (x_last > es->format_rect.right));
3371                         /* FIXME: use ScrollWindow() somehow to improve performance */
3372                         EDIT_UpdateText(es, NULL, TRUE);
3373                 }
3374         }
3375
3376     if(es->flags & EF_FOCUSED)
3377         EDIT_SetCaretPos(es, es->selection_end, es->flags & EF_AFTER_WRAP);
3378 }
3379
3380
3381 /*********************************************************************
3382  *
3383  *      EM_SETHANDLE
3384  *
3385  *      FIXME:  ES_LOWERCASE, ES_UPPERCASE, ES_OEMCONVERT, ES_NUMBER ???
3386  *
3387  */
3388 static void EDIT_EM_SetHandle(EDITSTATE *es, HLOCAL hloc)
3389 {
3390         if (!(es->style & ES_MULTILINE))
3391                 return;
3392
3393         if (!hloc) {
3394                 WARN("called with NULL handle\n");
3395                 return;
3396         }
3397
3398         EDIT_UnlockBuffer(es, TRUE);
3399
3400         if(es->hloc16)
3401         {
3402             STACK16FRAME* stack16 = MapSL((SEGPTR)NtCurrentTeb()->WOW32Reserved);
3403             HANDLE16 oldDS = stack16->ds;
3404
3405             stack16->ds = GetWindowLongPtrW( es->hwndSelf, GWLP_HINSTANCE );
3406             LocalFree16(es->hloc16);
3407             stack16->ds = oldDS;
3408             es->hloc16 = 0;
3409         }
3410
3411         if(es->is_unicode)
3412         {
3413             if(es->hloc32A)
3414             {
3415                 LocalFree(es->hloc32A);
3416                 es->hloc32A = NULL;
3417             }
3418             es->hloc32W = hloc;
3419         }
3420         else
3421         {
3422             INT countW, countA;
3423             HLOCAL hloc32W_new;
3424             WCHAR *textW;
3425             CHAR *textA;
3426
3427             countA = LocalSize(hloc);
3428             textA = LocalLock(hloc);
3429             countW = MultiByteToWideChar(CP_ACP, 0, textA, countA, NULL, 0);
3430             if(!(hloc32W_new = LocalAlloc(LMEM_MOVEABLE | LMEM_ZEROINIT, countW * sizeof(WCHAR))))
3431             {
3432                 ERR("Could not allocate new unicode buffer\n");
3433                 return;
3434             }
3435             textW = LocalLock(hloc32W_new);
3436             MultiByteToWideChar(CP_ACP, 0, textA, countA, textW, countW);
3437             LocalUnlock(hloc32W_new);
3438             LocalUnlock(hloc);
3439
3440             if(es->hloc32W)
3441                 LocalFree(es->hloc32W);
3442
3443             es->hloc32W = hloc32W_new;
3444             es->hloc32A = hloc;
3445         }
3446
3447         es->buffer_size = LocalSize(es->hloc32W)/sizeof(WCHAR) - 1;
3448
3449         EDIT_LockBuffer(es);
3450
3451         es->x_offset = es->y_offset = 0;
3452         es->selection_start = es->selection_end = 0;
3453         EDIT_EM_EmptyUndoBuffer(es);
3454         es->flags &= ~EF_MODIFIED;
3455         es->flags &= ~EF_UPDATE;
3456         EDIT_BuildLineDefs_ML(es, 0, strlenW(es->text), 0, NULL);
3457         EDIT_UpdateText(es, NULL, TRUE);
3458         EDIT_EM_ScrollCaret(es);
3459         /* force scroll info update */
3460         EDIT_UpdateScrollInfo(es);
3461 }
3462
3463
3464 /*********************************************************************
3465  *
3466  *      EM_SETHANDLE16
3467  *
3468  *      FIXME:  ES_LOWERCASE, ES_UPPERCASE, ES_OEMCONVERT, ES_NUMBER ???
3469  *
3470  */
3471 static void EDIT_EM_SetHandle16(EDITSTATE *es, HLOCAL16 hloc)
3472 {
3473         STACK16FRAME* stack16 = MapSL((SEGPTR)NtCurrentTeb()->WOW32Reserved);
3474         HINSTANCE16 hInstance = GetWindowLongPtrW( es->hwndSelf, GWLP_HINSTANCE );
3475         HANDLE16 oldDS = stack16->ds;
3476         INT countW, countA;
3477         HLOCAL hloc32W_new;
3478         WCHAR *textW;
3479         CHAR *textA;
3480
3481         if (!(es->style & ES_MULTILINE))
3482                 return;
3483
3484         if (!hloc) {
3485                 WARN("called with NULL handle\n");
3486                 return;
3487         }
3488
3489         EDIT_UnlockBuffer(es, TRUE);
3490
3491         if(es->hloc32A)
3492         {
3493             LocalFree(es->hloc32A);
3494             es->hloc32A = NULL;
3495         }
3496
3497         stack16->ds = hInstance;
3498         countA = LocalSize16(hloc);
3499         textA = MapSL(LocalLock16(hloc));
3500         countW = MultiByteToWideChar(CP_ACP, 0, textA, countA, NULL, 0);
3501         if(!(hloc32W_new = LocalAlloc(LMEM_MOVEABLE | LMEM_ZEROINIT, countW * sizeof(WCHAR))))
3502         {
3503             ERR("Could not allocate new unicode buffer\n");
3504             return;
3505         }
3506         textW = LocalLock(hloc32W_new);
3507         MultiByteToWideChar(CP_ACP, 0, textA, countA, textW, countW);
3508         LocalUnlock(hloc32W_new);
3509         LocalUnlock16(hloc);
3510         stack16->ds = oldDS;
3511
3512         if(es->hloc32W)
3513             LocalFree(es->hloc32W);
3514
3515         es->hloc32W = hloc32W_new;
3516         es->hloc16 = hloc;
3517
3518         es->buffer_size = LocalSize(es->hloc32W)/sizeof(WCHAR) - 1;
3519
3520         EDIT_LockBuffer(es);
3521
3522         es->x_offset = es->y_offset = 0;
3523         es->selection_start = es->selection_end = 0;
3524         EDIT_EM_EmptyUndoBuffer(es);
3525         es->flags &= ~EF_MODIFIED;
3526         es->flags &= ~EF_UPDATE;
3527         EDIT_BuildLineDefs_ML(es, 0, strlenW(es->text), 0, NULL);
3528         EDIT_UpdateText(es, NULL, TRUE);
3529         EDIT_EM_ScrollCaret(es);
3530         /* force scroll info update */
3531         EDIT_UpdateScrollInfo(es);
3532 }
3533
3534
3535 /*********************************************************************
3536  *
3537  *      EM_SETLIMITTEXT
3538  *
3539  *      FIXME: in WinNT maxsize is 0x7FFFFFFF / 0xFFFFFFFF
3540  *      However, the windows version is not complied to yet in all of edit.c
3541  *
3542  *  Additionally as the wrapper for RichEdit controls we need larger buffers
3543  *  at present -1 will represent nolimit
3544  */
3545 static void EDIT_EM_SetLimitText(EDITSTATE *es, INT limit)
3546 {
3547     if (limit == 0xFFFFFFFF)
3548         es->buffer_limit = -1;
3549     else if (es->style & ES_MULTILINE) {
3550                 if (limit)
3551                         es->buffer_limit = min(limit, BUFLIMIT_MULTI);
3552                 else
3553                         es->buffer_limit = BUFLIMIT_MULTI;
3554         } else {
3555                 if (limit)
3556                         es->buffer_limit = min(limit, BUFLIMIT_SINGLE);
3557                 else
3558                         es->buffer_limit = BUFLIMIT_SINGLE;
3559         }
3560 }
3561
3562
3563 /*********************************************************************
3564  *
3565  *      EM_SETMARGINS
3566  *
3567  * EC_USEFONTINFO is used as a left or right value i.e. lParam and not as an
3568  * action wParam despite what the docs say. EC_USEFONTINFO calculates the
3569  * margin according to the textmetrics of the current font.
3570  *
3571  * FIXME - With TrueType or vector fonts EC_USEFONTINFO currently sets one third
3572  * of the char's width as the margin, but this is not how Windows handles this.
3573  * For all other fonts Windows sets the margins to zero.
3574  *
3575  */
3576 static void EDIT_EM_SetMargins(EDITSTATE *es, INT action,
3577                                INT left, INT right, BOOL repaint)
3578 {
3579         TEXTMETRICW tm;
3580         INT default_left_margin  = 0; /* in pixels */
3581         INT default_right_margin = 0; /* in pixels */
3582
3583         /* Set the default margins depending on the font */
3584         if (es->font && (left == EC_USEFONTINFO || right == EC_USEFONTINFO)) {
3585             HDC dc = GetDC(es->hwndSelf);
3586             HFONT old_font = SelectObject(dc, es->font);
3587             GetTextMetricsW(dc, &tm);
3588             /* The default margins are only non zero for TrueType or Vector fonts */
3589             if (tm.tmPitchAndFamily & ( TMPF_VECTOR | TMPF_TRUETYPE )) {
3590                 /* This must be calculated more exactly! But how? */
3591                 default_left_margin = tm.tmAveCharWidth / 3;
3592                 default_right_margin = tm.tmAveCharWidth / 3;
3593             }
3594             SelectObject(dc, old_font);
3595             ReleaseDC(es->hwndSelf, dc);
3596         }
3597
3598         if (action & EC_LEFTMARGIN) {
3599                 es->format_rect.left -= es->left_margin;
3600                 if (left != EC_USEFONTINFO)
3601                         es->left_margin = left;
3602                 else
3603                         es->left_margin = default_left_margin;
3604                 es->format_rect.left += es->left_margin;
3605         }
3606
3607         if (action & EC_RIGHTMARGIN) {
3608                 es->format_rect.right += es->right_margin;
3609                 if (right != EC_USEFONTINFO)
3610                         es->right_margin = right;
3611                 else
3612                         es->right_margin = default_right_margin;
3613                 es->format_rect.right -= es->right_margin;
3614         }
3615
3616         if (action & (EC_LEFTMARGIN | EC_RIGHTMARGIN)) {
3617                 EDIT_AdjustFormatRect(es);
3618                 if (repaint) EDIT_UpdateText(es, NULL, TRUE);
3619         }
3620
3621         TRACE("left=%d, right=%d\n", es->left_margin, es->right_margin);
3622 }
3623
3624
3625 /*********************************************************************
3626  *
3627  *      EM_SETPASSWORDCHAR
3628  *
3629  */
3630 static void EDIT_EM_SetPasswordChar(EDITSTATE *es, WCHAR c)
3631 {
3632         LONG style;
3633
3634         if (es->style & ES_MULTILINE)
3635                 return;
3636
3637         if (es->password_char == c)
3638                 return;
3639
3640         style = GetWindowLongW( es->hwndSelf, GWL_STYLE );
3641         es->password_char = c;
3642         if (c) {
3643             SetWindowLongW( es->hwndSelf, GWL_STYLE, style | ES_PASSWORD );
3644             es->style |= ES_PASSWORD;
3645         } else {
3646             SetWindowLongW( es->hwndSelf, GWL_STYLE, style & ~ES_PASSWORD );
3647             es->style &= ~ES_PASSWORD;
3648         }
3649         EDIT_UpdateText(es, NULL, TRUE);
3650 }
3651
3652
3653 /*********************************************************************
3654  *
3655  *      EDIT_EM_SetSel
3656  *
3657  *      note:   unlike the specs say: the order of start and end
3658  *              _is_ preserved in Windows.  (i.e. start can be > end)
3659  *              In other words: this handler is OK
3660  *
3661  */
3662 static void EDIT_EM_SetSel(EDITSTATE *es, UINT start, UINT end, BOOL after_wrap)
3663 {
3664         UINT old_start = es->selection_start;
3665         UINT old_end = es->selection_end;
3666         UINT len = strlenW(es->text);
3667
3668         if (start == (UINT)-1) {
3669                 start = es->selection_end;
3670                 end = es->selection_end;
3671         } else {
3672                 start = min(start, len);
3673                 end = min(end, len);
3674         }
3675         es->selection_start = start;
3676         es->selection_end = end;
3677         if (after_wrap)
3678                 es->flags |= EF_AFTER_WRAP;
3679         else
3680                 es->flags &= ~EF_AFTER_WRAP;
3681         /* Compute the necessary invalidation region. */
3682         /* Note that we don't need to invalidate regions which have
3683          * "never" been selected, or those which are "still" selected.
3684          * In fact, every time we hit a selection boundary, we can
3685          * *toggle* whether we need to invalidate.  Thus we can optimize by
3686          * *sorting* the interval endpoints.  Let's assume that we sort them
3687          * in this order:
3688          *        start <= end <= old_start <= old_end
3689          * Knuth 5.3.1 (p 183) asssures us that this can be done optimally
3690          * in 5 comparisons; ie it's impossible to do better than the
3691          * following: */
3692         ORDER_UINT(end, old_end);
3693         ORDER_UINT(start, old_start);
3694         ORDER_UINT(old_start, old_end);
3695         ORDER_UINT(start, end);
3696         /* Note that at this point 'end' and 'old_start' are not in order, but
3697          * start is definitely the min. and old_end is definitely the max. */
3698         if (end != old_start)
3699         {
3700 /*
3701  * One can also do
3702  *          ORDER_UINT32(end, old_start);
3703  *          EDIT_InvalidateText(es, start, end);
3704  *          EDIT_InvalidateText(es, old_start, old_end);
3705  * in place of the following if statement.
3706  * (That would complete the optimal five-comparison four-element sort.)
3707  */
3708             if (old_start > end )
3709             {
3710                 EDIT_InvalidateText(es, start, end);
3711                 EDIT_InvalidateText(es, old_start, old_end);
3712             }
3713             else
3714             {
3715                 EDIT_InvalidateText(es, start, old_start);
3716                 EDIT_InvalidateText(es, end, old_end);
3717             }
3718         }
3719         else EDIT_InvalidateText(es, start, old_end);
3720 }
3721
3722
3723 /*********************************************************************
3724  *
3725  *      EM_SETTABSTOPS
3726  *
3727  */
3728 static BOOL EDIT_EM_SetTabStops(EDITSTATE *es, INT count, LPINT tabs)
3729 {
3730         if (!(es->style & ES_MULTILINE))
3731                 return FALSE;
3732         HeapFree(GetProcessHeap(), 0, es->tabs);
3733         es->tabs_count = count;
3734         if (!count)
3735                 es->tabs = NULL;
3736         else {
3737                 es->tabs = HeapAlloc(GetProcessHeap(), 0, count * sizeof(INT));
3738                 memcpy(es->tabs, tabs, count * sizeof(INT));
3739         }
3740         return TRUE;
3741 }
3742
3743
3744 /*********************************************************************
3745  *
3746  *      EM_SETTABSTOPS16
3747  *
3748  */
3749 static BOOL EDIT_EM_SetTabStops16(EDITSTATE *es, INT count, LPINT16 tabs)
3750 {
3751         if (!(es->style & ES_MULTILINE))
3752                 return FALSE;
3753         HeapFree(GetProcessHeap(), 0, es->tabs);
3754         es->tabs_count = count;
3755         if (!count)
3756                 es->tabs = NULL;
3757         else {
3758                 INT i;
3759                 es->tabs = HeapAlloc(GetProcessHeap(), 0, count * sizeof(INT));
3760                 for (i = 0 ; i < count ; i++)
3761                         es->tabs[i] = *tabs++;
3762         }
3763         return TRUE;
3764 }
3765
3766
3767 /*********************************************************************
3768  *
3769  *      EM_SETWORDBREAKPROC
3770  *
3771  */
3772 static void EDIT_EM_SetWordBreakProc(EDITSTATE *es, void *wbp)
3773 {
3774         if (es->word_break_proc == wbp)
3775                 return;
3776
3777         es->word_break_proc = wbp;
3778         es->word_break_proc16 = NULL;
3779
3780         if ((es->style & ES_MULTILINE) && !(es->style & ES_AUTOHSCROLL)) {
3781                 EDIT_BuildLineDefs_ML(es, 0, strlenW(es->text), 0, NULL);
3782                 EDIT_UpdateText(es, NULL, TRUE);
3783         }
3784 }
3785
3786
3787 /*********************************************************************
3788  *
3789  *      EM_SETWORDBREAKPROC16
3790  *
3791  */
3792 static void EDIT_EM_SetWordBreakProc16(EDITSTATE *es, EDITWORDBREAKPROC16 wbp)
3793 {
3794         if (es->word_break_proc16 == wbp)
3795                 return;
3796
3797         es->word_break_proc = NULL;
3798         es->word_break_proc16 = wbp;
3799         if ((es->style & ES_MULTILINE) && !(es->style & ES_AUTOHSCROLL)) {
3800                 EDIT_BuildLineDefs_ML(es, 0, strlenW(es->text), 0, NULL);
3801                 EDIT_UpdateText(es, NULL, TRUE);
3802         }
3803 }
3804
3805
3806 /*********************************************************************
3807  *
3808  *      EM_UNDO / WM_UNDO
3809  *
3810  */
3811 static BOOL EDIT_EM_Undo(EDITSTATE *es)
3812 {
3813         INT ulength;
3814         LPWSTR utext;
3815
3816         /* As per MSDN spec, for a single-line edit control,
3817            the return value is always TRUE */
3818         if( es->style & ES_READONLY )
3819             return !(es->style & ES_MULTILINE);
3820
3821         ulength = strlenW(es->undo_text);
3822
3823         utext = HeapAlloc(GetProcessHeap(), 0, (ulength + 1) * sizeof(WCHAR));
3824
3825         strcpyW(utext, es->undo_text);
3826
3827         TRACE("before UNDO:insertion length = %d, deletion buffer = %s\n",
3828                      es->undo_insert_count, debugstr_w(utext));
3829
3830         EDIT_EM_SetSel(es, es->undo_position, es->undo_position + es->undo_insert_count, FALSE);
3831         EDIT_EM_EmptyUndoBuffer(es);
3832         EDIT_EM_ReplaceSel(es, TRUE, utext, TRUE, TRUE);
3833         EDIT_EM_SetSel(es, es->undo_position, es->undo_position + es->undo_insert_count, FALSE);
3834         /* send the notification after the selection start and end are set */
3835         EDIT_NOTIFY_PARENT(es, EN_CHANGE);
3836         EDIT_EM_ScrollCaret(es);
3837         HeapFree(GetProcessHeap(), 0, utext);
3838
3839         TRACE("after UNDO:insertion length = %d, deletion buffer = %s\n",
3840                         es->undo_insert_count, debugstr_w(es->undo_text));
3841         return TRUE;
3842 }
3843
3844
3845 /*********************************************************************
3846  *
3847  *      WM_CHAR
3848  *
3849  */
3850 static void EDIT_WM_Char(EDITSTATE *es, WCHAR c)
3851 {
3852         BOOL control;
3853
3854         control = GetKeyState(VK_CONTROL) & 0x8000;
3855
3856         switch (c) {
3857         case '\r':
3858             /* If the edit doesn't want the return and it's not a multiline edit, do nothing */
3859             if(!(es->style & ES_MULTILINE) && !(es->style & ES_WANTRETURN))
3860                 break;
3861         case '\n':
3862                 if (es->style & ES_MULTILINE) {
3863                         if (es->style & ES_READONLY) {
3864                                 EDIT_MoveHome(es, FALSE);
3865                                 EDIT_MoveDown_ML(es, FALSE);
3866                         } else {
3867                                 static const WCHAR cr_lfW[] = {'\r','\n',0};
3868                                 EDIT_EM_ReplaceSel(es, TRUE, cr_lfW, TRUE, TRUE);
3869                         }
3870                 }
3871                 break;
3872         case '\t':
3873                 if ((es->style & ES_MULTILINE) && !(es->style & ES_READONLY))
3874                 {
3875                         static const WCHAR tabW[] = {'\t',0};
3876                         EDIT_EM_ReplaceSel(es, TRUE, tabW, TRUE, TRUE);
3877                 }
3878                 break;
3879         case VK_BACK:
3880                 if (!(es->style & ES_READONLY) && !control) {
3881                         if (es->selection_start != es->selection_end)
3882                                 EDIT_WM_Clear(es);
3883                         else {
3884                                 /* delete character left of caret */
3885                                 EDIT_EM_SetSel(es, (UINT)-1, 0, FALSE);
3886                                 EDIT_MoveBackward(es, TRUE);
3887                                 EDIT_WM_Clear(es);
3888                         }
3889                 }
3890                 break;
3891         case 0x03: /* ^C */
3892                 SendMessageW(es->hwndSelf, WM_COPY, 0, 0);
3893                 break;
3894         case 0x16: /* ^V */
3895                 if (!(es->style & ES_READONLY))
3896                     SendMessageW(es->hwndSelf, WM_PASTE, 0, 0);
3897                 break;
3898         case 0x18: /* ^X */
3899                 if (!(es->style & ES_READONLY))
3900                     SendMessageW(es->hwndSelf, WM_CUT, 0, 0);
3901                 break;
3902
3903         default:
3904                 /*If Edit control style is ES_NUMBER allow users to key in only numeric values*/
3905                 if( (es->style & ES_NUMBER) && !( c >= '0' && c <= '9') )
3906                         break;
3907
3908                 if (!(es->style & ES_READONLY) && (c >= ' ') && (c != 127)) {
3909                         WCHAR str[2];
3910                         str[0] = c;
3911                         str[1] = '\0';
3912                         EDIT_EM_ReplaceSel(es, TRUE, str, TRUE, TRUE);
3913                 }
3914                 break;
3915         }
3916 }
3917
3918
3919 /*********************************************************************
3920  *
3921  *      WM_COMMAND
3922  *
3923  */
3924 static void EDIT_WM_Command(EDITSTATE *es, INT code, INT id, HWND control)
3925 {
3926         if (code || control)
3927                 return;
3928
3929         switch (id) {
3930                 case EM_UNDO:
3931                         EDIT_EM_Undo(es);
3932                         break;
3933                 case WM_CUT:
3934                         EDIT_WM_Cut(es);
3935                         break;
3936                 case WM_COPY:
3937                         EDIT_WM_Copy(es);
3938                         break;
3939                 case WM_PASTE:
3940                         EDIT_WM_Paste(es);
3941                         break;
3942                 case WM_CLEAR:
3943                         EDIT_WM_Clear(es);
3944                         break;
3945                 case EM_SETSEL:
3946                         EDIT_EM_SetSel(es, 0, (UINT)-1, FALSE);
3947                         EDIT_EM_ScrollCaret(es);
3948                         break;
3949                 default:
3950                         ERR("unknown menu item, please report\n");
3951                         break;
3952         }
3953 }
3954
3955
3956 /*********************************************************************
3957  *
3958  *      WM_CONTEXTMENU
3959  *
3960  *      Note: the resource files resource/sysres_??.rc cannot define a
3961  *              single popup menu.  Hence we use a (dummy) menubar
3962  *              containing the single popup menu as its first item.
3963  *
3964  *      FIXME: the message identifiers have been chosen arbitrarily,
3965  *              hence we use MF_BYPOSITION.
3966  *              We might as well use the "real" values (anybody knows ?)
3967  *              The menu definition is in resources/sysres_??.rc.
3968  *              Once these are OK, we better use MF_BYCOMMAND here
3969  *              (as we do in EDIT_WM_Command()).
3970  *
3971  */
3972 static void EDIT_WM_ContextMenu(EDITSTATE *es, INT x, INT y)
3973 {
3974         HMENU menu = LoadMenuA(user32_module, "EDITMENU");
3975         HMENU popup = GetSubMenu(menu, 0);
3976         UINT start = es->selection_start;
3977         UINT end = es->selection_end;
3978
3979         ORDER_UINT(start, end);
3980
3981         /* undo */
3982         EnableMenuItem(popup, 0, MF_BYPOSITION | (EDIT_EM_CanUndo(es) && !(es->style & ES_READONLY) ? MF_ENABLED : MF_GRAYED));
3983         /* cut */
3984         EnableMenuItem(popup, 2, MF_BYPOSITION | ((end - start) && !(es->style & ES_PASSWORD) && !(es->style & ES_READONLY) ? MF_ENABLED : MF_GRAYED));
3985         /* copy */
3986         EnableMenuItem(popup, 3, MF_BYPOSITION | ((end - start) && !(es->style & ES_PASSWORD) ? MF_ENABLED : MF_GRAYED));
3987         /* paste */
3988         EnableMenuItem(popup, 4, MF_BYPOSITION | (IsClipboardFormatAvailable(CF_UNICODETEXT) && !(es->style & ES_READONLY) ? MF_ENABLED : MF_GRAYED));
3989         /* delete */
3990         EnableMenuItem(popup, 5, MF_BYPOSITION | ((end - start) && !(es->style & ES_READONLY) ? MF_ENABLED : MF_GRAYED));
3991         /* select all */
3992         EnableMenuItem(popup, 7, MF_BYPOSITION | (start || (end != strlenW(es->text)) ? MF_ENABLED : MF_GRAYED));
3993
3994         TrackPopupMenu(popup, TPM_LEFTALIGN | TPM_RIGHTBUTTON, x, y, 0, es->hwndSelf, NULL);
3995         DestroyMenu(menu);
3996 }
3997
3998
3999 /*********************************************************************
4000  *
4001  *      WM_COPY
4002  *
4003  */
4004 static void EDIT_WM_Copy(EDITSTATE *es)
4005 {
4006         INT s = min(es->selection_start, es->selection_end);
4007         INT e = max(es->selection_start, es->selection_end);
4008         HGLOBAL hdst;
4009         LPWSTR dst;
4010         DWORD len;
4011
4012         if (e == s) return;
4013
4014         len = e - s;
4015         hdst = GlobalAlloc(GMEM_MOVEABLE | GMEM_DDESHARE, (len + 1) * sizeof(WCHAR));
4016         dst = GlobalLock(hdst);
4017         memcpy(dst, es->text + s, len * sizeof(WCHAR));
4018         dst[len] = 0; /* ensure 0 termination */
4019         TRACE("%s\n", debugstr_w(dst));
4020         GlobalUnlock(hdst);
4021         OpenClipboard(es->hwndSelf);
4022         EmptyClipboard();
4023         SetClipboardData(CF_UNICODETEXT, hdst);
4024         CloseClipboard();
4025 }
4026
4027
4028 /*********************************************************************
4029  *
4030  *      WM_CREATE
4031  *
4032  */
4033 static LRESULT EDIT_WM_Create(EDITSTATE *es, LPCWSTR name)
4034 {
4035         RECT clientRect;
4036
4037         TRACE("%s\n", debugstr_w(name));
4038        /*
4039         *       To initialize some final structure members, we call some helper
4040         *       functions.  However, since the EDITSTATE is not consistent (i.e.
4041         *       not fully initialized), we should be very careful which
4042         *       functions can be called, and in what order.
4043         */
4044         EDIT_WM_SetFont(es, 0, FALSE);
4045         EDIT_EM_EmptyUndoBuffer(es);
4046
4047         /* We need to calculate the format rect
4048            (applications may send EM_SETMARGINS before the control gets visible) */
4049         GetClientRect(es->hwndSelf, &clientRect);
4050         EDIT_SetRectNP(es, &clientRect);
4051
4052        if (name && *name) {
4053            EDIT_EM_ReplaceSel(es, FALSE, name, FALSE, TRUE);
4054            /* if we insert text to the editline, the text scrolls out
4055             * of the window, as the caret is placed after the insert
4056             * pos normally; thus we reset es->selection... to 0 and
4057             * update caret
4058             */
4059            es->selection_start = es->selection_end = 0;
4060            /* Adobe Photoshop does NOT like this. and MSDN says that EN_CHANGE
4061             * Messages are only to be sent when the USER does something to
4062             * change the contents. So I am removing this EN_CHANGE
4063             *
4064             * EDIT_NOTIFY_PARENT(es, EN_CHANGE);
4065             */
4066            EDIT_EM_ScrollCaret(es);
4067        }
4068        /* force scroll info update */
4069        EDIT_UpdateScrollInfo(es);
4070        /* The rule seems to return 1 here for success */
4071        /* Power Builder masked edit controls will crash  */
4072        /* if not. */
4073        /* FIXME: is that in all cases so ? */
4074        return 1;
4075 }
4076
4077
4078 /*********************************************************************
4079  *
4080  *      WM_DESTROY
4081  *
4082  */
4083 static LRESULT EDIT_WM_Destroy(EDITSTATE *es)
4084 {
4085         LINEDEF *pc, *pp;
4086
4087         if (es->hloc32W) {
4088                 while (LocalUnlock(es->hloc32W)) ;
4089                 LocalFree(es->hloc32W);
4090         }
4091         if (es->hloc32A) {
4092                 while (LocalUnlock(es->hloc32A)) ;
4093                 LocalFree(es->hloc32A);
4094         }
4095         if (es->hloc16) {
4096                 STACK16FRAME* stack16 = MapSL((SEGPTR)NtCurrentTeb()->WOW32Reserved);
4097                 HANDLE16 oldDS = stack16->ds;
4098
4099                 stack16->ds = GetWindowLongPtrW( es->hwndSelf, GWLP_HINSTANCE );
4100                 while (LocalUnlock16(es->hloc16)) ;
4101                 LocalFree16(es->hloc16);
4102                 stack16->ds = oldDS;
4103         }
4104
4105         pc = es->first_line_def;
4106         while (pc)
4107         {
4108                 pp = pc->next;
4109                 HeapFree(GetProcessHeap(), 0, pc);
4110                 pc = pp;
4111         }
4112
4113         SetWindowLongW( es->hwndSelf, 0, 0 );
4114         HeapFree(GetProcessHeap(), 0, es);
4115
4116         return 0;
4117 }
4118
4119
4120 /*********************************************************************
4121  *
4122  *      WM_ERASEBKGND
4123  *
4124  */
4125 static LRESULT EDIT_WM_EraseBkGnd(EDITSTATE *es, HDC dc)
4126 {
4127     /* we do the proper erase in EDIT_WM_Paint */
4128     return -1;
4129 }
4130
4131
4132 /*********************************************************************
4133  *
4134  *      WM_GETTEXT
4135  *
4136  */
4137 static INT EDIT_WM_GetText(EDITSTATE *es, INT count, LPWSTR dst, BOOL unicode)
4138 {
4139     if(!count) return 0;
4140
4141     if(unicode)
4142     {
4143         lstrcpynW(dst, es->text, count);
4144         return strlenW(dst);
4145     }
4146     else
4147     {
4148         LPSTR textA = (LPSTR)dst;
4149         if (!WideCharToMultiByte(CP_ACP, 0, es->text, -1, textA, count, NULL, NULL))
4150             textA[count - 1] = 0; /* ensure 0 termination */
4151         return strlen(textA);
4152     }
4153 }
4154
4155 /*********************************************************************
4156  *
4157  *      WM_HSCROLL
4158  *
4159  */
4160 static LRESULT EDIT_WM_HScroll(EDITSTATE *es, INT action, INT pos)
4161 {
4162         INT dx;
4163         INT fw;
4164
4165         if (!(es->style & ES_MULTILINE))
4166                 return 0;
4167
4168         if (!(es->style & ES_AUTOHSCROLL))
4169                 return 0;
4170
4171         dx = 0;
4172         fw = es->format_rect.right - es->format_rect.left;
4173         switch (action) {
4174         case SB_LINELEFT:
4175                 TRACE("SB_LINELEFT\n");
4176                 if (es->x_offset)
4177                         dx = -es->char_width;
4178                 break;
4179         case SB_LINERIGHT:
4180                 TRACE("SB_LINERIGHT\n");
4181                 if (es->x_offset < es->text_width)
4182                         dx = es->char_width;
4183                 break;
4184         case SB_PAGELEFT:
4185                 TRACE("SB_PAGELEFT\n");
4186                 if (es->x_offset)
4187                         dx = -fw / HSCROLL_FRACTION / es->char_width * es->char_width;
4188                 break;
4189         case SB_PAGERIGHT:
4190                 TRACE("SB_PAGERIGHT\n");
4191                 if (es->x_offset < es->text_width)
4192                         dx = fw / HSCROLL_FRACTION / es->char_width * es->char_width;
4193                 break;
4194         case SB_LEFT:
4195                 TRACE("SB_LEFT\n");
4196                 if (es->x_offset)
4197                         dx = -es->x_offset;
4198                 break;
4199         case SB_RIGHT:
4200                 TRACE("SB_RIGHT\n");
4201                 if (es->x_offset < es->text_width)
4202                         dx = es->text_width - es->x_offset;
4203                 break;
4204         case SB_THUMBTRACK:
4205                 TRACE("SB_THUMBTRACK %d\n", pos);
4206                 es->flags |= EF_HSCROLL_TRACK;
4207                 if(es->style & WS_HSCROLL)
4208                     dx = pos - es->x_offset;
4209                 else
4210                 {
4211                     INT fw, new_x;
4212                     /* Sanity check */
4213                     if(pos < 0 || pos > 100) return 0;
4214                     /* Assume default scroll range 0-100 */
4215                     fw = es->format_rect.right - es->format_rect.left;
4216                     new_x = pos * (es->text_width - fw) / 100;
4217                     dx = es->text_width ? (new_x - es->x_offset) : 0;
4218                 }
4219                 break;
4220         case SB_THUMBPOSITION:
4221                 TRACE("SB_THUMBPOSITION %d\n", pos);
4222                 es->flags &= ~EF_HSCROLL_TRACK;
4223                 if(GetWindowLongW( es->hwndSelf, GWL_STYLE ) & WS_HSCROLL)
4224                     dx = pos - es->x_offset;
4225                 else
4226                 {
4227                     INT fw, new_x;
4228                     /* Sanity check */
4229                     if(pos < 0 || pos > 100) return 0;
4230                     /* Assume default scroll range 0-100 */
4231                     fw = es->format_rect.right - es->format_rect.left;
4232                     new_x = pos * (es->text_width - fw) / 100;
4233                     dx = es->text_width ? (new_x - es->x_offset) : 0;
4234                 }
4235                 if (!dx) {
4236                         /* force scroll info update */
4237                         EDIT_UpdateScrollInfo(es);
4238                         EDIT_NOTIFY_PARENT(es, EN_HSCROLL);
4239                 }
4240                 break;
4241         case SB_ENDSCROLL:
4242                 TRACE("SB_ENDSCROLL\n");
4243                 break;
4244         /*
4245          *      FIXME : the next two are undocumented !
4246          *      Are we doing the right thing ?
4247          *      At least Win 3.1 Notepad makes use of EM_GETTHUMB this way,
4248          *      although it's also a regular control message.
4249          */
4250         case EM_GETTHUMB: /* this one is used by NT notepad */
4251         case EM_GETTHUMB16:
4252         {
4253                 LRESULT ret;
4254                 if(GetWindowLongW( es->hwndSelf, GWL_STYLE ) & WS_HSCROLL)
4255                     ret = GetScrollPos(es->hwndSelf, SB_HORZ);
4256                 else
4257                 {
4258                     /* Assume default scroll range 0-100 */
4259                     INT fw = es->format_rect.right - es->format_rect.left;
4260                     ret = es->text_width ? es->x_offset * 100 / (es->text_width - fw) : 0;
4261                 }
4262                 TRACE("EM_GETTHUMB: returning %ld\n", ret);
4263                 return ret;
4264         }
4265         case EM_LINESCROLL16:
4266                 TRACE("EM_LINESCROLL16\n");
4267                 dx = pos;
4268                 break;
4269
4270         default:
4271                 ERR("undocumented WM_HSCROLL action %d (0x%04x), please report\n",
4272                     action, action);
4273                 return 0;
4274         }
4275         if (dx)
4276         {
4277             INT fw = es->format_rect.right - es->format_rect.left;
4278             /* check if we are going to move too far */
4279             if(es->x_offset + dx + fw > es->text_width)
4280                 dx = es->text_width - fw - es->x_offset;
4281             if(dx)
4282                 EDIT_EM_LineScroll_internal(es, dx, 0);
4283         }
4284         return 0;
4285 }
4286
4287
4288 /*********************************************************************
4289  *
4290  *      EDIT_CheckCombo
4291  *
4292  */
4293 static BOOL EDIT_CheckCombo(EDITSTATE *es, UINT msg, INT key)
4294 {
4295    HWND hLBox = es->hwndListBox;
4296    HWND hCombo;
4297    BOOL bDropped;
4298    int  nEUI;
4299
4300    if (!hLBox)
4301       return FALSE;
4302
4303    hCombo   = GetParent(es->hwndSelf);
4304    bDropped = TRUE;
4305    nEUI     = 0;
4306
4307    TRACE_(combo)("[%p]: handling msg %x (%x)\n", es->hwndSelf, msg, key);
4308
4309    if (key == VK_UP || key == VK_DOWN)
4310    {
4311       if (SendMessageW(hCombo, CB_GETEXTENDEDUI, 0, 0))
4312          nEUI = 1;
4313
4314       if (msg == WM_KEYDOWN || nEUI)
4315           bDropped = (BOOL)SendMessageW(hCombo, CB_GETDROPPEDSTATE, 0, 0);
4316    }
4317
4318    switch (msg)
4319    {
4320       case WM_KEYDOWN:
4321          if (!bDropped && nEUI && (key == VK_UP || key == VK_DOWN))
4322          {
4323             /* make sure ComboLBox pops up */
4324             SendMessageW(hCombo, CB_SETEXTENDEDUI, FALSE, 0);
4325             key = VK_F4;
4326             nEUI = 2;
4327          }
4328
4329          SendMessageW(hLBox, WM_KEYDOWN, (WPARAM)key, 0);
4330          break;
4331
4332       case WM_SYSKEYDOWN: /* Handle Alt+up/down arrows */
4333          if (nEUI)
4334             SendMessageW(hCombo, CB_SHOWDROPDOWN, bDropped ? FALSE : TRUE, 0);
4335          else
4336             SendMessageW(hLBox, WM_KEYDOWN, (WPARAM)VK_F4, 0);
4337          break;
4338    }
4339
4340    if(nEUI == 2)
4341       SendMessageW(hCombo, CB_SETEXTENDEDUI, TRUE, 0);
4342
4343    return TRUE;
4344 }
4345
4346
4347 /*********************************************************************
4348  *
4349  *      WM_KEYDOWN
4350  *
4351  *      Handling of special keys that don't produce a WM_CHAR
4352  *      (i.e. non-printable keys) & Backspace & Delete
4353  *
4354  */
4355 static LRESULT EDIT_WM_KeyDown(EDITSTATE *es, INT key)
4356 {
4357         BOOL shift;
4358         BOOL control;
4359
4360         if (GetKeyState(VK_MENU) & 0x8000)
4361                 return 0;
4362
4363         shift = GetKeyState(VK_SHIFT) & 0x8000;
4364         control = GetKeyState(VK_CONTROL) & 0x8000;
4365
4366         switch (key) {
4367         case VK_F4:
4368         case VK_UP:
4369                 if (EDIT_CheckCombo(es, WM_KEYDOWN, key) || key == VK_F4)
4370                         break;
4371
4372                 /* fall through */
4373         case VK_LEFT:
4374                 if ((es->style & ES_MULTILINE) && (key == VK_UP))
4375                         EDIT_MoveUp_ML(es, shift);
4376                 else
4377                         if (control)
4378                                 EDIT_MoveWordBackward(es, shift);
4379                         else
4380                                 EDIT_MoveBackward(es, shift);
4381                 break;
4382         case VK_DOWN:
4383                 if (EDIT_CheckCombo(es, WM_KEYDOWN, key))
4384                         break;
4385                 /* fall through */
4386         case VK_RIGHT:
4387                 if ((es->style & ES_MULTILINE) && (key == VK_DOWN))
4388                         EDIT_MoveDown_ML(es, shift);
4389                 else if (control)
4390                         EDIT_MoveWordForward(es, shift);
4391                 else
4392                         EDIT_MoveForward(es, shift);
4393                 break;
4394         case VK_HOME:
4395                 EDIT_MoveHome(es, shift);
4396                 break;
4397         case VK_END:
4398                 EDIT_MoveEnd(es, shift);
4399                 break;
4400         case VK_PRIOR:
4401                 if (es->style & ES_MULTILINE)
4402                         EDIT_MovePageUp_ML(es, shift);
4403                 else
4404                         EDIT_CheckCombo(es, WM_KEYDOWN, key);
4405                 break;
4406         case VK_NEXT:
4407                 if (es->style & ES_MULTILINE)
4408                         EDIT_MovePageDown_ML(es, shift);
4409                 else
4410                         EDIT_CheckCombo(es, WM_KEYDOWN, key);
4411                 break;
4412         case VK_DELETE:
4413                 if (!(es->style & ES_READONLY) && !(shift && control)) {
4414                         if (es->selection_start != es->selection_end) {
4415                                 if (shift)
4416                                         EDIT_WM_Cut(es);
4417                                 else
4418                                         EDIT_WM_Clear(es);
4419                         } else {
4420                                 if (shift) {
4421                                         /* delete character left of caret */
4422                                         EDIT_EM_SetSel(es, (UINT)-1, 0, FALSE);
4423                                         EDIT_MoveBackward(es, TRUE);
4424                                         EDIT_WM_Clear(es);
4425                                 } else if (control) {
4426                                         /* delete to end of line */
4427                                         EDIT_EM_SetSel(es, (UINT)-1, 0, FALSE);
4428                                         EDIT_MoveEnd(es, TRUE);
4429                                         EDIT_WM_Clear(es);
4430                                 } else {
4431                                         /* delete character right of caret */
4432                                         EDIT_EM_SetSel(es, (UINT)-1, 0, FALSE);
4433                                         EDIT_MoveForward(es, TRUE);
4434                                         EDIT_WM_Clear(es);
4435                                 }
4436                         }
4437                 }
4438                 break;
4439         case VK_INSERT:
4440                 if (shift) {
4441                         if (!(es->style & ES_READONLY))
4442                                 EDIT_WM_Paste(es);
4443                 } else if (control)
4444                         EDIT_WM_Copy(es);
4445                 break;
4446         case VK_RETURN:
4447             /* If the edit doesn't want the return send a message to the default object */
4448             if(!(es->style & ES_WANTRETURN))
4449             {
4450                 HWND hwndParent = GetParent(es->hwndSelf);
4451                 DWORD dw = SendMessageW( hwndParent, DM_GETDEFID, 0, 0 );
4452                 if (HIWORD(dw) == DC_HASDEFID)
4453                 {
4454                     SendMessageW( hwndParent, WM_COMMAND,
4455                                   MAKEWPARAM( LOWORD(dw), BN_CLICKED ),
4456                               (LPARAM)GetDlgItem( hwndParent, LOWORD(dw) ) );
4457                 }
4458             }
4459             break;
4460         }
4461         return 0;
4462 }
4463
4464
4465 /*********************************************************************
4466  *
4467  *      WM_KILLFOCUS
4468  *
4469  */
4470 static LRESULT EDIT_WM_KillFocus(EDITSTATE *es)
4471 {
4472         es->flags &= ~EF_FOCUSED;
4473         DestroyCaret();
4474         if(!(es->style & ES_NOHIDESEL))
4475                 EDIT_InvalidateText(es, es->selection_start, es->selection_end);
4476         EDIT_NOTIFY_PARENT(es, EN_KILLFOCUS);
4477         return 0;
4478 }
4479
4480
4481 /*********************************************************************
4482  *
4483  *      WM_LBUTTONDBLCLK
4484  *
4485  *      The caret position has been set on the WM_LBUTTONDOWN message
4486  *
4487  */
4488 static LRESULT EDIT_WM_LButtonDblClk(EDITSTATE *es)
4489 {
4490         INT s;
4491         INT e = es->selection_end;
4492         INT l;
4493         INT li;
4494         INT ll;
4495
4496         if (!(es->flags & EF_FOCUSED))
4497                 return 0;
4498
4499         l = EDIT_EM_LineFromChar(es, e);
4500         li = EDIT_EM_LineIndex(es, l);
4501         ll = EDIT_EM_LineLength(es, e);
4502         s = li + EDIT_CallWordBreakProc(es, li, e - li, ll, WB_LEFT);
4503         e = li + EDIT_CallWordBreakProc(es, li, e - li, ll, WB_RIGHT);
4504         EDIT_EM_SetSel(es, s, e, FALSE);
4505         EDIT_EM_ScrollCaret(es);
4506         return 0;
4507 }
4508
4509
4510 /*********************************************************************
4511  *
4512  *      WM_LBUTTONDOWN
4513  *
4514  */
4515 static LRESULT EDIT_WM_LButtonDown(EDITSTATE *es, DWORD keys, INT x, INT y)
4516 {
4517         INT e;
4518         BOOL after_wrap;
4519
4520         SetFocus(es->hwndSelf);
4521         if (!(es->flags & EF_FOCUSED))
4522                 return 0;
4523
4524         es->bCaptureState = TRUE;
4525         SetCapture(es->hwndSelf);
4526         EDIT_ConfinePoint(es, &x, &y);
4527         e = EDIT_CharFromPos(es, x, y, &after_wrap);
4528         EDIT_EM_SetSel(es, (keys & MK_SHIFT) ? es->selection_start : e, e, after_wrap);
4529         EDIT_EM_ScrollCaret(es);
4530         es->region_posx = es->region_posy = 0;
4531         SetTimer(es->hwndSelf, 0, 100, NULL);
4532         return 0;
4533 }
4534
4535
4536 /*********************************************************************
4537  *
4538  *      WM_LBUTTONUP
4539  *
4540  */
4541 static LRESULT EDIT_WM_LButtonUp(EDITSTATE *es)
4542 {
4543         if (es->bCaptureState) {
4544                 KillTimer(es->hwndSelf, 0);
4545                 if (GetCapture() == es->hwndSelf) ReleaseCapture();
4546         }
4547         es->bCaptureState = FALSE;
4548         return 0;
4549 }
4550
4551
4552 /*********************************************************************
4553  *
4554  *      WM_MBUTTONDOWN
4555  *
4556  */
4557 static LRESULT EDIT_WM_MButtonDown(EDITSTATE *es)
4558 {
4559     SendMessageW(es->hwndSelf, WM_PASTE, 0, 0);
4560     return 0;
4561 }
4562
4563
4564 /*********************************************************************
4565  *
4566  *      WM_MOUSEMOVE
4567  *
4568  */
4569 static LRESULT EDIT_WM_MouseMove(EDITSTATE *es, INT x, INT y)
4570 {
4571         INT e;
4572         BOOL after_wrap;
4573         INT prex, prey;
4574
4575         /* If the mouse has been captured by process other than the edit control itself,
4576          * the windows edit controls will not select the strings with mouse move.
4577          */
4578         if (!es->bCaptureState || GetCapture() != es->hwndSelf)
4579                 return 0;
4580
4581         /*
4582          *      FIXME: gotta do some scrolling if outside client
4583          *              area.  Maybe reset the timer ?
4584          */
4585         prex = x; prey = y;
4586         EDIT_ConfinePoint(es, &x, &y);
4587         es->region_posx = (prex < x) ? -1 : ((prex > x) ? 1 : 0);
4588         es->region_posy = (prey < y) ? -1 : ((prey > y) ? 1 : 0);
4589         e = EDIT_CharFromPos(es, x, y, &after_wrap);
4590         EDIT_EM_SetSel(es, es->selection_start, e, after_wrap);
4591         EDIT_SetCaretPos(es,es->selection_end,es->flags & EF_AFTER_WRAP);
4592         return 0;
4593 }
4594
4595
4596 /*********************************************************************
4597  *
4598  *      WM_NCCREATE
4599  *
4600  * See also EDIT_WM_StyleChanged
4601  */
4602 static LRESULT EDIT_WM_NCCreate(HWND hwnd, LPCREATESTRUCTW lpcs, BOOL unicode)
4603 {
4604         EDITSTATE *es;
4605         UINT alloc_size;
4606
4607         TRACE("Creating %s edit control, style = %08lx\n",
4608                 unicode ? "Unicode" : "ANSI", lpcs->style);
4609
4610         if (!(es = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*es))))
4611                 return FALSE;
4612         SetWindowLongW( hwnd, 0, (LONG)es );
4613
4614        /*
4615         *      Note: since the EDITSTATE has not been fully initialized yet,
4616         *            we can't use any API calls that may send
4617         *            WM_XXX messages before WM_NCCREATE is completed.
4618         */
4619
4620         es->is_unicode = unicode;
4621         es->style = lpcs->style;
4622
4623         es->bEnableState = !(es->style & WS_DISABLED);
4624
4625         es->hwndSelf = hwnd;
4626         /* Save parent, which will be notified by EN_* messages */
4627         es->hwndParent = lpcs->hwndParent;
4628
4629         if (es->style & ES_COMBO)
4630            es->hwndListBox = GetDlgItem(es->hwndParent, ID_CB_LISTBOX);
4631
4632         /* Number overrides lowercase overrides uppercase (at least it
4633          * does in Win95).  However I'll bet that ES_NUMBER would be
4634          * invalid under Win 3.1.
4635          */
4636         if (es->style & ES_NUMBER) {
4637                 ; /* do not override the ES_NUMBER */
4638         }  else if (es->style & ES_LOWERCASE) {
4639                 es->style &= ~ES_UPPERCASE;
4640         }
4641         if (es->style & ES_MULTILINE) {
4642                 es->buffer_limit = BUFLIMIT_MULTI;
4643                 if (es->style & WS_VSCROLL)
4644                         es->style |= ES_AUTOVSCROLL;
4645                 if (es->style & WS_HSCROLL)
4646                         es->style |= ES_AUTOHSCROLL;
4647                 es->style &= ~ES_PASSWORD;
4648                 if ((es->style & ES_CENTER) || (es->style & ES_RIGHT)) {
4649                         /* Confirmed - RIGHT overrides CENTER */
4650                         if (es->style & ES_RIGHT)
4651                                 es->style &= ~ES_CENTER;
4652                         es->style &= ~WS_HSCROLL;
4653                         es->style &= ~ES_AUTOHSCROLL;
4654                 }
4655         } else {
4656                 es->buffer_limit = BUFLIMIT_SINGLE;
4657                 if ((es->style & ES_RIGHT) && (es->style & ES_CENTER))
4658                         es->style &= ~ES_CENTER;
4659                 es->style &= ~WS_HSCROLL;
4660                 es->style &= ~WS_VSCROLL;
4661                 if (es->style & ES_PASSWORD)
4662                         es->password_char = '*';
4663         }
4664
4665         alloc_size = ROUND_TO_GROW((es->buffer_size + 1) * sizeof(WCHAR));
4666         if(!(es->hloc32W = LocalAlloc(LMEM_MOVEABLE | LMEM_ZEROINIT, alloc_size)))
4667             return FALSE;
4668         es->buffer_size = LocalSize(es->hloc32W)/sizeof(WCHAR) - 1;
4669
4670         if (!(es->undo_text = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, (es->buffer_size + 1) * sizeof(WCHAR))))
4671                 return FALSE;
4672         es->undo_buffer_size = es->buffer_size;
4673
4674         if (es->style & ES_MULTILINE)
4675                 if (!(es->first_line_def = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(LINEDEF))))
4676                         return FALSE;
4677         es->line_count = 1;
4678
4679         /*
4680          * In Win95 look and feel, the WS_BORDER style is replaced by the
4681          * WS_EX_CLIENTEDGE style for the edit control. This gives the edit
4682          * control a nonclient area so we don't need to draw the border.
4683          * If WS_BORDER without WS_EX_CLIENTEDGE is specified we shouldn't have
4684          * a nonclient area and we should handle painting the border ourselves.
4685          *
4686          * When making modifications please ensure that the code still works
4687          * for edit controls created directly with style 0x50800000, exStyle 0
4688          * (which should have a single pixel border)
4689          */
4690         if (lpcs->dwExStyle & WS_EX_CLIENTEDGE)
4691                 es->style &= ~WS_BORDER;
4692         else if (es->style & WS_BORDER)
4693                 SetWindowLongW(hwnd, GWL_STYLE, es->style & ~WS_BORDER);
4694
4695         return TRUE;
4696 }
4697
4698 /*********************************************************************
4699  *
4700  *      WM_PAINT
4701  *
4702  */
4703 static void EDIT_WM_Paint(EDITSTATE *es, HDC hdc)
4704 {
4705         PAINTSTRUCT ps;
4706         INT i;
4707         HDC dc;
4708         HFONT old_font = 0;
4709         RECT rc;
4710         RECT rcClient;
4711         RECT rcLine;
4712         RECT rcRgn;
4713         HBRUSH brush;
4714         HBRUSH old_brush;
4715         BOOL rev = es->bEnableState &&
4716                                 ((es->flags & EF_FOCUSED) ||
4717                                         (es->style & ES_NOHIDESEL));
4718         dc = hdc ? hdc : BeginPaint(es->hwndSelf, &ps);
4719
4720         GetClientRect(es->hwndSelf, &rcClient);
4721
4722         /* get the background brush */
4723         if (!(brush = EDIT_NotifyCtlColor(es, dc)))
4724                 brush = (HBRUSH)GetStockObject(WHITE_BRUSH);
4725
4726         /* paint the border and the background */
4727         IntersectClipRect(dc, rcClient.left, rcClient.top, rcClient.right, rcClient.bottom);
4728         if(es->style & WS_BORDER) {
4729                 rc = rcClient;
4730                 if(es->style & ES_MULTILINE) {
4731                         if(es->style & WS_HSCROLL) rc.bottom++;
4732                         if(es->style & WS_VSCROLL) rc.right++;
4733                 }
4734                 old_brush = SelectObject(dc, brush);
4735                 Rectangle(dc, rc.left, rc.top, rc.right, rc.bottom);
4736                 SelectObject(dc, old_brush);
4737         }
4738         else {
4739                 GetClipBox(dc, &rc);
4740                 FillRect(dc, &rc, brush);
4741         }
4742         IntersectClipRect(dc, es->format_rect.left,
4743                                 es->format_rect.top,
4744                                 es->format_rect.right,
4745                                 es->format_rect.bottom);
4746         if (es->style & ES_MULTILINE) {
4747                 rc = rcClient;
4748                 IntersectClipRect(dc, rc.left, rc.top, rc.right, rc.bottom);
4749         }
4750         if (es->font)
4751                 old_font = SelectObject(dc, es->font);
4752         EDIT_NotifyCtlColor(es, dc);
4753
4754         if (!es->bEnableState)
4755                 SetTextColor(dc, GetSysColor(COLOR_GRAYTEXT));
4756         GetClipBox(dc, &rcRgn);
4757         if (es->style & ES_MULTILINE) {
4758                 INT vlc = (es->format_rect.bottom - es->format_rect.top) / es->line_height;
4759                 for (i = es->y_offset ; i <= min(es->y_offset + vlc, es->y_offset + es->line_count - 1) ; i++) {
4760                         EDIT_GetLineRect(es, i, 0, -1, &rcLine);
4761                         if (IntersectRect(&rc, &rcRgn, &rcLine))
4762                                 EDIT_PaintLine(es, dc, i, rev);
4763                 }
4764         } else {
4765                 EDIT_GetLineRect(es, 0, 0, -1, &rcLine);
4766                 if (IntersectRect(&rc, &rcRgn, &rcLine))
4767                         EDIT_PaintLine(es, dc, 0, rev);
4768         }
4769         if (es->font)
4770                 SelectObject(dc, old_font);
4771
4772         if (!hdc)
4773             EndPaint(es->hwndSelf, &ps);
4774 }
4775
4776
4777 /*********************************************************************
4778  *
4779  *      WM_PASTE
4780  *
4781  */
4782 static void EDIT_WM_Paste(EDITSTATE *es)
4783 {
4784         HGLOBAL hsrc;
4785         LPWSTR src;
4786
4787         /* Protect read-only edit control from modification */
4788         if(es->style & ES_READONLY)
4789             return;
4790
4791         OpenClipboard(es->hwndSelf);
4792         if ((hsrc = GetClipboardData(CF_UNICODETEXT))) {
4793                 src = (LPWSTR)GlobalLock(hsrc);
4794                 EDIT_EM_ReplaceSel(es, TRUE, src, TRUE, TRUE);
4795                 GlobalUnlock(hsrc);
4796         }
4797         CloseClipboard();
4798 }
4799
4800
4801 /*********************************************************************
4802  *
4803  *      WM_SETFOCUS
4804  *
4805  */
4806 static void EDIT_WM_SetFocus(EDITSTATE *es)
4807 {
4808         es->flags |= EF_FOCUSED;
4809         CreateCaret(es->hwndSelf, 0, 2, es->line_height);
4810         EDIT_SetCaretPos(es, es->selection_end,
4811                          es->flags & EF_AFTER_WRAP);
4812         if(!(es->style & ES_NOHIDESEL))
4813                 EDIT_InvalidateText(es, es->selection_start, es->selection_end);
4814         ShowCaret(es->hwndSelf);
4815         EDIT_NOTIFY_PARENT(es, EN_SETFOCUS);
4816 }
4817
4818
4819 /*********************************************************************
4820  *
4821  *      WM_SETFONT
4822  *
4823  * With Win95 look the margins are set to default font value unless
4824  * the system font (font == 0) is being set, in which case they are left
4825  * unchanged.
4826  *
4827  */
4828 static void EDIT_WM_SetFont(EDITSTATE *es, HFONT font, BOOL redraw)
4829 {
4830         TEXTMETRICW tm;
4831         HDC dc;
4832         HFONT old_font = 0;
4833         RECT clientRect;
4834
4835         es->font = font;
4836         dc = GetDC(es->hwndSelf);
4837         if (font)
4838                 old_font = SelectObject(dc, font);
4839         GetTextMetricsW(dc, &tm);
4840         es->line_height = tm.tmHeight;
4841         es->char_width = tm.tmAveCharWidth;
4842         if (font)
4843                 SelectObject(dc, old_font);
4844         ReleaseDC(es->hwndSelf, dc);
4845
4846         /* Reset the format rect and the margins */
4847         GetClientRect(es->hwndSelf, &clientRect);
4848         EDIT_SetRectNP(es, &clientRect);
4849         EDIT_EM_SetMargins(es, EC_LEFTMARGIN | EC_RIGHTMARGIN,
4850                            EC_USEFONTINFO, EC_USEFONTINFO, FALSE);
4851
4852         if (es->style & ES_MULTILINE)
4853                 EDIT_BuildLineDefs_ML(es, 0, strlenW(es->text), 0, NULL);
4854         else
4855             EDIT_CalcLineWidth_SL(es);
4856
4857         if (redraw)
4858                 EDIT_UpdateText(es, NULL, TRUE);
4859         if (es->flags & EF_FOCUSED) {
4860                 DestroyCaret();
4861                 CreateCaret(es->hwndSelf, 0, 2, es->line_height);
4862                 EDIT_SetCaretPos(es, es->selection_end,
4863                                  es->flags & EF_AFTER_WRAP);
4864                 ShowCaret(es->hwndSelf);
4865         }
4866 }
4867
4868
4869 /*********************************************************************
4870  *
4871  *      WM_SETTEXT
4872  *
4873  * NOTES
4874  *  For multiline controls (ES_MULTILINE), reception of WM_SETTEXT triggers:
4875  *  The modified flag is reset. No notifications are sent.
4876  *
4877  *  For single-line controls, reception of WM_SETTEXT triggers:
4878  *  The modified flag is reset. EN_UPDATE and EN_CHANGE notifications are sent.
4879  *
4880  */
4881 static void EDIT_WM_SetText(EDITSTATE *es, LPCWSTR text, BOOL unicode)
4882 {
4883     if (!unicode && text)
4884     {
4885         LPCSTR textA = (LPCSTR)text;
4886         INT countW = MultiByteToWideChar(CP_ACP, 0, textA, -1, NULL, 0);
4887         LPWSTR textW = HeapAlloc(GetProcessHeap(), 0, countW * sizeof(WCHAR));
4888         if (textW)
4889             MultiByteToWideChar(CP_ACP, 0, textA, -1, textW, countW);
4890         text = textW;
4891     }
4892
4893     if (es->flags & EF_UPDATE)
4894         /* fixed this bug once; complain if we see it about to happen again. */
4895         ERR("SetSel may generate UPDATE message whose handler may reset "
4896             "selection.\n");
4897
4898     EDIT_EM_SetSel(es, 0, (UINT)-1, FALSE);
4899     if (text)
4900     {
4901         TRACE("%s\n", debugstr_w(text));
4902         EDIT_EM_ReplaceSel(es, FALSE, text, FALSE, FALSE);
4903         if(!unicode)
4904             HeapFree(GetProcessHeap(), 0, (LPWSTR)text);
4905     }
4906     else
4907     {
4908         static const WCHAR empty_stringW[] = {0};
4909         TRACE("<NULL>\n");
4910         EDIT_EM_ReplaceSel(es, FALSE, empty_stringW, FALSE, FALSE);
4911     }
4912     es->x_offset = 0;
4913     es->flags &= ~EF_MODIFIED;
4914     EDIT_EM_SetSel(es, 0, 0, FALSE);
4915
4916     /* Send the notification after the selection start and end have been set
4917      * edit control doesn't send notification on WM_SETTEXT
4918      * if it is multiline, or it is part of combobox
4919      */
4920     if( !((es->style & ES_MULTILINE) || es->hwndListBox))
4921     {
4922         EDIT_NOTIFY_PARENT(es, EN_UPDATE);
4923         EDIT_NOTIFY_PARENT(es, EN_CHANGE);
4924     }
4925     EDIT_EM_ScrollCaret(es);
4926     EDIT_UpdateScrollInfo(es);
4927 }
4928
4929
4930 /*********************************************************************
4931  *
4932  *      WM_SIZE
4933  *
4934  */
4935 static void EDIT_WM_Size(EDITSTATE *es, UINT action, INT width, INT height)
4936 {
4937         if ((action == SIZE_MAXIMIZED) || (action == SIZE_RESTORED)) {
4938                 RECT rc;
4939                 TRACE("width = %d, height = %d\n", width, height);
4940                 SetRect(&rc, 0, 0, width, height);
4941                 EDIT_SetRectNP(es, &rc);
4942                 EDIT_UpdateText(es, NULL, TRUE);
4943         }
4944 }
4945
4946
4947 /*********************************************************************
4948  *
4949  *      WM_STYLECHANGED
4950  *
4951  * This message is sent by SetWindowLong on having changed either the Style
4952  * or the extended style.
4953  *
4954  * We ensure that the window's version of the styles and the EDITSTATE's agree.
4955  *
4956  * See also EDIT_WM_NCCreate
4957  *
4958  * It appears that the Windows version of the edit control allows the style
4959  * (as retrieved by GetWindowLong) to be any value and maintains an internal
4960  * style variable which will generally be different.  In this function we
4961  * update the internal style based on what changed in the externally visible
4962  * style.
4963  *
4964  * Much of this content as based upon the MSDN, especially:
4965  *  Platform SDK Documentation -> User Interface Services ->
4966  *      Windows User Interface -> Edit Controls -> Edit Control Reference ->
4967  *      Edit Control Styles
4968  */
4969 static LRESULT  EDIT_WM_StyleChanged ( EDITSTATE *es, WPARAM which, const STYLESTRUCT *style)
4970 {
4971         if (GWL_STYLE == which) {
4972                 DWORD style_change_mask;
4973                 DWORD new_style;
4974                 /* Only a subset of changes can be applied after the control
4975                  * has been created.
4976                  */
4977                 style_change_mask = ES_UPPERCASE | ES_LOWERCASE |
4978                                     ES_NUMBER;
4979                 if (es->style & ES_MULTILINE)
4980                         style_change_mask |= ES_WANTRETURN;
4981
4982                 new_style = style->styleNew & style_change_mask;
4983
4984                 /* Number overrides lowercase overrides uppercase (at least it
4985                  * does in Win95).  However I'll bet that ES_NUMBER would be
4986                  * invalid under Win 3.1.
4987                  */
4988                 if (new_style & ES_NUMBER) {
4989                         ; /* do not override the ES_NUMBER */
4990                 }  else if (new_style & ES_LOWERCASE) {
4991                         new_style &= ~ES_UPPERCASE;
4992                 }
4993
4994                 es->style = (es->style & ~style_change_mask) | new_style;
4995         } else if (GWL_EXSTYLE == which) {
4996                 ; /* FIXME - what is needed here */
4997         } else {
4998                 WARN ("Invalid style change %d\n",which);
4999         }
5000
5001         return 0;
5002 }
5003
5004 /*********************************************************************
5005  *
5006  *      WM_SYSKEYDOWN
5007  *
5008  */
5009 static LRESULT EDIT_WM_SysKeyDown(EDITSTATE *es, INT key, DWORD key_data)
5010 {
5011         if ((key == VK_BACK) && (key_data & 0x2000)) {
5012                 if (EDIT_EM_CanUndo(es))
5013                         EDIT_EM_Undo(es);
5014                 return 0;
5015         } else if (key == VK_UP || key == VK_DOWN) {
5016                 if (EDIT_CheckCombo(es, WM_SYSKEYDOWN, key))
5017                         return 0;
5018         }
5019         return DefWindowProcW(es->hwndSelf, WM_SYSKEYDOWN, (WPARAM)key, (LPARAM)key_data);
5020 }
5021
5022
5023 /*********************************************************************
5024  *
5025  *      WM_TIMER
5026  *
5027  */
5028 static void EDIT_WM_Timer(EDITSTATE *es)
5029 {
5030         if (es->region_posx < 0) {
5031                 EDIT_MoveBackward(es, TRUE);
5032         } else if (es->region_posx > 0) {
5033                 EDIT_MoveForward(es, TRUE);
5034         }
5035 /*
5036  *      FIXME: gotta do some vertical scrolling here, like
5037  *              EDIT_EM_LineScroll(hwnd, 0, 1);
5038  */
5039 }
5040
5041 /*********************************************************************
5042  *
5043  *      WM_VSCROLL
5044  *
5045  */
5046 static LRESULT EDIT_WM_VScroll(EDITSTATE *es, INT action, INT pos)
5047 {
5048         INT dy;
5049
5050         if (!(es->style & ES_MULTILINE))
5051                 return 0;
5052
5053         if (!(es->style & ES_AUTOVSCROLL))
5054                 return 0;
5055
5056         dy = 0;
5057         switch (action) {
5058         case SB_LINEUP:
5059         case SB_LINEDOWN:
5060         case SB_PAGEUP:
5061         case SB_PAGEDOWN:
5062                 TRACE("action %d (%s)\n", action, (action == SB_LINEUP ? "SB_LINEUP" :
5063                                                    (action == SB_LINEDOWN ? "SB_LINEDOWN" :
5064                                                     (action == SB_PAGEUP ? "SB_PAGEUP" :
5065                                                      "SB_PAGEDOWN"))));
5066                 EDIT_EM_Scroll(es, action);
5067                 return 0;
5068         case SB_TOP:
5069                 TRACE("SB_TOP\n");
5070                 dy = -es->y_offset;
5071                 break;
5072         case SB_BOTTOM:
5073                 TRACE("SB_BOTTOM\n");
5074                 dy = es->line_count - 1 - es->y_offset;
5075                 break;
5076         case SB_THUMBTRACK:
5077                 TRACE("SB_THUMBTRACK %d\n", pos);
5078                 es->flags |= EF_VSCROLL_TRACK;
5079                 if(es->style & WS_VSCROLL)
5080                     dy = pos - es->y_offset;
5081                 else
5082                 {
5083                     /* Assume default scroll range 0-100 */
5084                     INT vlc, new_y;
5085                     /* Sanity check */
5086                     if(pos < 0 || pos > 100) return 0;
5087                     vlc = (es->format_rect.bottom - es->format_rect.top) / es->line_height;
5088                     new_y = pos * (es->line_count - vlc) / 100;
5089                     dy = es->line_count ? (new_y - es->y_offset) : 0;
5090                     TRACE("line_count=%d, y_offset=%d, pos=%d, dy = %d\n",
5091                             es->line_count, es->y_offset, pos, dy);
5092                 }
5093                 break;
5094         case SB_THUMBPOSITION:
5095                 TRACE("SB_THUMBPOSITION %d\n", pos);
5096                 es->flags &= ~EF_VSCROLL_TRACK;
5097                 if(es->style & WS_VSCROLL)
5098                     dy = pos - es->y_offset;
5099                 else
5100                 {
5101                     /* Assume default scroll range 0-100 */
5102                     INT vlc, new_y;
5103                     /* Sanity check */
5104                     if(pos < 0 || pos > 100) return 0;
5105                     vlc = (es->format_rect.bottom - es->format_rect.top) / es->line_height;
5106                     new_y = pos * (es->line_count - vlc) / 100;
5107                     dy = es->line_count ? (new_y - es->y_offset) : 0;
5108                     TRACE("line_count=%d, y_offset=%d, pos=%d, dy = %d\n",
5109                             es->line_count, es->y_offset, pos, dy);
5110                 }
5111                 if (!dy)
5112                 {
5113                         /* force scroll info update */
5114                         EDIT_UpdateScrollInfo(es);
5115                         EDIT_NOTIFY_PARENT(es, EN_VSCROLL);
5116                 }
5117                 break;
5118         case SB_ENDSCROLL:
5119                 TRACE("SB_ENDSCROLL\n");
5120                 break;
5121         /*
5122          *      FIXME : the next two are undocumented !
5123          *      Are we doing the right thing ?
5124          *      At least Win 3.1 Notepad makes use of EM_GETTHUMB this way,
5125          *      although it's also a regular control message.
5126          */
5127         case EM_GETTHUMB: /* this one is used by NT notepad */
5128         case EM_GETTHUMB16:
5129         {
5130                 LRESULT ret;
5131                 if(GetWindowLongW( es->hwndSelf, GWL_STYLE ) & WS_VSCROLL)
5132                     ret = GetScrollPos(es->hwndSelf, SB_VERT);
5133                 else
5134                 {
5135                     /* Assume default scroll range 0-100 */
5136                     INT vlc = (es->format_rect.bottom - es->format_rect.top) / es->line_height;
5137                     ret = es->line_count ? es->y_offset * 100 / (es->line_count - vlc) : 0;
5138                 }
5139                 TRACE("EM_GETTHUMB: returning %ld\n", ret);
5140                 return ret;
5141         }
5142         case EM_LINESCROLL16:
5143                 TRACE("EM_LINESCROLL16 %d\n", pos);
5144                 dy = pos;
5145                 break;
5146
5147         default:
5148                 ERR("undocumented WM_VSCROLL action %d (0x%04x), please report\n",
5149                     action, action);
5150                 return 0;
5151         }
5152         if (dy)
5153                 EDIT_EM_LineScroll(es, 0, dy);
5154         return 0;
5155 }
5156
5157 /*********************************************************************
5158  *
5159  *      EDIT_UpdateText
5160  *
5161  */
5162 static void EDIT_UpdateTextRegion(EDITSTATE *es, HRGN hrgn, BOOL bErase)
5163 {
5164     if (es->flags & EF_UPDATE) {
5165         es->flags &= ~EF_UPDATE;
5166         EDIT_NOTIFY_PARENT(es, EN_UPDATE);
5167     }
5168     InvalidateRgn(es->hwndSelf, hrgn, bErase);
5169 }
5170
5171
5172 /*********************************************************************
5173  *
5174  *      EDIT_UpdateText
5175  *
5176  */
5177 static void EDIT_UpdateText(EDITSTATE *es, LPRECT rc, BOOL bErase)
5178 {
5179     if (es->flags & EF_UPDATE) {
5180         es->flags &= ~EF_UPDATE;
5181         EDIT_NOTIFY_PARENT(es, EN_UPDATE);
5182     }
5183     InvalidateRect(es->hwndSelf, rc, bErase);
5184 }