git.oblomov.eu Git - wine/blob - dlls/riched20/editor.c

   1 /*
   2  * RichEdit - functions dealing with editor object
   3  *
   4  * Copyright 2004 by Krzysztof Foltman
   5  * Copyright 2005 by Cihan Altinay
   6  * Copyright 2005 by Phil Krylov
   7  * Copyright 2008 Eric Pouech
   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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  22  */
  23
  24 /*
  25   API implementation status:
  26
  27   Messages (ANSI versions not done yet)
  28   + EM_AUTOURLDETECT 2.0
  29   + EM_CANPASTE
  30   + EM_CANREDO 2.0
  31   + EM_CANUNDO
  32   + EM_CHARFROMPOS
  33   - EM_DISPLAYBAND
  34   + EM_EMPTYUNDOBUFFER
  35   + EM_EXGETSEL
  36   + EM_EXLIMITTEXT
  37   + EM_EXLINEFROMCHAR
  38   + EM_EXSETSEL
  39   + EM_FINDTEXT (only FR_DOWN flag implemented)
  40   + EM_FINDTEXTEX (only FR_DOWN flag implemented)
  41   - EM_FINDWORDBREAK
  42   - EM_FMTLINES
  43   - EM_FORMATRANGE
  44   + EM_GETAUTOURLDETECT 2.0
  45   - EM_GETBIDIOPTIONS 3.0
  46   - EM_GETCHARFORMAT (partly done)
  47   - EM_GETEDITSTYLE
  48   + EM_GETEVENTMASK
  49   + EM_GETFIRSTVISIBLELINE (can be optimized if needed)
  50   - EM_GETIMECOLOR 1.0asian
  51   - EM_GETIMECOMPMODE 2.0
  52   - EM_GETIMEOPTIONS 1.0asian
  53   - EM_GETIMESTATUS
  54   - EM_GETLANGOPTIONS 2.0
  55   + EM_GETLIMITTEXT
  56   + EM_GETLINE
  57   + EM_GETLINECOUNT   returns number of rows, not of paragraphs
  58   + EM_GETMODIFY
  59   - EM_GETOLEINTERFACE
  60   + EM_GETOPTIONS
  61   + EM_GETPARAFORMAT
  62   + EM_GETPASSWORDCHAR 2.0
  63   - EM_GETPUNCTUATION 1.0asian
  64   + EM_GETRECT
  65   - EM_GETREDONAME 2.0
  66   + EM_GETSEL
  67   + EM_GETSELTEXT (ANSI&Unicode)
  68   + EM_GETSCROLLPOS 3.0 (only Y value valid)
  69 ! - EM_GETTHUMB
  70   + EM_GETTEXTEX 2.0
  71   + EM_GETTEXTLENGTHEX (GTL_PRECISE unimplemented)
  72   - EM_GETTEXTMODE 2.0
  73 ? + EM_GETTEXTRANGE (ANSI&Unicode)
  74   - EM_GETTYPOGRAPHYOPTIONS 3.0
  75   - EM_GETUNDONAME
  76   + EM_GETWORDBREAKPROC
  77   - EM_GETWORDBREAKPROCEX
  78   - EM_GETWORDWRAPMODE 1.0asian
  79   + EM_GETZOOM 3.0
  80   + EM_HIDESELECTION
  81   + EM_LIMITTEXT (Also called EM_SETLIMITTEXT)
  82   + EM_LINEFROMCHAR
  83   + EM_LINEINDEX
  84   + EM_LINELENGTH
  85   + EM_LINESCROLL
  86   - EM_PASTESPECIAL
  87   + EM_POSFROMCHAR
  88   + EM_REDO 2.0
  89   + EM_REQUESTRESIZE
  90   + EM_REPLACESEL (proper style?) ANSI&Unicode
  91   + EM_SCROLL
  92   + EM_SCROLLCARET
  93   - EM_SELECTIONTYPE
  94   - EM_SETBIDIOPTIONS 3.0
  95   + EM_SETBKGNDCOLOR
  96   + EM_SETCHARFORMAT (partly done, no ANSI)
  97   - EM_SETEDITSTYLE
  98   + EM_SETEVENTMASK (few notifications supported)
  99   - EM_SETFONTSIZE
 100   - EM_SETIMECOLOR 1.0asian
 101   - EM_SETIMEOPTIONS 1.0asian
 102   - EM_SETIMESTATUS
 103   - EM_SETLANGOPTIONS 2.0
 104   - EM_SETLIMITTEXT
 105   - EM_SETMARGINS
 106   + EM_SETMODIFY (not sure if implementation is correct)
 107   - EM_SETOLECALLBACK
 108   + EM_SETOPTIONS (partially implemented)
 109   - EM_SETPALETTE 2.0
 110   + EM_SETPARAFORMAT
 111   + EM_SETPASSWORDCHAR 2.0
 112   - EM_SETPUNCTUATION 1.0asian
 113   + EM_SETREADONLY no beep on modification attempt
 114   + EM_SETRECT
 115   + EM_SETRECTNP (EM_SETRECT without repainting)
 116   + EM_SETSEL
 117   + EM_SETSCROLLPOS 3.0
 118   - EM_SETTABSTOPS 3.0
 119   - EM_SETTARGETDEVICE (partial)
 120   + EM_SETTEXTEX 3.0 (proper style?)
 121   - EM_SETTEXTMODE 2.0
 122   - EM_SETTYPOGRAPHYOPTIONS 3.0
 123   + EM_SETUNDOLIMIT 2.0
 124   + EM_SETWORDBREAKPROC (used only for word movement at the moment)
 125   - EM_SETWORDBREAKPROCEX
 126   - EM_SETWORDWRAPMODE 1.0asian
 127   + EM_SETZOOM 3.0
 128   + EM_SHOWSCROLLBAR 2.0
 129   + EM_STOPGROUPTYPING 2.0
 130   + EM_STREAMIN
 131   + EM_STREAMOUT
 132   + EM_UNDO
 133   + WM_CHAR
 134   + WM_CLEAR
 135   + WM_COPY
 136   + WM_CUT
 137   + WM_GETDLGCODE (the current implementation is incomplete)
 138   + WM_GETTEXT (ANSI&Unicode)
 139   + WM_GETTEXTLENGTH (ANSI version sucks)
 140   + WM_PASTE
 141   + WM_SETFONT
 142   + WM_SETTEXT (resets undo stack !) (proper style?) ANSI&Unicode
 143   - WM_STYLECHANGING
 144   - WM_STYLECHANGED (things like read-only flag)
 145   + WM_UNICHAR
 146
 147   Notifications
 148
 149   * EN_CHANGE (sent from the wrong place)
 150   - EN_CORRECTTEXT
 151   - EN_DROPFILES
 152   - EN_ERRSPACE
 153   - EN_HSCROLL
 154   - EN_IMECHANGE
 155   + EN_KILLFOCUS
 156   - EN_LINK
 157   - EN_MAXTEXT
 158   - EN_MSGFILTER
 159   - EN_OLEOPFAILED
 160   - EN_PROTECTED
 161   + EN_REQUESTRESIZE
 162   - EN_SAVECLIPBOARD
 163   + EN_SELCHANGE
 164   + EN_SETFOCUS
 165   - EN_STOPNOUNDO
 166   * EN_UPDATE (sent from the wrong place)
 167   - EN_VSCROLL
 168
 169   Styles
 170
 171   - ES_AUTOHSCROLL
 172   - ES_AUTOVSCROLL
 173   - ES_CENTER
 174   + ES_DISABLENOSCROLL (scrollbar is always visible)
 175   - ES_EX_NOCALLOLEINIT
 176   - ES_LEFT
 177   - ES_MULTILINE (currently single line controls aren't supported)
 178   - ES_NOIME
 179   - ES_READONLY (I'm not sure if beeping is the proper behaviour)
 180   - ES_RIGHT
 181   - ES_SAVESEL
 182   - ES_SELFIME
 183   - ES_SUNKEN
 184   - ES_VERTICAL
 185   - ES_WANTRETURN (don't know how to do WM_GETDLGCODE part)
 186   - WS_SETFONT
 187   - WS_HSCROLL
 188   + WS_VSCROLL
 189 */
 190
 191 /*
 192  * RICHED20 TODO (incomplete):
 193  *
 194  * - messages/styles/notifications listed above
 195  * - add remaining CHARFORMAT/PARAFORMAT fields
 196  * - right/center align should strip spaces from the beginning
 197  * - pictures/OLE objects (not just smiling faces that lack API support ;-) )
 198  * - COM interface (looks like a major pain in the TODO list)
 199  * - calculate heights of pictures (half-done)
 200  * - horizontal scrolling (not even started)
 201  * - hysteresis during wrapping (related to scrollbars appearing/disappearing)
 202  * - find/replace
 203  * - how to implement EM_FORMATRANGE and EM_DISPLAYBAND ? (Mission Impossible)
 204  * - italic caret with italic fonts
 205  * - IME
 206  * - most notifications aren't sent at all (the most important ones are)
 207  * - when should EN_SELCHANGE be sent after text change ? (before/after EN_UPDATE?)
 208  * - WM_SETTEXT may use wrong style (but I'm 80% sure it's OK)
 209  * - EM_GETCHARFORMAT with SCF_SELECTION may not behave 100% like in original (but very close)
 210  * - full justification
 211  * - hyphenation
 212  * - tables
 213  * - ListBox & ComboBox not implemented
 214  *
 215  * Bugs that are probably fixed, but not so easy to verify:
 216  * - EN_UPDATE/EN_CHANGE are handled very incorrectly (should be OK now)
 217  * - undo for ME_JoinParagraphs doesn't store paragraph format ? (it does)
 218  * - check/fix artificial EOL logic (bCursorAtEnd, hardly logical)
 219  * - caret shouldn't be displayed when selection isn't empty
 220  * - check refcounting in style management functions (looks perfect now, but no bugs is suspicious)
 221  * - undo for setting default format (done, might be buggy)
 222  * - styles might be not released properly (looks like they work like charm, but who knows?
 223  *
 224  */
 225
 226 #include "editor.h"
 227 #include "commdlg.h"
 228 #include "winreg.h"
 229 #define NO_SHLWAPI_STREAM
 230 #include "shlwapi.h"
 231 #include "rtf.h"
 232 #include "imm.h"
 233 #include "res.h"
 234
 235 #define STACK_SIZE_DEFAULT  100
 236 #define STACK_SIZE_MAX     1000
 237
 238 #define TEXT_LIMIT_DEFAULT 32767
 239
 240 WINE_DEFAULT_DEBUG_CHANNEL(richedit);
 241
 242 static BOOL ME_RegisterEditorClass(HINSTANCE);
 243 static BOOL ME_UpdateLinkAttribute(ME_TextEditor *editor, int sel_min, int sel_max);
 244
 245 static const WCHAR RichEdit20W[] = {'R', 'i', 'c', 'h', 'E', 'd', 'i', 't', '2', '0', 'W', 0};
 246 static const WCHAR RichEdit50W[] = {'R', 'i', 'c', 'h', 'E', 'd', 'i', 't', '5', '0', 'W', 0};
 247 static const WCHAR REListBox20W[] = {'R','E','L','i','s','t','B','o','x','2','0','W', 0};
 248 static const WCHAR REComboBox20W[] = {'R','E','C','o','m','b','o','B','o','x','2','0','W', 0};
 249 static HCURSOR hLeft;
 250
 251 int me_debug = 0;
 252 HANDLE me_heap = NULL;
 253
 254 static BOOL ME_ListBoxRegistered = FALSE;
 255 static BOOL ME_ComboBoxRegistered = FALSE;
 256
 257 static inline int is_version_nt(void)
 258 {
 259     return !(GetVersion() & 0x80000000);
 260 }
 261
 262 static ME_TextBuffer *ME_MakeText(void) {
 263
 264   ME_TextBuffer *buf = ALLOC_OBJ(ME_TextBuffer);
 265
 266   ME_DisplayItem *p1 = ME_MakeDI(diTextStart);
 267   ME_DisplayItem *p2 = ME_MakeDI(diTextEnd);
 268
 269   p1->prev = NULL;
 270   p1->next = p2;
 271   p2->prev = p1;
 272   p2->next = NULL;
 273   p1->member.para.next_para = p2;
 274   p2->member.para.prev_para = p1;
 275   p2->member.para.nCharOfs = 0;
 276
 277   buf->pFirst = p1;
 278   buf->pLast = p2;
 279   buf->pCharStyle = NULL;
 280
 281   return buf;
 282 }
 283
 284
 285 static LRESULT ME_StreamInText(ME_TextEditor *editor, DWORD dwFormat, ME_InStream *stream, ME_Style *style)
 286 {
 287   WCHAR wszText[STREAMIN_BUFFER_SIZE+1];
 288   WCHAR *pText;
 289
 290   TRACE("%08x %p\n", dwFormat, stream);
 291
 292   do {
 293     long nWideChars = 0;
 294
 295     if (!stream->dwSize)
 296     {
 297       ME_StreamInFill(stream);
 298       if (stream->editstream->dwError)
 299         break;
 300       if (!stream->dwSize)
 301         break;
 302     }
 303
 304     if (!(dwFormat & SF_UNICODE))
 305     {
 306       /* FIXME? this is doomed to fail on true MBCS like UTF-8, luckily they're unlikely to be used as CP_ACP */
 307       nWideChars = MultiByteToWideChar(CP_ACP, 0, stream->buffer, stream->dwSize, wszText, STREAMIN_BUFFER_SIZE);
 308       pText = wszText;
 309     }
 310     else
 311     {
 312       nWideChars = stream->dwSize >> 1;
 313       pText = (WCHAR *)stream->buffer;
 314     }
 315
 316     ME_InsertTextFromCursor(editor, 0, pText, nWideChars, style);
 317     if (stream->dwSize == 0)
 318       break;
 319     stream->dwSize = 0;
 320   } while(1);
 321   ME_CommitUndo(editor);
 322   ME_UpdateRepaint(editor);
 323   return 0;
 324 }
 325
 326 static void ME_ApplyBorderProperties(RTF_Info *info,
 327                                      ME_BorderRect *borderRect,
 328                                      RTFBorder *borderDef)
 329 {
 330   int i, colorNum;
 331   ME_Border *pBorders[] = {&borderRect->top,
 332                            &borderRect->left,
 333                            &borderRect->bottom,
 334                            &borderRect->right};
 335   for (i = 0; i < 4; i++)
 336   {
 337     RTFColor *colorDef = info->colorList;
 338     pBorders[i]->width = borderDef[i].width;
 339     colorNum = borderDef[i].color;
 340     while (colorDef && colorDef->rtfCNum != colorNum)
 341       colorDef = colorDef->rtfNextColor;
 342     if (colorDef)
 343       pBorders[i]->colorRef = RGB(
 344                            colorDef->rtfCRed >= 0 ? colorDef->rtfCRed : 0,
 345                            colorDef->rtfCGreen >= 0 ? colorDef->rtfCGreen : 0,
 346                            colorDef->rtfCBlue >= 0 ? colorDef->rtfCBlue : 0);
 347     else
 348       pBorders[i]->colorRef = RGB(0, 0, 0);
 349   }
 350 }
 351
 352 void ME_RTFCharAttrHook(RTF_Info *info)
 353 {
 354   CHARFORMAT2W fmt;
 355   fmt.cbSize = sizeof(fmt);
 356   fmt.dwMask = 0;
 357   fmt.dwEffects = 0;
 358
 359   switch(info->rtfMinor)
 360   {
 361     case rtfPlain:
 362       /* FIXME add more flags once they're implemented */
 363       fmt.dwMask = CFM_BOLD | CFM_ITALIC | CFM_UNDERLINETYPE | CFM_STRIKEOUT | CFM_COLOR | CFM_BACKCOLOR | CFM_SIZE | CFM_WEIGHT;
 364       fmt.dwEffects = CFE_AUTOCOLOR | CFE_AUTOBACKCOLOR;
 365       fmt.yHeight = 12*20; /* 12pt */
 366       fmt.wWeight = FW_NORMAL;
 367       fmt.bUnderlineType = CFU_UNDERLINENONE;
 368       break;
 369     case rtfBold:
 370       fmt.dwMask = CFM_BOLD | CFM_WEIGHT;
 371       fmt.dwEffects = info->rtfParam ? CFE_BOLD : 0;
 372       fmt.wWeight = info->rtfParam ? FW_BOLD : FW_NORMAL;
 373       break;
 374     case rtfItalic:
 375       fmt.dwMask = CFM_ITALIC;
 376       fmt.dwEffects = info->rtfParam ? fmt.dwMask : 0;
 377       break;
 378     case rtfUnderline:
 379       fmt.dwMask = CFM_UNDERLINETYPE;
 380       fmt.bUnderlineType = info->rtfParam ? CFU_CF1UNDERLINE : CFU_UNDERLINENONE;
 381       break;
 382     case rtfDotUnderline:
 383       fmt.dwMask = CFM_UNDERLINETYPE;
 384       fmt.bUnderlineType = info->rtfParam ? CFU_UNDERLINEDOTTED : CFU_UNDERLINENONE;
 385       break;
 386     case rtfDbUnderline:
 387       fmt.dwMask = CFM_UNDERLINETYPE;
 388       fmt.bUnderlineType = info->rtfParam ? CFU_UNDERLINEDOUBLE : CFU_UNDERLINENONE;
 389       break;
 390     case rtfWordUnderline:
 391       fmt.dwMask = CFM_UNDERLINETYPE;
 392       fmt.bUnderlineType = info->rtfParam ? CFU_UNDERLINEWORD : CFU_UNDERLINENONE;
 393       break;
 394     case rtfNoUnderline:
 395       fmt.dwMask = CFM_UNDERLINETYPE;
 396       fmt.bUnderlineType = CFU_UNDERLINENONE;
 397       break;
 398     case rtfStrikeThru:
 399       fmt.dwMask = CFM_STRIKEOUT;
 400       fmt.dwEffects = info->rtfParam ? fmt.dwMask : 0;
 401       break;
 402     case rtfSubScript:
 403     case rtfSuperScript:
 404     case rtfSubScrShrink:
 405     case rtfSuperScrShrink:
 406     case rtfNoSuperSub:
 407       fmt.dwMask = CFM_SUBSCRIPT|CFM_SUPERSCRIPT;
 408       if (info->rtfMinor == rtfSubScrShrink) fmt.dwEffects = CFE_SUBSCRIPT;
 409       if (info->rtfMinor == rtfSuperScrShrink) fmt.dwEffects = CFE_SUPERSCRIPT;
 410       if (info->rtfMinor == rtfNoSuperSub) fmt.dwEffects = 0;
 411       break;
 412     case rtfInvisible:
 413       fmt.dwMask = CFM_HIDDEN;
 414       fmt.dwEffects = info->rtfParam ? fmt.dwMask : 0;
 415       break;
 416     case rtfBackColor:
 417       fmt.dwMask = CFM_BACKCOLOR;
 418       fmt.dwEffects = 0;
 419       if (info->rtfParam == 0)
 420         fmt.dwEffects = CFE_AUTOBACKCOLOR;
 421       else if (info->rtfParam != rtfNoParam)
 422       {
 423         RTFColor *c = RTFGetColor(info, info->rtfParam);
 424         fmt.crTextColor = (c->rtfCBlue<<16)|(c->rtfCGreen<<8)|(c->rtfCRed);
 425       }
 426       break;
 427     case rtfForeColor:
 428       fmt.dwMask = CFM_COLOR;
 429       fmt.dwEffects = 0;
 430       if (info->rtfParam == 0)
 431         fmt.dwEffects = CFE_AUTOCOLOR;
 432       else if (info->rtfParam != rtfNoParam)
 433       {
 434         RTFColor *c = RTFGetColor(info, info->rtfParam);
 435         if (c)
 436           fmt.crTextColor = (c->rtfCBlue<<16)|(c->rtfCGreen<<8)|(c->rtfCRed);
 437         else
 438           fmt.crTextColor = 0;
 439       }
 440       break;
 441     case rtfFontNum:
 442       if (info->rtfParam != rtfNoParam)
 443       {
 444         RTFFont *f = RTFGetFont(info, info->rtfParam);
 445         if (f)
 446         {
 447           MultiByteToWideChar(CP_ACP, 0, f->rtfFName, -1, fmt.szFaceName, sizeof(fmt.szFaceName)/sizeof(WCHAR));
 448           fmt.szFaceName[sizeof(fmt.szFaceName)/sizeof(WCHAR)-1] = '\0';
 449           fmt.bCharSet = f->rtfFCharSet;
 450           fmt.dwMask = CFM_FACE | CFM_CHARSET;
 451           fmt.bPitchAndFamily = f->rtfFPitch | (f->rtfFFamily << 4);
 452         }
 453       }
 454       break;
 455     case rtfFontSize:
 456       fmt.dwMask = CFM_SIZE;
 457       if (info->rtfParam != rtfNoParam)
 458         fmt.yHeight = info->rtfParam*10;
 459       break;
 460   }
 461   if (fmt.dwMask) {
 462     ME_Style *style2;
 463     RTFFlushOutputBuffer(info);
 464     /* FIXME too slow ? how come ? */
 465     style2 = ME_ApplyStyle(info->style, &fmt);
 466     ME_ReleaseStyle(info->style);
 467     info->style = style2;
 468     info->styleChanged = TRUE;
 469   }
 470 }
 471
 472 /* FIXME this function doesn't get any information about context of the RTF tag, which is very bad,
 473    the same tags mean different things in different contexts */
 474 void ME_RTFParAttrHook(RTF_Info *info)
 475 {
 476   PARAFORMAT2 fmt;
 477   fmt.cbSize = sizeof(fmt);
 478   fmt.dwMask = 0;
 479
 480   switch(info->rtfMinor)
 481   {
 482   case rtfParDef: /* restores default paragraph attributes */
 483     if (!info->editor->bEmulateVersion10) /* v4.1 */
 484       info->borderType = RTFBorderParaLeft;
 485     else /* v1.0 - 3.0 */
 486       info->borderType = RTFBorderParaTop;
 487     fmt.dwMask = PFM_ALIGNMENT | PFM_BORDER | PFM_LINESPACING | PFM_TABSTOPS |
 488         PFM_OFFSET | PFM_RIGHTINDENT | PFM_SPACEAFTER | PFM_SPACEBEFORE |
 489         PFM_STARTINDENT;
 490     /* TODO: numbering, shading */
 491     fmt.wAlignment = PFA_LEFT;
 492     fmt.cTabCount = 0;
 493     fmt.dxOffset = fmt.dxStartIndent = fmt.dxRightIndent = 0;
 494     fmt.wBorderWidth = fmt.wBorders = 0;
 495     fmt.wBorderSpace = 0;
 496     fmt.bLineSpacingRule = 0;
 497     fmt.dySpaceBefore = fmt.dySpaceAfter = 0;
 498     fmt.dyLineSpacing = 0;
 499     if (!info->editor->bEmulateVersion10) /* v4.1 */
 500     {
 501       if (info->tableDef && info->tableDef->tableRowStart &&
 502           info->tableDef->tableRowStart->member.para.nFlags & MEPF_ROWEND)
 503       {
 504         ME_Cursor cursor;
 505         ME_DisplayItem *para;
 506         /* We are just after a table row. */
 507         RTFFlushOutputBuffer(info);
 508         cursor = info->editor->pCursors[0];
 509         para = ME_GetParagraph(cursor.pRun);
 510         if (para  == info->tableDef->tableRowStart->member.para.next_para
 511             && !cursor.nOffset && !cursor.pRun->member.run.nCharOfs)
 512         {
 513           /* Since the table row end, no text has been inserted, and the \intbl
 514            * control word has not be used.  We can confirm that we are not in a
 515            * table anymore.
 516            */
 517           info->tableDef->tableRowStart = NULL;
 518           info->canInheritInTbl = FALSE;
 519         }
 520       }
 521     } else { /* v1.0 - v3.0 */
 522       fmt.dwMask |= PFM_TABLE;
 523       fmt.wEffects &= ~PFE_TABLE;
 524     }
 525     break;
 526   case rtfNestLevel:
 527     if (!info->editor->bEmulateVersion10) /* v4.1 */
 528     {
 529       while (info->rtfParam > info->nestingLevel) {
 530         RTFTable *tableDef = ALLOC_OBJ(RTFTable);
 531         ZeroMemory(tableDef, sizeof(RTFTable));
 532         tableDef->parent = info->tableDef;
 533         info->tableDef = tableDef;
 534
 535         RTFFlushOutputBuffer(info);
 536         if (tableDef->tableRowStart &&
 537             tableDef->tableRowStart->member.para.nFlags & MEPF_ROWEND)
 538         {
 539           ME_DisplayItem *para = tableDef->tableRowStart;
 540           para = para->member.para.next_para;
 541           para = ME_InsertTableRowStartAtParagraph(info->editor, para);
 542           tableDef->tableRowStart = para;
 543         } else {
 544           ME_Cursor cursor;
 545           WCHAR endl = '\r';
 546           cursor = info->editor->pCursors[0];
 547           if (cursor.nOffset || cursor.pRun->member.run.nCharOfs)
 548             ME_InsertTextFromCursor(info->editor, 0, &endl, 1, info->style);
 549           tableDef->tableRowStart = ME_InsertTableRowStartFromCursor(info->editor);
 550         }
 551
 552         info->nestingLevel++;
 553       }
 554       info->canInheritInTbl = FALSE;
 555     }
 556     break;
 557   case rtfInTable:
 558   {
 559     if (!info->editor->bEmulateVersion10) /* v4.1 */
 560     {
 561       if (info->nestingLevel < 1)
 562       {
 563         RTFTable *tableDef;
 564         if (!info->tableDef)
 565         {
 566             info->tableDef = ALLOC_OBJ(RTFTable);
 567             ZeroMemory(info->tableDef, sizeof(RTFTable));
 568         }
 569         tableDef = info->tableDef;
 570         RTFFlushOutputBuffer(info);
 571         if (tableDef->tableRowStart &&
 572             tableDef->tableRowStart->member.para.nFlags & MEPF_ROWEND)
 573         {
 574           ME_DisplayItem *para = tableDef->tableRowStart;
 575           para = para->member.para.next_para;
 576           para = ME_InsertTableRowStartAtParagraph(info->editor, para);
 577           tableDef->tableRowStart = para;
 578         } else {
 579           ME_Cursor cursor;
 580           WCHAR endl = '\r';
 581           cursor = info->editor->pCursors[0];
 582           if (cursor.nOffset || cursor.pRun->member.run.nCharOfs)
 583             ME_InsertTextFromCursor(info->editor, 0, &endl, 1, info->style);
 584           tableDef->tableRowStart = ME_InsertTableRowStartFromCursor(info->editor);
 585         }
 586         info->nestingLevel = 1;
 587         info->canInheritInTbl = TRUE;
 588       }
 589       return;
 590     } else { /* v1.0 - v3.0 */
 591       fmt.dwMask |= PFM_TABLE;
 592       fmt.wEffects |= PFE_TABLE;
 593     }
 594     break;
 595   }
 596   case rtfFirstIndent:
 597     ME_GetSelectionParaFormat(info->editor, &fmt);
 598     fmt.dwMask = PFM_STARTINDENT | PFM_OFFSET;
 599     fmt.dxStartIndent += fmt.dxOffset + info->rtfParam;
 600     fmt.dxOffset = -info->rtfParam;
 601     break;
 602   case rtfLeftIndent:
 603     ME_GetSelectionParaFormat(info->editor, &fmt);
 604     fmt.dwMask = PFM_STARTINDENT;
 605     fmt.dxStartIndent = info->rtfParam - fmt.dxOffset;
 606     break;
 607   case rtfRightIndent:
 608     fmt.dwMask = PFM_RIGHTINDENT;
 609     fmt.dxRightIndent = info->rtfParam;
 610     break;
 611   case rtfQuadLeft:
 612   case rtfQuadJust:
 613     fmt.dwMask = PFM_ALIGNMENT;
 614     fmt.wAlignment = PFA_LEFT;
 615     break;
 616   case rtfQuadRight:
 617     fmt.dwMask = PFM_ALIGNMENT;
 618     fmt.wAlignment = PFA_RIGHT;
 619     break;
 620   case rtfQuadCenter:
 621     fmt.dwMask = PFM_ALIGNMENT;
 622     fmt.wAlignment = PFA_CENTER;
 623     break;
 624   case rtfTabPos:
 625     ME_GetSelectionParaFormat(info->editor, &fmt);
 626     if (!(fmt.dwMask & PFM_TABSTOPS))
 627     {
 628       fmt.cTabCount = 0;
 629     }
 630     if (fmt.cTabCount < MAX_TAB_STOPS && info->rtfParam < 0x1000000)
 631       fmt.rgxTabs[fmt.cTabCount++] = info->rtfParam;
 632     fmt.dwMask = PFM_TABSTOPS;
 633     break;
 634   case rtfKeep:
 635     fmt.dwMask = PFM_KEEP;
 636     fmt.wEffects = PFE_KEEP;
 637     break;
 638   case rtfNoWidowControl:
 639     fmt.dwMask = PFM_NOWIDOWCONTROL;
 640     fmt.wEffects = PFE_NOWIDOWCONTROL;
 641     break;
 642   case rtfKeepNext:
 643     fmt.dwMask = PFM_KEEPNEXT;
 644     fmt.wEffects = PFE_KEEPNEXT;
 645     break;
 646   case rtfSpaceAfter:
 647     fmt.dwMask = PFM_SPACEAFTER;
 648     fmt.dySpaceAfter = info->rtfParam;
 649     break;
 650   case rtfSpaceBefore:
 651     fmt.dwMask = PFM_SPACEBEFORE;
 652     fmt.dySpaceBefore = info->rtfParam;
 653     break;
 654   case rtfSpaceBetween:
 655     fmt.dwMask = PFM_LINESPACING;
 656     if ((int)info->rtfParam > 0)
 657     {
 658       fmt.dyLineSpacing = info->rtfParam;
 659       fmt.bLineSpacingRule = 3;
 660     }
 661     else
 662     {
 663       fmt.dyLineSpacing = info->rtfParam;
 664       fmt.bLineSpacingRule = 4;
 665     }
 666   case rtfSpaceMultiply:
 667     fmt.dwMask = PFM_LINESPACING;
 668     fmt.dyLineSpacing = info->rtfParam * 20;
 669     fmt.bLineSpacingRule = 5;
 670     break;
 671   case rtfParBullet:
 672     fmt.dwMask = PFM_NUMBERING;
 673     fmt.wNumbering = PFN_BULLET;
 674     break;
 675   case rtfParSimple:
 676     fmt.dwMask = PFM_NUMBERING;
 677     fmt.wNumbering = 2; /* FIXME: MSDN says it's not used ?? */
 678     break;
 679   case rtfParNumDecimal:
 680     fmt.dwMask = PFM_NUMBERING;
 681     fmt.wNumbering = 2; /* FIXME: MSDN says it's not used ?? */
 682     break;
 683   case rtfParNumIndent:
 684     fmt.dwMask = PFM_NUMBERINGTAB;
 685     fmt.wNumberingTab = info->rtfParam;
 686     break;
 687   case rtfParNumStartAt:
 688     fmt.dwMask = PFM_NUMBERINGSTART;
 689     fmt.wNumberingStart = info->rtfParam;
 690     break;
 691   case rtfBorderLeft:
 692     info->borderType = RTFBorderParaLeft;
 693     ME_GetSelectionParaFormat(info->editor, &fmt);
 694     if (!(fmt.dwMask & PFM_BORDER))
 695     {
 696       fmt.wBorderSpace = 0;
 697       fmt.wBorderWidth = 1;
 698       fmt.wBorders = 0;
 699     }
 700     fmt.wBorders |= 1;
 701     fmt.dwMask = PFM_BORDER;
 702     break;
 703   case rtfBorderRight:
 704     info->borderType = RTFBorderParaRight;
 705     ME_GetSelectionParaFormat(info->editor, &fmt);
 706     if (!(fmt.dwMask & PFM_BORDER))
 707     {
 708       fmt.wBorderSpace = 0;
 709       fmt.wBorderWidth = 1;
 710       fmt.wBorders = 0;
 711     }
 712     fmt.wBorders |= 2;
 713     fmt.dwMask = PFM_BORDER;
 714     break;
 715   case rtfBorderTop:
 716     info->borderType = RTFBorderParaTop;
 717     ME_GetSelectionParaFormat(info->editor, &fmt);
 718     if (!(fmt.dwMask & PFM_BORDER))
 719     {
 720       fmt.wBorderSpace = 0;
 721       fmt.wBorderWidth = 1;
 722       fmt.wBorders = 0;
 723     }
 724     fmt.wBorders |= 4;
 725     fmt.dwMask = PFM_BORDER;
 726     break;
 727   case rtfBorderBottom:
 728     info->borderType = RTFBorderParaBottom;
 729     ME_GetSelectionParaFormat(info->editor, &fmt);
 730     if (!(fmt.dwMask & PFM_BORDER))
 731     {
 732       fmt.wBorderSpace = 0;
 733       fmt.wBorderWidth = 1;
 734       fmt.wBorders = 0;
 735     }
 736     fmt.wBorders |= 8;
 737     fmt.dwMask = PFM_BORDER;
 738     break;
 739   case rtfBorderSingle:
 740     ME_GetSelectionParaFormat(info->editor, &fmt);
 741     /* we assume that borders have been created before (RTF spec) */
 742     fmt.wBorders &= ~0x700;
 743     fmt.wBorders |= 1 << 8;
 744     fmt.dwMask = PFM_BORDER;
 745     break;
 746   case rtfBorderThick:
 747     ME_GetSelectionParaFormat(info->editor, &fmt);
 748     /* we assume that borders have been created before (RTF spec) */
 749     fmt.wBorders &= ~0x700;
 750     fmt.wBorders |= 2 << 8;
 751     fmt.dwMask = PFM_BORDER;
 752     break;
 753   case rtfBorderShadow:
 754     ME_GetSelectionParaFormat(info->editor, &fmt);
 755     /* we assume that borders have been created before (RTF spec) */
 756     fmt.wBorders &= ~0x700;
 757     fmt.wBorders |= 10 << 8;
 758     fmt.dwMask = PFM_BORDER;
 759     break;
 760   case rtfBorderDouble:
 761     ME_GetSelectionParaFormat(info->editor, &fmt);
 762     /* we assume that borders have been created before (RTF spec) */
 763     fmt.wBorders &= ~0x700;
 764     fmt.wBorders |= 7 << 8;
 765     fmt.dwMask = PFM_BORDER;
 766     break;
 767   case rtfBorderDot:
 768     ME_GetSelectionParaFormat(info->editor, &fmt);
 769     /* we assume that borders have been created before (RTF spec) */
 770     fmt.wBorders &= ~0x700;
 771     fmt.wBorders |= 11 << 8;
 772     fmt.dwMask = PFM_BORDER;
 773     break;
 774   case rtfBorderWidth:
 775   {
 776     int borderSide = info->borderType & RTFBorderSideMask;
 777     RTFTable *tableDef = info->tableDef;
 778     ME_GetSelectionParaFormat(info->editor, &fmt);
 779     /* we assume that borders have been created before (RTF spec) */
 780     fmt.wBorderWidth |= ((info->rtfParam / 15) & 7) << 8;
 781     if ((info->borderType & RTFBorderTypeMask) == RTFBorderTypeCell)
 782     {
 783       RTFBorder *border;
 784       if (!tableDef || tableDef->numCellsDefined >= MAX_TABLE_CELLS)
 785         break;
 786       border = &tableDef->cells[tableDef->numCellsDefined].border[borderSide];
 787       border->width = info->rtfParam;
 788       break;
 789     }
 790     fmt.dwMask = PFM_BORDER;
 791     break;
 792   }
 793   case rtfBorderSpace:
 794     ME_GetSelectionParaFormat(info->editor, &fmt);
 795     /* we assume that borders have been created before (RTF spec) */
 796     fmt.wBorderSpace = info->rtfParam;
 797     fmt.dwMask = PFM_BORDER;
 798     break;
 799   case rtfBorderColor:
 800   {
 801     RTFTable *tableDef = info->tableDef;
 802     int borderSide = info->borderType & RTFBorderSideMask;
 803     int borderType = info->borderType & RTFBorderTypeMask;
 804     switch(borderType)
 805     {
 806     case RTFBorderTypePara:
 807       if (!info->editor->bEmulateVersion10) /* v4.1 */
 808         break;
 809       /* v1.0 - 3.0 treat paragraph and row borders the same. */
 810     case RTFBorderTypeRow:
 811       if (tableDef) {
 812         tableDef->border[borderSide].color = info->rtfParam;
 813       }
 814       break;
 815     case RTFBorderTypeCell:
 816       if (tableDef && tableDef->numCellsDefined < MAX_TABLE_CELLS) {
 817         tableDef->cells[tableDef->numCellsDefined].border[borderSide].color = info->rtfParam;
 818       }
 819       break;
 820     }
 821     break;
 822   }
 823   }
 824   if (fmt.dwMask) {
 825     RTFFlushOutputBuffer(info);
 826     /* FIXME too slow ? how come ?*/
 827     ME_SetSelectionParaFormat(info->editor, &fmt);
 828   }
 829 }
 830
 831 void ME_RTFTblAttrHook(RTF_Info *info)
 832 {
 833   switch (info->rtfMinor)
 834   {
 835     case rtfRowDef:
 836     {
 837       if (!info->editor->bEmulateVersion10) /* v4.1 */
 838         info->borderType = 0; /* Not sure */
 839       else /* v1.0 - 3.0 */
 840         info->borderType = RTFBorderRowTop;
 841       if (!info->tableDef) {
 842         info->tableDef = ME_MakeTableDef(info->editor);
 843       } else {
 844         ME_InitTableDef(info->editor, info->tableDef);
 845       }
 846       break;
 847     }
 848     case rtfCellPos:
 849     {
 850       int cellNum;
 851       if (!info->tableDef)
 852       {
 853         info->tableDef = ME_MakeTableDef(info->editor);
 854       }
 855       cellNum = info->tableDef->numCellsDefined;
 856       if (cellNum >= MAX_TABLE_CELLS)
 857         break;
 858       info->tableDef->cells[cellNum].rightBoundary = info->rtfParam;
 859       if (cellNum < MAX_TAB_STOPS) {
 860         /* Tab stops were used to store cell positions before v4.1 but v4.1
 861          * still seems to set the tabstops without using them. */
 862         ME_DisplayItem *para = ME_GetParagraph(info->editor->pCursors[0].pRun);
 863         PARAFORMAT2 *pFmt = para->member.para.pFmt;
 864         pFmt->rgxTabs[cellNum] &= ~0x00FFFFFF;
 865         pFmt->rgxTabs[cellNum] = 0x00FFFFFF & info->rtfParam;
 866       }
 867       info->tableDef->numCellsDefined++;
 868       break;
 869     }
 870     case rtfRowBordTop:
 871       info->borderType = RTFBorderRowTop;
 872       break;
 873     case rtfRowBordLeft:
 874       info->borderType = RTFBorderRowLeft;
 875       break;
 876     case rtfRowBordBottom:
 877       info->borderType = RTFBorderRowBottom;
 878       break;
 879     case rtfRowBordRight:
 880       info->borderType = RTFBorderRowRight;
 881       break;
 882     case rtfCellBordTop:
 883       info->borderType = RTFBorderCellTop;
 884       break;
 885     case rtfCellBordLeft:
 886       info->borderType = RTFBorderCellLeft;
 887       break;
 888     case rtfCellBordBottom:
 889       info->borderType = RTFBorderCellBottom;
 890       break;
 891     case rtfCellBordRight:
 892       info->borderType = RTFBorderCellRight;
 893       break;
 894     case rtfRowGapH:
 895       if (info->tableDef)
 896         info->tableDef->gapH = info->rtfParam;
 897       break;
 898     case rtfRowLeftEdge:
 899       if (info->tableDef)
 900         info->tableDef->leftEdge = info->rtfParam;
 901       break;
 902   }
 903 }
 904
 905 void ME_RTFSpecialCharHook(RTF_Info *info)
 906 {
 907   RTFTable *tableDef = info->tableDef;
 908   switch (info->rtfMinor)
 909   {
 910     case rtfNestCell:
 911       if (info->editor->bEmulateVersion10) /* v1.0 - v3.0 */
 912         break;
 913       /* else fall through since v4.1 treats rtfNestCell and rtfCell the same */
 914     case rtfCell:
 915       if (!tableDef)
 916         break;
 917       RTFFlushOutputBuffer(info);
 918       if (!info->editor->bEmulateVersion10) { /* v4.1 */
 919         if (tableDef->tableRowStart)
 920         {
 921           if (!info->nestingLevel &&
 922               tableDef->tableRowStart->member.para.nFlags & MEPF_ROWEND)
 923           {
 924             ME_DisplayItem *para = tableDef->tableRowStart;
 925             para = para->member.para.next_para;
 926             para = ME_InsertTableRowStartAtParagraph(info->editor, para);
 927             tableDef->tableRowStart = para;
 928             info->nestingLevel = 1;
 929           }
 930           ME_InsertTableCellFromCursor(info->editor);
 931         }
 932       } else { /* v1.0 - v3.0 */
 933         ME_DisplayItem *para = ME_GetParagraph(info->editor->pCursors[0].pRun);
 934         PARAFORMAT2 *pFmt = para->member.para.pFmt;
 935         if (pFmt->dwMask & PFM_TABLE && pFmt->wEffects & PFE_TABLE &&
 936             tableDef->numCellsInserted < tableDef->numCellsDefined)
 937         {
 938           WCHAR tab = '\t';
 939           ME_InsertTextFromCursor(info->editor, 0, &tab, 1, info->style);
 940           tableDef->numCellsInserted++;
 941         }
 942       }
 943       break;
 944     case rtfNestRow:
 945       if (info->editor->bEmulateVersion10) /* v1.0 - v3.0 */
 946         break;
 947       /* else fall through since v4.1 treats rtfNestRow and rtfRow the same */
 948     case rtfRow:
 949     {
 950       ME_DisplayItem *para, *cell, *run;
 951       int i;
 952
 953       if (!tableDef)
 954         break;
 955       RTFFlushOutputBuffer(info);
 956       if (!info->editor->bEmulateVersion10) { /* v4.1 */
 957         if (!tableDef->tableRowStart)
 958           break;
 959         if (!info->nestingLevel &&
 960             tableDef->tableRowStart->member.para.nFlags & MEPF_ROWEND)
 961         {
 962           para = tableDef->tableRowStart;
 963           para = para->member.para.next_para;
 964           para = ME_InsertTableRowStartAtParagraph(info->editor, para);
 965           tableDef->tableRowStart = para;
 966           info->nestingLevel++;
 967         }
 968         para = tableDef->tableRowStart;
 969         cell = ME_FindItemFwd(para, diCell);
 970         assert(cell && !cell->member.cell.prev_cell);
 971         if (tableDef->numCellsDefined < 1)
 972         {
 973           /* 2000 twips appears to be the cell size that native richedit uses
 974            * when no cell sizes are specified. */
 975           const int defaultCellSize = 2000;
 976           int nRightBoundary = defaultCellSize;
 977           cell->member.cell.nRightBoundary = nRightBoundary;
 978           while (cell->member.cell.next_cell) {
 979             cell = cell->member.cell.next_cell;
 980             nRightBoundary += defaultCellSize;
 981             cell->member.cell.nRightBoundary = nRightBoundary;
 982           }
 983           para = ME_InsertTableCellFromCursor(info->editor);
 984           cell = para->member.para.pCell;
 985           cell->member.cell.nRightBoundary = nRightBoundary;
 986         } else {
 987           for (i = 0; i < tableDef->numCellsDefined; i++)
 988           {
 989             RTFCell *cellDef = &tableDef->cells[i];
 990             cell->member.cell.nRightBoundary = cellDef->rightBoundary;
 991             ME_ApplyBorderProperties(info, &cell->member.cell.border,
 992                                      cellDef->border);
 993             cell = cell->member.cell.next_cell;
 994             if (!cell)
 995             {
 996               para = ME_InsertTableCellFromCursor(info->editor);
 997               cell = para->member.para.pCell;
 998             }
 999           }
1000           /* Cell for table row delimiter is empty */
1001           cell->member.cell.nRightBoundary = tableDef->cells[i-1].rightBoundary;
1002         }
1003
1004         run = ME_FindItemFwd(cell, diRun);
1005         if (info->editor->pCursors[0].pRun != run ||
1006             info->editor->pCursors[0].nOffset)
1007         {
1008           int nOfs, nChars;
1009           /* Delete inserted cells that aren't defined. */
1010           info->editor->pCursors[1].pRun = run;
1011           info->editor->pCursors[1].nOffset = 0;
1012           nOfs = ME_GetCursorOfs(info->editor, 1);
1013           nChars = ME_GetCursorOfs(info->editor, 0) - nOfs;
1014           ME_InternalDeleteText(info->editor, nOfs, nChars, TRUE);
1015         }
1016
1017         para = ME_InsertTableRowEndFromCursor(info->editor);
1018         para->member.para.pFmt->dxOffset = abs(info->tableDef->gapH);
1019         para->member.para.pFmt->dxStartIndent = info->tableDef->leftEdge;
1020         ME_ApplyBorderProperties(info, &para->member.para.border,
1021                                  tableDef->border);
1022         info->nestingLevel--;
1023         if (!info->nestingLevel)
1024         {
1025           if (info->canInheritInTbl) {
1026             tableDef->tableRowStart = para;
1027           } else {
1028             while (info->tableDef) {
1029               tableDef = info->tableDef;
1030               info->tableDef = tableDef->parent;
1031               heap_free(tableDef);
1032             }
1033           }
1034         } else {
1035           info->tableDef = tableDef->parent;
1036           heap_free(tableDef);
1037         }
1038       } else { /* v1.0 - v3.0 */
1039         WCHAR endl = '\r';
1040         ME_DisplayItem *para = ME_GetParagraph(info->editor->pCursors[0].pRun);
1041         PARAFORMAT2 *pFmt = para->member.para.pFmt;
1042         pFmt->dxOffset = info->tableDef->gapH;
1043         pFmt->dxStartIndent = info->tableDef->leftEdge;
1044
1045         para = ME_GetParagraph(info->editor->pCursors[0].pRun);
1046         ME_ApplyBorderProperties(info, &para->member.para.border,
1047                                  tableDef->border);
1048         while (tableDef->numCellsInserted < tableDef->numCellsDefined)
1049         {
1050           WCHAR tab = '\t';
1051           ME_InsertTextFromCursor(info->editor, 0, &tab, 1, info->style);
1052           tableDef->numCellsInserted++;
1053         }
1054         pFmt->cTabCount = min(tableDef->numCellsDefined, MAX_TAB_STOPS);
1055         if (!tableDef->numCellsDefined)
1056           pFmt->wEffects &= ~PFE_TABLE;
1057         ME_InsertTextFromCursor(info->editor, 0, &endl, 1, info->style);
1058         tableDef->numCellsInserted = 0;
1059       }
1060       break;
1061     }
1062     case rtfTab:
1063     case rtfPar:
1064       if (info->editor->bEmulateVersion10) { /* v1.0 - 3.0 */
1065         ME_DisplayItem *para;
1066         PARAFORMAT2 *pFmt;
1067         RTFFlushOutputBuffer(info);
1068         para = ME_GetParagraph(info->editor->pCursors[0].pRun);
1069         pFmt = para->member.para.pFmt;
1070         if (pFmt->dwMask & PFM_TABLE && pFmt->wEffects & PFE_TABLE)
1071         {
1072           /* rtfPar is treated like a space within a table. */
1073           info->rtfClass = rtfText;
1074           info->rtfMajor = ' ';
1075         }
1076         else if (info->rtfMinor == rtfPar && tableDef)
1077           tableDef->numCellsInserted = 0;
1078       }
1079       break;
1080   }
1081 }
1082
1083 static BOOL ME_RTFInsertOleObject(RTF_Info *info, HENHMETAFILE hemf, HBITMAP hbmp,
1084                                   const SIZEL* sz)
1085 {
1086   LPOLEOBJECT         lpObject = NULL;
1087   LPSTORAGE           lpStorage = NULL;
1088   LPOLECLIENTSITE     lpClientSite = NULL;
1089   LPDATAOBJECT        lpDataObject = NULL;
1090   LPOLECACHE          lpOleCache = NULL;
1091   STGMEDIUM           stgm;
1092   FORMATETC           fm;
1093   CLSID               clsid;
1094   BOOL                ret = FALSE;
1095   DWORD               conn;
1096
1097   if (hemf)
1098   {
1099       stgm.tymed = TYMED_ENHMF;
1100       stgm.u.hEnhMetaFile = hemf;
1101       fm.cfFormat = CF_ENHMETAFILE;
1102   }
1103   else if (hbmp)
1104   {
1105       stgm.tymed = TYMED_GDI;
1106       stgm.u.hBitmap = hbmp;
1107       fm.cfFormat = CF_BITMAP;
1108   }
1109   stgm.pUnkForRelease = NULL;
1110
1111   fm.ptd = NULL;
1112   fm.dwAspect = DVASPECT_CONTENT;
1113   fm.lindex = -1;
1114   fm.tymed = stgm.tymed;
1115
1116   if (!info->lpRichEditOle)
1117   {
1118     CreateIRichEditOle(info->editor, (VOID**)&info->lpRichEditOle);
1119   }
1120
1121   if (OleCreateDefaultHandler(&CLSID_NULL, NULL, &IID_IOleObject, (void**)&lpObject) == S_OK &&
1122 #if 0
1123       /* FIXME: enable it when rich-edit properly implements this method */
1124       IRichEditOle_GetClientSite(info->lpRichEditOle, &lpClientSite) == S_OK &&
1125       IOleObject_SetClientSite(lpObject, lpClientSite) == S_OK &&
1126 #endif
1127       IOleObject_GetUserClassID(lpObject, &clsid) == S_OK &&
1128       IOleObject_QueryInterface(lpObject, &IID_IOleCache, (void**)&lpOleCache) == S_OK &&
1129       IOleCache_Cache(lpOleCache, &fm, 0, &conn) == S_OK &&
1130       IOleObject_QueryInterface(lpObject, &IID_IDataObject, (void**)&lpDataObject) == S_OK &&
1131       IDataObject_SetData(lpDataObject, &fm, &stgm, TRUE) == S_OK)
1132   {
1133     REOBJECT            reobject;
1134
1135     reobject.cbStruct = sizeof(reobject);
1136     reobject.cp = REO_CP_SELECTION;
1137     reobject.clsid = clsid;
1138     reobject.poleobj = lpObject;
1139     reobject.pstg = lpStorage;
1140     reobject.polesite = lpClientSite;
1141     /* convert from twips to .01 mm */
1142     reobject.sizel.cx = MulDiv(sz->cx, 254, 144);
1143     reobject.sizel.cy = MulDiv(sz->cy, 254, 144);
1144     reobject.dvaspect = DVASPECT_CONTENT;
1145     reobject.dwFlags = 0; /* FIXME */
1146     reobject.dwUser = 0;
1147
1148     /* FIXME: could be simpler */
1149     ret = IRichEditOle_InsertObject(info->lpRichEditOle, &reobject) == S_OK;
1150   }
1151
1152   if (lpObject)       IOleObject_Release(lpObject);
1153   if (lpClientSite)   IOleClientSite_Release(lpClientSite);
1154   if (lpStorage)      IStorage_Release(lpStorage);
1155   if (lpDataObject)   IDataObject_Release(lpDataObject);
1156   if (lpOleCache)     IOleCache_Release(lpOleCache);
1157
1158   return ret;
1159 }
1160
1161 static void ME_RTFReadPictGroup(RTF_Info *info)
1162 {
1163   SIZEL         sz;
1164   BYTE*         buffer = NULL;
1165   unsigned      bufsz, bufidx;
1166   BOOL          flip;
1167   BYTE          val;
1168   METAFILEPICT  mfp;
1169   HENHMETAFILE  hemf;
1170   HBITMAP       hbmp;
1171   enum gfxkind {gfx_unknown = 0, gfx_enhmetafile, gfx_metafile, gfx_dib} gfx = gfx_unknown;
1172
1173   RTFGetToken (info);
1174   if (info->rtfClass == rtfEOF)
1175     return;
1176   mfp.mm = MM_TEXT;
1177   /* fetch picture type */
1178   if (RTFCheckMM (info, rtfPictAttr, rtfWinMetafile))
1179   {
1180     mfp.mm = info->rtfParam;
1181     gfx = gfx_metafile;
1182   }
1183   else if (RTFCheckMM (info, rtfPictAttr, rtfDevIndBitmap))
1184   {
1185     if (info->rtfParam != 0) FIXME("dibitmap should be 0 (%d)\n", info->rtfParam);
1186     gfx = gfx_dib;
1187   }
1188   else if (RTFCheckMM (info, rtfPictAttr, rtfEmfBlip))
1189   {
1190     gfx = gfx_enhmetafile;
1191   }
1192   else
1193   {
1194     FIXME("%d %d\n", info->rtfMajor, info->rtfMinor);
1195     goto skip_group;
1196   }
1197   sz.cx = sz.cy = 0;
1198   /* fetch picture attributes */
1199   for (;;)
1200   {
1201     RTFGetToken (info);
1202     if (info->rtfClass == rtfEOF)
1203       return;
1204     if (info->rtfClass == rtfText)
1205       break;
1206     if (!RTFCheckCM (info, rtfControl, rtfPictAttr))
1207     {
1208       ERR("Expected picture attribute (%d %d)\n",
1209         info->rtfClass, info->rtfMajor);
1210       goto skip_group;
1211     }
1212     else if (RTFCheckMM (info, rtfPictAttr, rtfPicWid))
1213     {
1214       if (gfx == gfx_metafile) mfp.xExt = info->rtfParam;
1215     }
1216     else if (RTFCheckMM (info, rtfPictAttr, rtfPicHt))
1217     {
1218       if (gfx == gfx_metafile) mfp.yExt = info->rtfParam;
1219     }
1220     else if (RTFCheckMM (info, rtfPictAttr, rtfPicGoalWid))
1221       sz.cx = info->rtfParam;
1222     else if (RTFCheckMM (info, rtfPictAttr, rtfPicGoalHt))
1223       sz.cy = info->rtfParam;
1224     else
1225       FIXME("Non supported attribute: %d %d %d\n", info->rtfClass, info->rtfMajor, info->rtfMinor);
1226   }
1227   /* fetch picture data */
1228   bufsz = 1024;
1229   bufidx = 0;
1230   buffer = HeapAlloc(GetProcessHeap(), 0, bufsz);
1231   val = info->rtfMajor;
1232   for (flip = TRUE;; flip = !flip)
1233   {
1234     RTFGetToken (info);
1235     if (info->rtfClass == rtfEOF)
1236     {
1237       HeapFree(GetProcessHeap(), 0, buffer);
1238       return; /* Warn ?? */
1239     }
1240     if (RTFCheckCM(info, rtfGroup, rtfEndGroup))
1241       break;
1242     if (info->rtfClass != rtfText) goto skip_group;
1243     if (flip)
1244     {
1245       if (bufidx >= bufsz &&
1246           !(buffer = HeapReAlloc(GetProcessHeap(), 0, buffer, bufsz += 1024)))
1247         goto skip_group;
1248       buffer[bufidx++] = RTFCharToHex(val) * 16 + RTFCharToHex(info->rtfMajor);
1249     }
1250     else
1251       val = info->rtfMajor;
1252   }
1253   if (flip) FIXME("wrong hex string\n");
1254
1255   switch (gfx)
1256   {
1257   case gfx_enhmetafile:
1258     if ((hemf = SetEnhMetaFileBits(bufidx, buffer)))
1259       ME_RTFInsertOleObject(info, hemf, NULL, &sz);
1260     break;
1261   case gfx_metafile:
1262     if ((hemf = SetWinMetaFileBits(bufidx, buffer, NULL, &mfp)))
1263         ME_RTFInsertOleObject(info, hemf, NULL, &sz);
1264     break;
1265   case gfx_dib:
1266     {
1267       BITMAPINFO* bi = (BITMAPINFO*)buffer;
1268       HDC         hdc = GetDC(0);
1269       unsigned    nc = bi->bmiHeader.biClrUsed;
1270
1271       /* not quite right, especially for bitfields type of compression */
1272       if (!nc && bi->bmiHeader.biBitCount <= 8)
1273         nc = 1 << bi->bmiHeader.biBitCount;
1274       if ((hbmp = CreateDIBitmap(hdc, &bi->bmiHeader,
1275                                  CBM_INIT, (char*)(bi + 1) + nc * sizeof(RGBQUAD),
1276                                  bi, DIB_RGB_COLORS)))
1277           ME_RTFInsertOleObject(info, NULL, hbmp, &sz);
1278       ReleaseDC(0, hdc);
1279     }
1280     break;
1281   default:
1282     break;
1283   }
1284   HeapFree(GetProcessHeap(), 0, buffer);
1285   RTFRouteToken (info); /* feed "}" back to router */
1286   return;
1287 skip_group:
1288   HeapFree(GetProcessHeap(), 0, buffer);
1289   RTFSkipGroup(info);
1290   RTFRouteToken(info);  /* feed "}" back to router */
1291 }
1292
1293 /* for now, lookup the \result part and use it, whatever the object */
1294 static void ME_RTFReadObjectGroup(RTF_Info *info)
1295 {
1296   for (;;)
1297   {
1298     RTFGetToken (info);
1299     if (info->rtfClass == rtfEOF)
1300       return;
1301     if (RTFCheckCM(info, rtfGroup, rtfEndGroup))
1302       break;
1303     if (RTFCheckCM(info, rtfGroup, rtfBeginGroup))
1304     {
1305       RTFGetToken (info);
1306       if (info->rtfClass == rtfEOF)
1307         return;
1308       if (RTFCheckCMM(info, rtfControl, rtfDestination, rtfObjResult))
1309       {
1310         int     level = 1;
1311
1312         while (RTFGetToken (info) != rtfEOF)
1313         {
1314           if (info->rtfClass == rtfGroup)
1315           {
1316             if (info->rtfMajor == rtfBeginGroup) level++;
1317             else if (info->rtfMajor == rtfEndGroup && --level < 0) break;
1318           }
1319           RTFRouteToken(info);
1320         }
1321       }
1322       else RTFSkipGroup(info);
1323       continue;
1324     }
1325     if (!RTFCheckCM (info, rtfControl, rtfObjAttr))
1326     {
1327       FIXME("Non supported attribute: %d %d %d\n", info->rtfClass, info->rtfMajor, info->rtfMinor);
1328       return;
1329     }
1330   }
1331   RTFRouteToken(info);  /* feed "}" back to router */
1332 }
1333
1334 static void ME_RTFReadHook(RTF_Info *info)
1335 {
1336   switch(info->rtfClass)
1337   {
1338     case rtfGroup:
1339       switch(info->rtfMajor)
1340       {
1341         case rtfBeginGroup:
1342           if (info->stackTop < maxStack) {
1343             info->stack[info->stackTop].fmt = info->style->fmt;
1344             info->stack[info->stackTop].codePage = info->codePage;
1345             info->stack[info->stackTop].unicodeLength = info->unicodeLength;
1346           }
1347           info->stackTop++;
1348           info->styleChanged = FALSE;
1349           break;
1350         case rtfEndGroup:
1351         {
1352           ME_Style *s;
1353           RTFFlushOutputBuffer(info);
1354           info->stackTop--;
1355           if (info->stackTop<=0) {
1356             info->rtfClass = rtfEOF;
1357             return;
1358           }
1359           assert(info->stackTop >= 0);
1360           if (info->styleChanged)
1361           {
1362             /* FIXME too slow ? how come ? */
1363             s = ME_ApplyStyle(info->style, &info->stack[info->stackTop].fmt);
1364             ME_ReleaseStyle(info->style);
1365             info->style = s;
1366             info->codePage = info->stack[info->stackTop].codePage;
1367             info->unicodeLength = info->stack[info->stackTop].unicodeLength;
1368           }
1369           break;
1370         }
1371       }
1372       break;
1373   }
1374 }
1375
1376 void
1377 ME_StreamInFill(ME_InStream *stream)
1378 {
1379   stream->editstream->dwError = stream->editstream->pfnCallback(stream->editstream->dwCookie,
1380                                                                 (BYTE *)stream->buffer,
1381                                                                 sizeof(stream->buffer),
1382                                                                 (LONG *)&stream->dwSize);
1383   stream->dwUsed = 0;
1384 }
1385
1386 static LRESULT ME_StreamIn(ME_TextEditor *editor, DWORD format, EDITSTREAM *stream, BOOL stripLastCR)
1387 {
1388   RTF_Info parser;
1389   ME_Style *style;
1390   int from, to, to2, nUndoMode;
1391   int nEventMask = editor->nEventMask;
1392   ME_InStream inStream;
1393   BOOL invalidRTF = FALSE;
1394
1395   TRACE("stream==%p hWnd==%p format==0x%X\n", stream, editor->hWnd, format);
1396   editor->nEventMask = 0;
1397
1398   ME_GetSelection(editor, &from, &to);
1399   if ((format & SFF_SELECTION) && (editor->mode & TM_RICHTEXT)) {
1400     style = ME_GetSelectionInsertStyle(editor);
1401
1402     ME_InternalDeleteText(editor, from, to-from, FALSE);
1403
1404     /* Don't insert text at the end of the table row */
1405     if (!editor->bEmulateVersion10) { /* v4.1 */
1406       ME_DisplayItem *para = ME_GetParagraph(editor->pCursors->pRun);
1407       if (para->member.para.nFlags & MEPF_ROWEND)
1408       {
1409         para = para->member.para.next_para;
1410         editor->pCursors[0].pRun = ME_FindItemFwd(para, diRun);
1411         editor->pCursors[0].nOffset = 0;
1412       }
1413       if (para->member.para.nFlags & MEPF_ROWSTART)
1414       {
1415         para = para->member.para.next_para;
1416         editor->pCursors[0].pRun = ME_FindItemFwd(para, diRun);
1417         editor->pCursors[0].nOffset = 0;
1418       }
1419       editor->pCursors[1] = editor->pCursors[0];
1420     } else { /* v1.0 - 3.0 */
1421       if (editor->pCursors[0].pRun->member.run.nFlags & MERF_ENDPARA &&
1422           ME_IsInTable(editor->pCursors[0].pRun))
1423         return 0;
1424     }
1425   }
1426   else {
1427     ME_DisplayItem *para_item;
1428     style = editor->pBuffer->pDefaultStyle;
1429     ME_AddRefStyle(style);
1430     ME_SetSelection(editor, 0, 0);
1431     ME_InternalDeleteText(editor, 0, ME_GetTextLength(editor), FALSE);
1432     from = to = 0;
1433     ME_ClearTempStyle(editor);
1434
1435     para_item = ME_GetParagraph(editor->pCursors[0].pRun);
1436     ME_SetDefaultParaFormat(para_item->member.para.pFmt);
1437   }
1438
1439
1440   /* Back up undo mode to a local variable */
1441   nUndoMode = editor->nUndoMode;
1442
1443   /* Only create an undo if SFF_SELECTION is set */
1444   if (!(format & SFF_SELECTION))
1445     editor->nUndoMode = umIgnore;
1446
1447   inStream.editstream = stream;
1448   inStream.editstream->dwError = 0;
1449   inStream.dwSize = 0;
1450   inStream.dwUsed = 0;
1451
1452   if (format & SF_RTF)
1453   {
1454     /* Check if it's really RTF, and if it is not, use plain text */
1455     ME_StreamInFill(&inStream);
1456     if (!inStream.editstream->dwError)
1457     {
1458       if ((!editor->bEmulateVersion10 && strncmp(inStream.buffer, "{\\rtf", 5) && strncmp(inStream.buffer, "{\\urtf", 6))
1459         || (editor->bEmulateVersion10 && *inStream.buffer != '{'))
1460       {
1461         invalidRTF = TRUE;
1462         inStream.editstream->dwError = -16;
1463       }
1464     }
1465   }
1466
1467   if (!invalidRTF && !inStream.editstream->dwError)
1468   {
1469     if (format & SF_RTF) {
1470       /* setup the RTF parser */
1471       memset(&parser, 0, sizeof parser);
1472       RTFSetEditStream(&parser, &inStream);
1473       parser.rtfFormat = format&(SF_TEXT|SF_RTF);
1474       parser.editor = editor;
1475       parser.style = style;
1476       WriterInit(&parser);
1477       RTFInit(&parser);
1478       RTFSetReadHook(&parser, ME_RTFReadHook);
1479       RTFSetDestinationCallback(&parser, rtfPict, ME_RTFReadPictGroup);
1480       RTFSetDestinationCallback(&parser, rtfObject, ME_RTFReadObjectGroup);
1481       if (!parser.editor->bEmulateVersion10) /* v4.1 */
1482       {
1483         RTFSetDestinationCallback(&parser, rtfNoNestTables, RTFSkipGroup);
1484         RTFSetDestinationCallback(&parser, rtfNestTableProps, RTFReadGroup);
1485       }
1486       BeginFile(&parser);
1487
1488       /* do the parsing */
1489       RTFRead(&parser);
1490       RTFFlushOutputBuffer(&parser);
1491       if (!editor->bEmulateVersion10) { /* v4.1 */
1492         if (parser.tableDef && parser.tableDef->tableRowStart &&
1493             (parser.nestingLevel > 0 || parser.canInheritInTbl))
1494         {
1495           /* Delete any incomplete table row at the end of the rich text. */
1496           int nOfs, nChars;
1497           ME_DisplayItem *pCell;
1498           ME_DisplayItem *para;
1499
1500           parser.rtfMinor = rtfRow;
1501           /* Complete the table row before deleting it.
1502            * By doing it this way we will have the current paragraph format set
1503            * properly to reflect that is not in the complete table, and undo items
1504            * will be added for this change to the current paragraph format. */
1505           if (parser.nestingLevel > 0)
1506           {
1507             while (parser.nestingLevel > 1)
1508               ME_RTFSpecialCharHook(&parser); /* Decrements nestingLevel */
1509             para = parser.tableDef->tableRowStart;
1510             ME_RTFSpecialCharHook(&parser);
1511           } else {
1512             para = parser.tableDef->tableRowStart;
1513             ME_RTFSpecialCharHook(&parser);
1514             assert(para->member.para.nFlags & MEPF_ROWEND);
1515             para = para->member.para.next_para;
1516           }
1517           pCell = para->member.para.pCell;
1518
1519           editor->pCursors[1].pRun = ME_FindItemFwd(para, diRun);
1520           editor->pCursors[1].nOffset = 0;
1521           nOfs = ME_GetCursorOfs(editor, 1);
1522           nChars = ME_GetCursorOfs(editor, 0) - nOfs;
1523           ME_InternalDeleteText(editor, nOfs, nChars, TRUE);
1524           if (parser.tableDef)
1525             parser.tableDef->tableRowStart = NULL;
1526         }
1527       }
1528       ME_CheckTablesForCorruption(editor);
1529       RTFDestroy(&parser);
1530       if (parser.lpRichEditOle)
1531         IRichEditOle_Release(parser.lpRichEditOle);
1532
1533       if (!inStream.editstream->dwError && parser.stackTop > 0)
1534         inStream.editstream->dwError = HRESULT_FROM_WIN32(ERROR_HANDLE_EOF);
1535
1536       /* Remove last line break, as mandated by tests. This is not affected by
1537          CR/LF counters, since RTF streaming presents only \para tokens, which
1538          are converted according to the standard rules: \r for 2.0, \r\n for 1.0
1539        */
1540       if (stripLastCR) {
1541         int newfrom, newto;
1542         ME_GetSelection(editor, &newfrom, &newto);
1543         if (newto > to + (editor->bEmulateVersion10 ? 1 : 0)) {
1544           WCHAR lastchar[3] = {'\0', '\0'};
1545           int linebreakSize = editor->bEmulateVersion10 ? 2 : 1;
1546
1547           ME_GetTextW(editor, lastchar, newto - linebreakSize, linebreakSize, 0);
1548           if (lastchar[0] == '\r' && (lastchar[1] == '\n' || lastchar[1] == '\0')) {
1549             ME_InternalDeleteText(editor, newto - linebreakSize, linebreakSize, FALSE);
1550           }
1551         }
1552       }
1553
1554       style = parser.style;
1555     }
1556     else if (format & SF_TEXT)
1557       ME_StreamInText(editor, format, &inStream, style);
1558     else
1559       ERR("EM_STREAMIN without SF_TEXT or SF_RTF\n");
1560     ME_GetSelection(editor, &to, &to2);
1561     /* put the cursor at the top */
1562     if (!(format & SFF_SELECTION))
1563       ME_SetSelection(editor, 0, 0);
1564   }
1565
1566   /* Restore saved undo mode */
1567   editor->nUndoMode = nUndoMode;
1568
1569   /* even if we didn't add an undo, we need to commit anything on the stack */
1570   ME_CommitUndo(editor);
1571
1572   /* If SFF_SELECTION isn't set, delete any undos from before we started too */
1573   if (!(format & SFF_SELECTION))
1574     ME_EmptyUndoStack(editor);
1575
1576   ME_ReleaseStyle(style);
1577   editor->nEventMask = nEventMask;
1578   ME_UpdateRepaint(editor);
1579   if (!(format & SFF_SELECTION)) {
1580     ME_ClearTempStyle(editor);
1581   }
1582   HideCaret(editor->hWnd);
1583   ME_MoveCaret(editor);
1584   ShowCaret(editor->hWnd);
1585   ME_SendSelChange(editor);
1586   ME_SendRequestResize(editor, FALSE);
1587
1588   return 0;
1589 }
1590
1591
1592 typedef struct tagME_RTFStringStreamStruct
1593 {
1594   char *string;
1595   int pos;
1596   int length;
1597 } ME_RTFStringStreamStruct;
1598
1599 static DWORD CALLBACK ME_ReadFromRTFString(DWORD_PTR dwCookie, LPBYTE lpBuff, LONG cb, LONG *pcb)
1600 {
1601   ME_RTFStringStreamStruct *pStruct = (ME_RTFStringStreamStruct *)dwCookie;
1602   int count;
1603
1604   count = min(cb, pStruct->length - pStruct->pos);
1605   memmove(lpBuff, pStruct->string + pStruct->pos, count);
1606   pStruct->pos += count;
1607   *pcb = count;
1608   return 0;
1609 }
1610
1611 static void
1612 ME_StreamInRTFString(ME_TextEditor *editor, BOOL selection, char *string)
1613 {
1614   EDITSTREAM es;
1615   ME_RTFStringStreamStruct data;
1616
1617   data.string = string;
1618   data.length = strlen(string);
1619   data.pos = 0;
1620   es.dwCookie = (DWORD_PTR)&data;
1621   es.pfnCallback = ME_ReadFromRTFString;
1622   ME_StreamIn(editor, SF_RTF | (selection ? SFF_SELECTION : 0), &es, FALSE);
1623 }
1624
1625
1626 ME_DisplayItem *
1627 ME_FindItemAtOffset(ME_TextEditor *editor, ME_DIType nItemType, int nOffset, int *nItemOffset)
1628 {
1629   ME_DisplayItem *item = ME_FindItemFwd(editor->pBuffer->pFirst, diParagraph);
1630   int runLength;
1631
1632   while (item && item->member.para.next_para->member.para.nCharOfs <= nOffset)
1633     item = ME_FindItemFwd(item, diParagraph);
1634
1635   if (!item)
1636     return item;
1637
1638   nOffset -= item->member.para.nCharOfs;
1639   if (nItemType == diParagraph) {
1640     if (nItemOffset)
1641       *nItemOffset = nOffset;
1642     return item;
1643   }
1644
1645   do {
1646     item = ME_FindItemFwd(item, diRun);
1647     runLength = ME_StrLen(item->member.run.strText);
1648     if (item->member.run.nFlags & MERF_ENDPARA)
1649       runLength = item->member.run.nCR + item->member.run.nLF;
1650   } while (item && (item->member.run.nCharOfs + runLength <= nOffset));
1651   if (item) {
1652     nOffset -= item->member.run.nCharOfs;
1653
1654     /* Special case: nOffset may not point exactly at the division between the
1655        \r and the \n in 1.0 emulation. If such a case happens, it is sent
1656        into the next run, if one exists
1657      */
1658     if (   item->member.run.nFlags & MERF_ENDPARA
1659         && nOffset == item->member.run.nCR
1660         && item->member.run.nLF > 0) {
1661       ME_DisplayItem *nextItem;
1662       nextItem = ME_FindItemFwd(item, diRun);
1663       if (nextItem) {
1664         nOffset = 0;
1665         item = nextItem;
1666       }
1667     }
1668     if (nItemOffset)
1669       *nItemOffset = nOffset;
1670   }
1671   return item;
1672 }
1673
1674
1675 static int
1676 ME_FindText(ME_TextEditor *editor, DWORD flags, const CHARRANGE *chrg, const WCHAR *text, CHARRANGE *chrgText)
1677 {
1678   const int nLen = lstrlenW(text);
1679   const int nTextLen = ME_GetTextLength(editor);
1680   int nStart, nEnd;
1681   int nMin, nMax;
1682   ME_DisplayItem *item;
1683   ME_DisplayItem *para;
1684   WCHAR wLastChar = ' ';
1685
1686   TRACE("flags==0x%08x, chrg->cpMin==%d, chrg->cpMax==%d text==%s\n",
1687         flags, chrg->cpMin, chrg->cpMax, debugstr_w(text));
1688
1689   if (flags & ~(FR_DOWN | FR_MATCHCASE | FR_WHOLEWORD))
1690     FIXME("Flags 0x%08x not implemented\n",
1691         flags & ~(FR_DOWN | FR_MATCHCASE | FR_WHOLEWORD));
1692
1693   nMin = chrg->cpMin;
1694   if (chrg->cpMax == -1)
1695     nMax = nTextLen;
1696   else
1697     nMax = chrg->cpMax > nTextLen ? nTextLen : chrg->cpMax;
1698
1699   /* In 1.0 emulation, if cpMax reaches end of text, add the FR_DOWN flag */
1700   if (editor->bEmulateVersion10 && nMax == nTextLen)
1701   {
1702     flags |= FR_DOWN;
1703   }
1704
1705   /* In 1.0 emulation, cpMin must always be no greater than cpMax */
1706   if (editor->bEmulateVersion10 && nMax < nMin)
1707   {
1708     if (chrgText)
1709     {
1710       chrgText->cpMin = -1;
1711       chrgText->cpMax = -1;
1712     }
1713     return -1;
1714   }
1715
1716   /* when searching up, if cpMin < cpMax, then instead of searching
1717    * on [cpMin,cpMax], we search on [0,cpMin], otherwise, search on
1718    * [cpMax, cpMin]. The exception is when cpMax is -1, in which
1719    * case, it is always bigger than cpMin.
1720    */
1721   if (!editor->bEmulateVersion10 && !(flags & FR_DOWN))
1722   {
1723     int nSwap = nMax;
1724
1725     nMax = nMin > nTextLen ? nTextLen : nMin;
1726     if (nMin < nSwap || chrg->cpMax == -1)
1727       nMin = 0;
1728     else
1729       nMin = nSwap;
1730   }
1731
1732   if (!nLen || nMin < 0 || nMax < 0 || nMax < nMin)
1733   {
1734     if (chrgText)
1735       chrgText->cpMin = chrgText->cpMax = -1;
1736     return -1;
1737   }
1738
1739   if (flags & FR_DOWN) /* Forward search */
1740   {
1741     /* If possible, find the character before where the search starts */
1742     if ((flags & FR_WHOLEWORD) && nMin)
1743     {
1744       nStart = nMin - 1;
1745       item = ME_FindItemAtOffset(editor, diRun, nStart, &nStart);
1746       if (!item)
1747       {
1748         if (chrgText)
1749           chrgText->cpMin = chrgText->cpMax = -1;
1750         return -1;
1751       }
1752       wLastChar = item->member.run.strText->szData[nStart];
1753     }
1754
1755     nStart = nMin;
1756     item = ME_FindItemAtOffset(editor, diRun, nStart, &nStart);
1757     if (!item)
1758     {
1759       if (chrgText)
1760         chrgText->cpMin = chrgText->cpMax = -1;
1761       return -1;
1762     }
1763
1764     para = ME_GetParagraph(item);
1765     while (item
1766            && para->member.para.nCharOfs + item->member.run.nCharOfs + nStart + nLen <= nMax)
1767     {
1768       ME_DisplayItem *pCurItem = item;
1769       int nCurStart = nStart;
1770       int nMatched = 0;
1771
1772       while (pCurItem && ME_CharCompare(pCurItem->member.run.strText->szData[nCurStart + nMatched], text[nMatched], (flags & FR_MATCHCASE)))
1773       {
1774         if ((flags & FR_WHOLEWORD) && isalnumW(wLastChar))
1775           break;
1776
1777         nMatched++;
1778         if (nMatched == nLen)
1779         {
1780           ME_DisplayItem *pNextItem = pCurItem;
1781           int nNextStart = nCurStart;
1782           WCHAR wNextChar;
1783
1784           /* Check to see if next character is a whitespace */
1785           if (flags & FR_WHOLEWORD)
1786           {
1787             if (nCurStart + nMatched == ME_StrLen(pCurItem->member.run.strText))
1788             {
1789               pNextItem = ME_FindItemFwd(pCurItem, diRun);
1790               nNextStart = -nMatched;
1791             }
1792
1793             if (pNextItem)
1794               wNextChar = pNextItem->member.run.strText->szData[nNextStart + nMatched];
1795             else
1796               wNextChar = ' ';
1797
1798             if (isalnumW(wNextChar))
1799               break;
1800           }
1801
1802           nStart += para->member.para.nCharOfs + item->member.run.nCharOfs;
1803           if (chrgText)
1804           {
1805             chrgText->cpMin = nStart;
1806             chrgText->cpMax = nStart + nLen;
1807           }
1808           TRACE("found at %d-%d\n", nStart, nStart + nLen);
1809           return nStart;
1810         }
1811         if (nCurStart + nMatched == ME_StrLen(pCurItem->member.run.strText))
1812         {
1813           pCurItem = ME_FindItemFwd(pCurItem, diRun);
1814           para = ME_GetParagraph(pCurItem);
1815           nCurStart = -nMatched;
1816         }
1817       }
1818       if (pCurItem)
1819         wLastChar = pCurItem->member.run.strText->szData[nCurStart + nMatched];
1820       else
1821         wLastChar = ' ';
1822
1823       nStart++;
1824       if (nStart == ME_StrLen(item->member.run.strText))
1825       {
1826         item = ME_FindItemFwd(item, diRun);
1827         para = ME_GetParagraph(item);
1828         nStart = 0;
1829       }
1830     }
1831   }
1832   else /* Backward search */
1833   {
1834     /* If possible, find the character after where the search ends */
1835     if ((flags & FR_WHOLEWORD) && nMax < nTextLen - 1)
1836     {
1837       nEnd = nMax + 1;
1838       item = ME_FindItemAtOffset(editor, diRun, nEnd, &nEnd);
1839       if (!item)
1840       {
1841         if (chrgText)
1842           chrgText->cpMin = chrgText->cpMax = -1;
1843         return -1;
1844       }
1845       wLastChar = item->member.run.strText->szData[nEnd];
1846     }
1847
1848     nEnd = nMax;
1849     item = ME_FindItemAtOffset(editor, diRun, nEnd, &nEnd);
1850     if (!item)
1851     {
1852       if (chrgText)
1853         chrgText->cpMin = chrgText->cpMax = -1;
1854       return -1;
1855     }
1856
1857     para = ME_GetParagraph(item);
1858
1859     while (item
1860            && para->member.para.nCharOfs + item->member.run.nCharOfs + nEnd - nLen >= nMin)
1861     {
1862       ME_DisplayItem *pCurItem = item;
1863       int nCurEnd = nEnd;
1864       int nMatched = 0;
1865
1866       if (nCurEnd - nMatched == 0)
1867       {
1868         pCurItem = ME_FindItemBack(pCurItem, diRun);
1869         para = ME_GetParagraph(pCurItem);
1870         nCurEnd = ME_StrLen(pCurItem->member.run.strText) + nMatched;
1871       }
1872
1873       while (pCurItem && ME_CharCompare(pCurItem->member.run.strText->szData[nCurEnd - nMatched - 1], text[nLen - nMatched - 1], (flags & FR_MATCHCASE)))
1874       {
1875         if ((flags & FR_WHOLEWORD) && isalnumW(wLastChar))
1876           break;
1877
1878         nMatched++;
1879         if (nMatched == nLen)
1880         {
1881           ME_DisplayItem *pPrevItem = pCurItem;
1882           int nPrevEnd = nCurEnd;
1883           WCHAR wPrevChar;
1884
1885           /* Check to see if previous character is a whitespace */
1886           if (flags & FR_WHOLEWORD)
1887           {
1888             if (nPrevEnd - nMatched == 0)
1889             {
1890               pPrevItem = ME_FindItemBack(pCurItem, diRun);
1891               if (pPrevItem)
1892                 nPrevEnd = ME_StrLen(pPrevItem->member.run.strText) + nMatched;
1893             }
1894
1895             if (pPrevItem)
1896               wPrevChar = pPrevItem->member.run.strText->szData[nPrevEnd - nMatched - 1];
1897             else
1898               wPrevChar = ' ';
1899
1900             if (isalnumW(wPrevChar))
1901               break;
1902           }
1903
1904           nStart = para->member.para.nCharOfs + pCurItem->member.run.nCharOfs + nCurEnd - nMatched;
1905           if (chrgText)
1906           {
1907             chrgText->cpMin = nStart;
1908             chrgText->cpMax = nStart + nLen;
1909           }
1910           TRACE("found at %d-%d\n", nStart, nStart + nLen);
1911           return nStart;
1912         }
1913         if (nCurEnd - nMatched == 0)
1914         {
1915           pCurItem = ME_FindItemBack(pCurItem, diRun);
1916           /* Don't care about pCurItem becoming NULL here; it's already taken
1917            * care of in the exterior loop condition */
1918           para = ME_GetParagraph(pCurItem);
1919           nCurEnd = ME_StrLen(pCurItem->member.run.strText) + nMatched;
1920         }
1921       }
1922       if (pCurItem)
1923         wLastChar = pCurItem->member.run.strText->szData[nCurEnd - nMatched - 1];
1924       else
1925         wLastChar = ' ';
1926
1927       nEnd--;
1928       if (nEnd < 0)
1929       {
1930         item = ME_FindItemBack(item, diRun);
1931         para = ME_GetParagraph(item);
1932         nEnd = ME_StrLen(item->member.run.strText);
1933       }
1934     }
1935   }
1936   TRACE("not found\n");
1937   if (chrgText)
1938     chrgText->cpMin = chrgText->cpMax = -1;
1939   return -1;
1940 }
1941
1942 static int ME_GetTextEx(ME_TextEditor *editor, GETTEXTEX *ex, LPARAM pText)
1943 {
1944     int nStart, nCount; /* in chars */
1945
1946     if (ex->flags & ~(GT_SELECTION | GT_USECRLF))
1947       FIXME("GETTEXTEX flags 0x%08x not supported\n", ex->flags & ~(GT_SELECTION | GT_USECRLF));
1948
1949     if (ex->flags & GT_SELECTION)
1950     {
1951       ME_GetSelection(editor, &nStart, &nCount);
1952       nCount -= nStart;
1953     }
1954     else
1955     {
1956       nStart = 0;
1957       nCount = 0x7fffffff;
1958     }
1959     if (ex->codepage == 1200)
1960     {
1961       nCount = min(nCount, ex->cb / sizeof(WCHAR) - 1);
1962       return ME_GetTextW(editor, (LPWSTR)pText, nStart, nCount, ex->flags & GT_USECRLF);
1963     }
1964     else
1965     {
1966       /* potentially each char may be a CR, why calculate the exact value with O(N) when
1967         we can just take a bigger buffer? :)
1968         The above assumption still holds with CR/LF counters, since CR->CRLF expansion
1969         occurs only in richedit 2.0 mode, in which line breaks have only one CR
1970        */
1971       int crlfmul = (ex->flags & GT_USECRLF) ? 2 : 1;
1972       LPWSTR buffer;
1973       DWORD buflen = ex->cb;
1974       LRESULT rc;
1975       DWORD flags = 0;
1976
1977       nCount = min(nCount, ex->cb - 1);
1978       buffer = heap_alloc((crlfmul*nCount + 1) * sizeof(WCHAR));
1979
1980       buflen = ME_GetTextW(editor, buffer, nStart, nCount, ex->flags & GT_USECRLF);
1981       rc = WideCharToMultiByte(ex->codepage, flags, buffer, buflen+1,
1982                                (LPSTR)pText, ex->cb, ex->lpDefaultChar, ex->lpUsedDefChar);
1983       if (rc) rc--; /* do not count 0 terminator */
1984
1985       heap_free(buffer);
1986       return rc;
1987     }
1988 }
1989
1990 static int ME_GetTextRange(ME_TextEditor *editor, TEXTRANGEW *rng, BOOL unicode)
1991 {
1992     if (unicode)
1993       return ME_GetTextW(editor, rng->lpstrText, rng->chrg.cpMin,
1994                          rng->chrg.cpMax-rng->chrg.cpMin, 0);
1995     else
1996     {
1997       int nLen = rng->chrg.cpMax-rng->chrg.cpMin;
1998       WCHAR *p = ALLOC_N_OBJ(WCHAR, nLen+1);
1999       int nChars = ME_GetTextW(editor, p, rng->chrg.cpMin, nLen, 0);
2000       /* FIXME this is a potential security hole (buffer overrun)
2001          if you know more about wchar->mbyte conversion please explain
2002       */
2003       WideCharToMultiByte(CP_ACP, 0, p, nChars+1, (char *)rng->lpstrText, nLen+1, NULL, NULL);
2004       FREE_OBJ(p);
2005       return nChars;
2006     }
2007 }
2008
2009 typedef struct tagME_GlobalDestStruct
2010 {
2011   HGLOBAL hData;
2012   int nLength;
2013 } ME_GlobalDestStruct;
2014
2015 static DWORD CALLBACK ME_ReadFromHGLOBALUnicode(DWORD_PTR dwCookie, LPBYTE lpBuff, LONG cb, LONG *pcb)
2016 {
2017   ME_GlobalDestStruct *pData = (ME_GlobalDestStruct *)dwCookie;
2018   int i;
2019   WORD *pSrc, *pDest;
2020
2021   cb = cb >> 1;
2022   pDest = (WORD *)lpBuff;
2023   pSrc = GlobalLock(pData->hData);
2024   for (i = 0; i<cb && pSrc[pData->nLength+i]; i++) {
2025     pDest[i] = pSrc[pData->nLength+i];
2026   }
2027   pData->nLength += i;
2028   *pcb = 2*i;
2029   GlobalUnlock(pData->hData);
2030   return 0;
2031 }
2032
2033 static DWORD CALLBACK ME_ReadFromHGLOBALRTF(DWORD_PTR dwCookie, LPBYTE lpBuff, LONG cb, LONG *pcb)
2034 {
2035   ME_GlobalDestStruct *pData = (ME_GlobalDestStruct *)dwCookie;
2036   int i;
2037   BYTE *pSrc, *pDest;
2038
2039   pDest = lpBuff;
2040   pSrc = GlobalLock(pData->hData);
2041   for (i = 0; i<cb && pSrc[pData->nLength+i]; i++) {
2042     pDest[i] = pSrc[pData->nLength+i];
2043   }
2044   pData->nLength += i;
2045   *pcb = i;
2046   GlobalUnlock(pData->hData);
2047   return 0;
2048 }
2049
2050 static BOOL ME_Paste(ME_TextEditor *editor)
2051 {
2052   DWORD dwFormat = 0;
2053   EDITSTREAM es;
2054   ME_GlobalDestStruct gds;
2055   UINT nRTFFormat = RegisterClipboardFormatA("Rich Text Format");
2056   UINT cf = 0;
2057
2058   if (IsClipboardFormatAvailable(nRTFFormat))
2059     cf = nRTFFormat, dwFormat = SF_RTF;
2060   else if (IsClipboardFormatAvailable(CF_UNICODETEXT))
2061     cf = CF_UNICODETEXT, dwFormat = SF_TEXT|SF_UNICODE;
2062   else
2063     return FALSE;
2064
2065   if (!OpenClipboard(editor->hWnd))
2066     return FALSE;
2067   gds.hData = GetClipboardData(cf);
2068   gds.nLength = 0;
2069   es.dwCookie = (DWORD_PTR)&gds;
2070   es.pfnCallback = dwFormat == SF_RTF ? ME_ReadFromHGLOBALRTF : ME_ReadFromHGLOBALUnicode;
2071   ME_StreamIn(editor, dwFormat|SFF_SELECTION, &es, FALSE);
2072
2073   CloseClipboard();
2074   return TRUE;
2075 }
2076
2077 static BOOL ME_Copy(ME_TextEditor *editor, CHARRANGE *range)
2078 {
2079   LPDATAOBJECT dataObj = NULL;
2080   HRESULT hr = S_OK;
2081
2082   if (editor->cPasswordMask)
2083     return FALSE; /* Copying or Cutting masked text isn't allowed */
2084
2085   if(editor->lpOleCallback)
2086     hr = IRichEditOleCallback_GetClipboardData(editor->lpOleCallback, range, RECO_COPY, &dataObj);
2087   if(FAILED(hr) || !dataObj)
2088     hr = ME_GetDataObject(editor, range, &dataObj);
2089   if(SUCCEEDED(hr)) {
2090     hr = OleSetClipboard(dataObj);
2091     IDataObject_Release(dataObj);
2092   }
2093   return SUCCEEDED(hr) != 0;
2094 }
2095
2096 /* helper to send a msg filter notification */
2097 static BOOL
2098 ME_FilterEvent(ME_TextEditor *editor, UINT msg, WPARAM* wParam, LPARAM* lParam)
2099 {
2100     MSGFILTER msgf;
2101
2102     msgf.nmhdr.hwndFrom = editor->hWnd;
2103     msgf.nmhdr.idFrom = GetWindowLongW(editor->hWnd, GWLP_ID);
2104     msgf.nmhdr.code = EN_MSGFILTER;
2105     msgf.msg = msg;
2106
2107     msgf.wParam = *wParam;
2108     msgf.lParam = *lParam;
2109     if (SendMessageW(GetParent(editor->hWnd), WM_NOTIFY, msgf.nmhdr.idFrom, (LPARAM)&msgf))
2110         return FALSE;
2111     *wParam = msgf.wParam;
2112     *lParam = msgf.lParam;
2113     msgf.wParam = *wParam;
2114
2115     return TRUE;
2116 }
2117
2118 static void ME_UpdateSelectionLinkAttribute(ME_TextEditor *editor)
2119 {
2120   ME_DisplayItem * startPara, * endPara;
2121   ME_DisplayItem * item;
2122   int dummy;
2123   int from, to;
2124
2125   ME_GetSelection(editor, &from, &to);
2126   if (from > to) from ^= to, to ^=from, from ^= to;
2127   startPara = NULL; endPara = NULL;
2128
2129   /* Find paragraph previous to the one that contains start cursor */
2130   item = ME_FindItemAtOffset(editor, diRun, from, &dummy);
2131   if (item) {
2132     startPara = ME_FindItemBack(item, diParagraph);
2133     item = ME_FindItemBack(startPara, diParagraph);
2134     if (item) startPara = item;
2135   }
2136
2137   /* Find paragraph that contains end cursor */
2138   item = ME_FindItemAtOffset(editor, diRun, to, &dummy);
2139   if (item) {
2140     endPara = ME_FindItemFwd(item, diParagraph);
2141   }
2142
2143   if (startPara && endPara) {
2144     ME_UpdateLinkAttribute(editor,
2145       startPara->member.para.nCharOfs,
2146       endPara->member.para.nCharOfs);
2147   } else if (startPara) {
2148     ME_UpdateLinkAttribute(editor,
2149       startPara->member.para.nCharOfs,
2150       -1);
2151   }
2152 }
2153
2154 static BOOL
2155 ME_KeyDown(ME_TextEditor *editor, WORD nKey)
2156 {
2157   BOOL ctrl_is_down = GetKeyState(VK_CONTROL) & 0x8000;
2158   BOOL shift_is_down = GetKeyState(VK_SHIFT) & 0x8000;
2159   DWORD dwStyle = GetWindowLongW(editor->hWnd, GWL_STYLE);
2160
2161   if (nKey != VK_SHIFT && nKey != VK_CONTROL && nKey != VK_MENU)
2162       editor->nSelectionType = stPosition;
2163
2164   switch (nKey)
2165   {
2166     case VK_LEFT:
2167     case VK_RIGHT:
2168     case VK_HOME:
2169     case VK_END:
2170         editor->nUDArrowX = -1;
2171         /* fall through */
2172     case VK_UP:
2173     case VK_DOWN:
2174     case VK_PRIOR:
2175     case VK_NEXT:
2176       ME_CommitUndo(editor); /* End coalesced undos for typed characters */
2177       ME_ArrowKey(editor, nKey, shift_is_down, ctrl_is_down);
2178       return TRUE;
2179     case VK_BACK:
2180     case VK_DELETE:
2181       editor->nUDArrowX = -1;
2182       /* FIXME backspace and delete aren't the same, they act different wrt paragraph style of the merged paragraph */
2183       if (dwStyle & ES_READONLY)
2184         return FALSE;
2185       if (ME_IsSelection(editor))
2186       {
2187         ME_DeleteSelection(editor);
2188         ME_CommitUndo(editor);
2189       }
2190       else if (nKey == VK_DELETE)
2191       {
2192         /* Delete stops group typing.
2193          * (See MSDN remarks on EM_STOPGROUPTYPING message) */
2194         ME_DeleteTextAtCursor(editor, 1, 1);
2195         ME_CommitUndo(editor);
2196       }
2197       else if (ME_ArrowKey(editor, VK_LEFT, FALSE, FALSE))
2198       {
2199         BOOL bDeletionSucceeded;
2200         /* Backspace can be grouped for a single undo */
2201         ME_ContinueCoalescingTransaction(editor);
2202         bDeletionSucceeded = ME_DeleteTextAtCursor(editor, 1, 1);
2203         if (!bDeletionSucceeded && !editor->bEmulateVersion10) { /* v4.1 */
2204           /* Deletion was prevented so the cursor is moved back to where it was.
2205            * (e.g. this happens when trying to delete cell boundaries)
2206            */
2207           ME_ArrowKey(editor, VK_RIGHT, FALSE, FALSE);
2208         }
2209         ME_CommitCoalescingUndo(editor);
2210       }
2211       else
2212         return TRUE;
2213       ME_MoveCursorFromTableRowStartParagraph(editor);
2214       ME_UpdateSelectionLinkAttribute(editor);
2215       ME_UpdateRepaint(editor);
2216       ME_SendRequestResize(editor, FALSE);
2217       return TRUE;
2218     case VK_RETURN:
2219       if (dwStyle & ES_MULTILINE)
2220       {
2221         ME_Cursor cursor = editor->pCursors[0];
2222         ME_DisplayItem *para = ME_GetParagraph(cursor.pRun);
2223         int from, to;
2224         const WCHAR endl = '\r';
2225         ME_Style *style;
2226
2227         if (dwStyle & ES_READONLY) {
2228           MessageBeep(MB_ICONERROR);
2229           return TRUE;
2230         }
2231
2232         ME_GetSelection(editor, &from, &to);
2233         if (editor->nTextLimit > ME_GetTextLength(editor) - (to-from))
2234         {
2235           if (!editor->bEmulateVersion10) { /* v4.1 */
2236             if (para->member.para.nFlags & MEPF_ROWEND) {
2237               /* Add a new table row after this row. */
2238               para = ME_AppendTableRow(editor, para);
2239               para = para->member.para.next_para;
2240               editor->pCursors[0].pRun = ME_FindItemFwd(para, diRun);
2241               editor->pCursors[0].nOffset = 0;
2242               editor->pCursors[1] = editor->pCursors[0];
2243               ME_CommitUndo(editor);
2244               ME_CheckTablesForCorruption(editor);
2245               ME_UpdateRepaint(editor);
2246               return TRUE;
2247             }
2248             else if (para == ME_GetParagraph(editor->pCursors[1].pRun) &&
2249                      cursor.nOffset + cursor.pRun->member.run.nCharOfs == 0 &&
2250                      para->member.para.prev_para->member.para.nFlags & MEPF_ROWSTART &&
2251                      !para->member.para.prev_para->member.para.nCharOfs)
2252             {
2253               /* Insert a newline before the table. */
2254               para = para->member.para.prev_para;
2255               para->member.para.nFlags &= ~MEPF_ROWSTART;
2256               editor->pCursors[0].pRun = ME_FindItemFwd(para, diRun);
2257               editor->pCursors[1] = editor->pCursors[0];
2258               ME_InsertTextFromCursor(editor, 0, &endl, 1,
2259                                       editor->pCursors[0].pRun->member.run.style);
2260               para = editor->pBuffer->pFirst->member.para.next_para;
2261               ME_SetDefaultParaFormat(para->member.para.pFmt);
2262               para->member.para.nFlags = MEPF_REWRAP;
2263               editor->pCursors[0].pRun = ME_FindItemFwd(para, diRun);
2264               editor->pCursors[1] = editor->pCursors[0];
2265               para->member.para.next_para->member.para.nFlags |= MEPF_ROWSTART;
2266               ME_CommitCoalescingUndo(editor);
2267               ME_CheckTablesForCorruption(editor);
2268               ME_UpdateRepaint(editor);
2269               return TRUE;
2270             }
2271           } else { /* v1.0 - 3.0 */
2272             ME_DisplayItem *para = ME_GetParagraph(cursor.pRun);
2273             if (ME_IsInTable(para))
2274             {
2275               if (cursor.pRun->member.run.nFlags & MERF_ENDPARA)
2276               {
2277                 if (from == to) {
2278                   ME_ContinueCoalescingTransaction(editor);
2279                   para = ME_AppendTableRow(editor, para);
2280                   editor->pCursors[0].pRun = ME_FindItemFwd(para, diRun);
2281                   editor->pCursors[0].nOffset = 0;
2282                   editor->pCursors[1] = editor->pCursors[0];
2283                   ME_CommitCoalescingUndo(editor);
2284                   ME_UpdateRepaint(editor);
2285                   return TRUE;
2286                 }
2287               } else {
2288                 ME_ContinueCoalescingTransaction(editor);
2289                 if (cursor.pRun->member.run.nCharOfs + cursor.nOffset == 0 &&
2290                     !ME_IsInTable(para->member.para.prev_para))
2291                 {
2292                   /* Insert newline before table */
2293                   cursor.pRun = ME_FindItemBack(para, diRun);
2294                   if (cursor.pRun)
2295                     editor->pCursors[0].pRun = cursor.pRun;
2296                   editor->pCursors[0].nOffset = 0;
2297                   editor->pCursors[1] = editor->pCursors[0];
2298                   ME_InsertTextFromCursor(editor, 0, &endl, 1,
2299                                           editor->pCursors[0].pRun->member.run.style);
2300                 } else {
2301                   editor->pCursors[1] = editor->pCursors[0];
2302                   para = ME_AppendTableRow(editor, para);
2303                   editor->pCursors[0].pRun = ME_FindItemFwd(para, diRun);
2304                   editor->pCursors[0].nOffset = 0;
2305                   editor->pCursors[1] = editor->pCursors[0];
2306                 }
2307                 ME_CommitCoalescingUndo(editor);
2308                 ME_UpdateRepaint(editor);
2309                 return TRUE;
2310               }
2311             }
2312           }
2313
2314           style = ME_GetInsertStyle(editor, 0);
2315           ME_SaveTempStyle(editor);
2316           ME_ContinueCoalescingTransaction(editor);
2317           if (shift_is_down)
2318             ME_InsertEndRowFromCursor(editor, 0);
2319           else
2320             ME_InsertTextFromCursor(editor, 0, &endl, 1, style);
2321           ME_ReleaseStyle(style);
2322           ME_CommitCoalescingUndo(editor);
2323           SetCursor(NULL);
2324
2325           if (editor->AutoURLDetect_bEnable)
2326             ME_UpdateSelectionLinkAttribute(editor);
2327
2328           ME_UpdateRepaint(editor);
2329         }
2330         return TRUE;
2331       }
2332       break;
2333     case 'A':
2334       if (ctrl_is_down)
2335       {
2336         ME_SetSelection(editor, 0, -1);
2337         return TRUE;
2338       }
2339       break;
2340     case 'V':
2341       if (ctrl_is_down)
2342         return ME_Paste(editor);
2343       break;
2344     case 'C':
2345     case 'X':
2346       if (ctrl_is_down)
2347       {
2348         CHARRANGE range;
2349         BOOL result;
2350
2351         ME_GetSelection(editor, &range.cpMin, &range.cpMax);
2352         result = ME_Copy(editor, &range);
2353         if (result && nKey == 'X')
2354         {
2355           ME_InternalDeleteText(editor, range.cpMin, range.cpMax-range.cpMin, FALSE);
2356           ME_CommitUndo(editor);
2357           ME_UpdateRepaint(editor);
2358         }
2359         return result;
2360       }
2361       break;
2362     case 'Z':
2363       if (ctrl_is_down)
2364       {
2365         ME_Undo(editor);
2366         return TRUE;
2367       }
2368       break;
2369     case 'Y':
2370       if (ctrl_is_down)
2371       {
2372         ME_Redo(editor);
2373         return TRUE;
2374       }
2375       break;
2376
2377     default:
2378       if (nKey != VK_SHIFT && nKey != VK_CONTROL && nKey && nKey != VK_MENU)
2379           editor->nUDArrowX = -1;
2380       if (ctrl_is_down)
2381       {
2382         if (nKey == 'W')
2383         {
2384           CHARFORMAT2W chf;
2385           char buf[2048];
2386           chf.cbSize = sizeof(chf);
2387
2388           ME_GetSelectionCharFormat(editor, &chf);
2389           ME_DumpStyleToBuf(&chf, buf);
2390           MessageBoxA(NULL, buf, "Style dump", MB_OK);
2391         }
2392         if (nKey == 'Q')
2393         {
2394           ME_CheckCharOffsets(editor);
2395         }
2396       }
2397   }
2398   return FALSE;
2399 }
2400
2401 static LRESULT ME_Char(ME_TextEditor *editor, WPARAM charCode,
2402                        LPARAM flags, BOOL unicode)
2403 {
2404   WCHAR wstr;
2405
2406   if (unicode)
2407       wstr = (WCHAR)charCode;
2408   else
2409   {
2410       CHAR charA = charCode;
2411       MultiByteToWideChar(CP_ACP, 0, &charA, 1, &wstr, 1);
2412   }
2413
2414   if (GetWindowLongW(editor->hWnd, GWL_STYLE) & ES_READONLY) {
2415     MessageBeep(MB_ICONERROR);
2416     return 0; /* FIXME really 0 ? */
2417   }
2418
2419   if ((unsigned)wstr >= ' ' || wstr == '\t')
2420   {
2421     ME_Cursor cursor = editor->pCursors[0];
2422     ME_DisplayItem *para = ME_GetParagraph(cursor.pRun);
2423     int from, to;
2424     BOOL ctrl_is_down = GetKeyState(VK_CONTROL) & 0x8000;
2425     ME_GetSelection(editor, &from, &to);
2426     if (wstr == '\t' &&
2427         /* v4.1 allows tabs to be inserted with ctrl key down */
2428         !(ctrl_is_down && !editor->bEmulateVersion10))
2429     {
2430       ME_DisplayItem *para;
2431       BOOL bSelectedRow = FALSE;
2432
2433       para = ME_GetParagraph(cursor.pRun);
2434       if (ME_IsSelection(editor) &&
2435           cursor.pRun->member.run.nCharOfs + cursor.nOffset == 0 &&
2436           to == ME_GetCursorOfs(editor, 0) &&
2437           para->member.para.prev_para->type == diParagraph)
2438       {
2439         para = para->member.para.prev_para;
2440         bSelectedRow = TRUE;
2441       }
2442       if (ME_IsInTable(para))
2443       {
2444         ME_TabPressedInTable(editor, bSelectedRow);
2445         ME_CommitUndo(editor);
2446         return 0;
2447       }
2448     } else if (!editor->bEmulateVersion10) { /* v4.1 */
2449       if (para->member.para.nFlags & MEPF_ROWEND) {
2450         if (from == to) {
2451           para = para->member.para.next_para;
2452           if (para->member.para.nFlags & MEPF_ROWSTART)
2453             para = para->member.para.next_para;
2454           editor->pCursors[0].pRun = ME_FindItemFwd(para, diRun);
2455           editor->pCursors[0].nOffset = 0;
2456           editor->pCursors[1] = editor->pCursors[0];
2457         }
2458       }
2459     } else { /* v1.0 - 3.0 */
2460       if (ME_IsInTable(cursor.pRun) &&
2461           cursor.pRun->member.run.nFlags & MERF_ENDPARA &&
2462           from == to)
2463       {
2464         /* Text should not be inserted at the end of the table. */
2465         MessageBeep(-1);
2466         return 0;
2467       }
2468     }
2469     /* FIXME maybe it would make sense to call EM_REPLACESEL instead ? */
2470     /* WM_CHAR is restricted to nTextLimit */
2471     if(editor->nTextLimit > ME_GetTextLength(editor) - (to-from))
2472     {
2473       ME_Style *style = ME_GetInsertStyle(editor, 0);
2474       ME_SaveTempStyle(editor);
2475       ME_ContinueCoalescingTransaction(editor);
2476       ME_InsertTextFromCursor(editor, 0, &wstr, 1, style);
2477       ME_ReleaseStyle(style);
2478       ME_CommitCoalescingUndo(editor);
2479       SetCursor(NULL);
2480     }
2481
2482     if (editor->AutoURLDetect_bEnable) ME_UpdateSelectionLinkAttribute(editor);
2483
2484     ME_UpdateRepaint(editor);
2485   }
2486   return 0;
2487 }
2488
2489 /* Process the message and calculate the new click count.
2490  *
2491  * returns: The click count if it is mouse down event, else returns 0. */
2492 static int ME_CalculateClickCount(ME_TextEditor *editor, UINT msg, WPARAM wParam,
2493                                   LPARAM lParam)
2494 {
2495     static int clickNum = 0;
2496     if (msg < WM_MOUSEFIRST || msg > WM_MOUSELAST)
2497         return 0;
2498
2499     if ((msg == WM_LBUTTONDBLCLK) ||
2500         (msg == WM_RBUTTONDBLCLK) ||
2501         (msg == WM_MBUTTONDBLCLK) ||
2502         (msg == WM_XBUTTONDBLCLK))
2503     {
2504         msg -= (WM_LBUTTONDBLCLK - WM_LBUTTONDOWN);
2505     }
2506
2507     if ((msg == WM_LBUTTONDOWN) ||
2508         (msg == WM_RBUTTONDOWN) ||
2509         (msg == WM_MBUTTONDOWN) ||
2510         (msg == WM_XBUTTONDOWN))
2511     {
2512         static MSG prevClickMsg;
2513         MSG clickMsg;
2514         /* Compare the editor instead of the hwnd so that the this
2515          * can still be done for windowless richedit controls. */
2516         clickMsg.hwnd = (HWND)editor;
2517         clickMsg.message = msg;
2518         clickMsg.wParam = wParam;
2519         clickMsg.lParam = lParam;
2520         clickMsg.time = GetMessageTime();
2521         clickMsg.pt.x = (short)LOWORD(lParam);
2522         clickMsg.pt.y = (short)HIWORD(lParam);
2523         if ((clickNum != 0) &&
2524             (clickMsg.message == prevClickMsg.message) &&
2525             (clickMsg.hwnd == prevClickMsg.hwnd) &&
2526             (clickMsg.wParam == prevClickMsg.wParam) &&
2527             (clickMsg.time - prevClickMsg.time < GetDoubleClickTime()) &&
2528             (abs(clickMsg.pt.x - prevClickMsg.pt.x) < GetSystemMetrics(SM_CXDOUBLECLK)/2) &&
2529             (abs(clickMsg.pt.y - prevClickMsg.pt.y) < GetSystemMetrics(SM_CYDOUBLECLK)/2))
2530         {
2531             clickNum++;
2532         } else {
2533             clickNum = 1;
2534         }
2535         prevClickMsg = clickMsg;
2536     } else {
2537         return 0;
2538     }
2539     return clickNum;
2540 }
2541
2542 static BOOL ME_SetCursor(ME_TextEditor *editor)
2543 {
2544   POINT pt;
2545   BOOL isExact;
2546   int offset;
2547   SCROLLBARINFO sbi;
2548   DWORD messagePos = GetMessagePos();
2549   pt.x = (short)LOWORD(messagePos);
2550   pt.y = (short)HIWORD(messagePos);
2551
2552   sbi.cbSize = sizeof(sbi);
2553   GetScrollBarInfo(editor->hWnd, OBJID_HSCROLL, &sbi);
2554   if (!(sbi.rgstate[0] & (STATE_SYSTEM_INVISIBLE|STATE_SYSTEM_OFFSCREEN)) &&
2555       PtInRect(&sbi.rcScrollBar, pt))
2556   {
2557       SetCursor(LoadCursorW(NULL, (WCHAR*)IDC_ARROW));
2558       return TRUE;
2559   }
2560   sbi.cbSize = sizeof(sbi);
2561   GetScrollBarInfo(editor->hWnd, OBJID_VSCROLL, &sbi);
2562   if (!(sbi.rgstate[0] & (STATE_SYSTEM_INVISIBLE|STATE_SYSTEM_OFFSCREEN)) &&
2563       PtInRect(&sbi.rcScrollBar, pt))
2564   {
2565       SetCursor(LoadCursorW(NULL, (WCHAR*)IDC_ARROW));
2566       return TRUE;
2567   }
2568   ScreenToClient(editor->hWnd, &pt);
2569
2570   if (editor->nSelectionType == stLine && editor->bMouseCaptured) {
2571       SetCursor(hLeft);
2572       return TRUE;
2573   }
2574   if (!editor->bEmulateVersion10 /* v4.1 */ &&
2575       pt.y < editor->rcFormat.top &&
2576       pt.x < editor->rcFormat.left)
2577   {
2578       SetCursor(hLeft);
2579       return TRUE;
2580   }
2581   if (pt.y < editor->rcFormat.top || pt.y > editor->rcFormat.bottom)
2582   {
2583       if (editor->bEmulateVersion10) /* v1.0 - 3.0 */
2584           SetCursor(LoadCursorW(NULL, (WCHAR*)IDC_ARROW));
2585       else /* v4.1 */
2586           SetCursor(LoadCursorW(NULL, (WCHAR*)IDC_IBEAM));
2587       return TRUE;
2588   }
2589   if (pt.x < editor->rcFormat.left)
2590   {
2591       SetCursor(hLeft);
2592       return TRUE;
2593   }
2594   offset = ME_CharFromPos(editor, pt.x, pt.y, &isExact);
2595   if (isExact)
2596   {
2597       if (editor->AutoURLDetect_bEnable)
2598       {
2599           ME_Cursor cursor;
2600           ME_Run *run;
2601           ME_CursorFromCharOfs(editor, offset, &cursor);
2602           run = &cursor.pRun->member.run;
2603           if (editor->AutoURLDetect_bEnable &&
2604               run->style->fmt.dwMask & CFM_LINK &&
2605               run->style->fmt.dwEffects & CFE_LINK)
2606           {
2607               SetCursor(LoadCursorW(NULL, (WCHAR*)IDC_HAND));
2608               return TRUE;
2609           }
2610       }
2611       if (ME_IsSelection(editor))
2612       {
2613           int selStart, selEnd;
2614           ME_GetSelection(editor, &selStart, &selEnd);
2615           if (selStart <= offset && selEnd >= offset) {
2616               SetCursor(LoadCursorW(NULL, (WCHAR*)IDC_ARROW));
2617               return TRUE;
2618           }
2619       }
2620   }
2621   SetCursor(LoadCursorW(NULL, (WCHAR*)IDC_IBEAM));
2622   return TRUE;
2623 }
2624
2625 static void ME_SetDefaultFormatRect(ME_TextEditor *editor)
2626 {
2627   DWORD exstyle = GetWindowLongW(editor->hWnd, GWL_EXSTYLE);
2628
2629   GetClientRect(editor->hWnd, &editor->rcFormat);
2630   editor->rcFormat.top += (exstyle & WS_EX_CLIENTEDGE ? 1 : 0);
2631   editor->rcFormat.left += 1 + editor->selofs;
2632   editor->rcFormat.right -= 1;
2633 }
2634
2635 static BOOL ME_ShowContextMenu(ME_TextEditor *editor, int x, int y)
2636 {
2637   CHARRANGE selrange;
2638   HMENU menu;
2639   int seltype = 0;
2640   if(!editor->lpOleCallback)
2641     return FALSE;
2642   ME_GetSelection(editor, &selrange.cpMin, &selrange.cpMax);
2643   if(selrange.cpMin == selrange.cpMax)
2644     seltype |= SEL_EMPTY;
2645   else
2646   {
2647     /* FIXME: Handle objects */
2648     seltype |= SEL_TEXT;
2649     if(selrange.cpMax-selrange.cpMin > 1)
2650       seltype |= SEL_MULTICHAR;
2651   }
2652   if(SUCCEEDED(IRichEditOleCallback_GetContextMenu(editor->lpOleCallback, seltype, NULL, &selrange, &menu)))
2653   {
2654     TrackPopupMenu(menu, TPM_LEFTALIGN | TPM_RIGHTBUTTON, x, y, 0, GetParent(editor->hWnd), NULL);
2655     DestroyMenu(menu);
2656   }
2657   return TRUE;
2658 }
2659
2660 static ME_TextEditor *ME_MakeEditor(HWND hWnd, BOOL bEmulateVersion10)
2661 {
2662   ME_TextEditor *ed = ALLOC_OBJ(ME_TextEditor);
2663   int i;
2664   ed->hWnd = hWnd;
2665   ed->bEmulateVersion10 = bEmulateVersion10;
2666   ed->pBuffer = ME_MakeText();
2667   ed->nZoomNumerator = ed->nZoomDenominator = 0;
2668   ME_MakeFirstParagraph(ed);
2669   /* The four cursors are for:
2670    * 0 - The position where the caret is shown
2671    * 1 - The anchored end of the selection (for normal selection)
2672    * 2 & 3 - The anchored start and end respectively for word, line,
2673    * or paragraph selection.
2674    */
2675   ed->nCursors = 4;
2676   ed->pCursors = ALLOC_N_OBJ(ME_Cursor, ed->nCursors);
2677   ed->pCursors[0].pRun = ME_FindItemFwd(ed->pBuffer->pFirst, diRun);
2678   ed->pCursors[0].nOffset = 0;
2679   ed->pCursors[1].pRun = ME_FindItemFwd(ed->pBuffer->pFirst, diRun);
2680   ed->pCursors[1].nOffset = 0;
2681   ed->pCursors[2] = ed->pCursors[0];
2682   ed->pCursors[3] = ed->pCursors[1];
2683   ed->nLastTotalLength = ed->nTotalLength = 0;
2684   ed->nUDArrowX = -1;
2685   ed->nSequence = 0;
2686   ed->rgbBackColor = -1;
2687   ed->hbrBackground = GetSysColorBrush(COLOR_WINDOW);
2688   ed->bCaretAtEnd = FALSE;
2689   ed->nEventMask = 0;
2690   ed->nModifyStep = 0;
2691   ed->nTextLimit = TEXT_LIMIT_DEFAULT;
2692   ed->pUndoStack = ed->pRedoStack = ed->pUndoStackBottom = NULL;
2693   ed->nUndoStackSize = 0;
2694   ed->nUndoLimit = STACK_SIZE_DEFAULT;
2695   ed->nUndoMode = umAddToUndo;
2696   ed->nParagraphs = 1;
2697   ed->nLastSelStart = ed->nLastSelEnd = 0;
2698   ed->pLastSelStartPara = ed->pLastSelEndPara = ME_FindItemFwd(ed->pBuffer->pFirst, diParagraph);
2699   if (ed->bEmulateVersion10)
2700     ed->bWordWrap = (GetWindowLongW(hWnd, GWL_STYLE) & ES_AUTOHSCROLL) ? FALSE : TRUE;
2701   else
2702     ed->bWordWrap = (GetWindowLongW(hWnd, GWL_STYLE) & (WS_HSCROLL|ES_AUTOHSCROLL)) ? FALSE : TRUE;
2703   ed->bHideSelection = FALSE;
2704   ed->nInvalidOfs = -1;
2705   ed->pfnWordBreak = NULL;
2706   ed->lpOleCallback = NULL;
2707   ed->mode = TM_RICHTEXT | TM_MULTILEVELUNDO | TM_MULTICODEPAGE;
2708   ed->AutoURLDetect_bEnable = FALSE;
2709   ed->bHaveFocus = FALSE;
2710   ed->bMouseCaptured = FALSE;
2711   for (i=0; i<HFONT_CACHE_SIZE; i++)
2712   {
2713     ed->pFontCache[i].nRefs = 0;
2714     ed->pFontCache[i].nAge = 0;
2715     ed->pFontCache[i].hFont = NULL;
2716   }
2717
2718   ME_CheckCharOffsets(ed);
2719   if (GetWindowLongW(hWnd, GWL_STYLE) & ES_SELECTIONBAR)
2720     ed->selofs = SELECTIONBAR_WIDTH;
2721   else
2722     ed->selofs = 0;
2723   ed->bDefaultFormatRect = TRUE;
2724   ed->nSelectionType = stPosition;
2725
2726   if (GetWindowLongW(hWnd, GWL_STYLE) & ES_PASSWORD)
2727     ed->cPasswordMask = '*';
2728   else
2729     ed->cPasswordMask = 0;
2730
2731   ed->notified_cr.cpMin = ed->notified_cr.cpMax = 0;
2732
2733   /* Default vertical scrollbar information */
2734   ed->vert_si.cbSize = sizeof(SCROLLINFO);
2735   ed->vert_si.nMin = 0;
2736   ed->vert_si.nMax = 0;
2737   ed->vert_si.nPage = 0;
2738   ed->vert_si.nPos = 0;
2739
2740   OleInitialize(NULL);
2741
2742   return ed;
2743 }
2744
2745 static void ME_DestroyEditor(ME_TextEditor *editor)
2746 {
2747   ME_DisplayItem *pFirst = editor->pBuffer->pFirst;
2748   ME_DisplayItem *p = pFirst, *pNext = NULL;
2749   int i;
2750
2751   ME_ClearTempStyle(editor);
2752   ME_EmptyUndoStack(editor);
2753   while(p) {
2754     pNext = p->next;
2755     ME_DestroyDisplayItem(p);
2756     p = pNext;
2757   }
2758   ME_ReleaseStyle(editor->pBuffer->pDefaultStyle);
2759   for (i=0; i<HFONT_CACHE_SIZE; i++)
2760   {
2761     if (editor->pFontCache[i].hFont)
2762       DeleteObject(editor->pFontCache[i].hFont);
2763   }
2764   if (editor->rgbBackColor != -1)
2765     DeleteObject(editor->hbrBackground);
2766   if(editor->lpOleCallback)
2767     IUnknown_Release(editor->lpOleCallback);
2768   SetWindowLongPtrW(editor->hWnd, 0, 0);
2769   OleUninitialize();
2770
2771   FREE_OBJ(editor->pBuffer);
2772   FREE_OBJ(editor->pCursors);
2773
2774   FREE_OBJ(editor);
2775 }
2776
2777 BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
2778 {
2779     TRACE("\n");
2780     switch (fdwReason)
2781     {
2782     case DLL_PROCESS_ATTACH:
2783       DisableThreadLibraryCalls(hinstDLL);
2784       me_heap = HeapCreate (0, 0x10000, 0);
2785       if (!ME_RegisterEditorClass(hinstDLL)) return FALSE;
2786       hLeft = LoadCursorW(hinstDLL, MAKEINTRESOURCEW(OCR_REVERSE));
2787       LookupInit();
2788       break;
2789
2790     case DLL_PROCESS_DETACH:
2791       UnregisterClassW(RichEdit20W, 0);
2792       UnregisterClassW(RichEdit50W, 0);
2793       UnregisterClassA("RichEdit20A", 0);
2794       UnregisterClassA("RichEdit50A", 0);
2795       if (ME_ListBoxRegistered)
2796           UnregisterClassW(REListBox20W, 0);
2797       if (ME_ComboBoxRegistered)
2798           UnregisterClassW(REComboBox20W, 0);
2799       LookupCleanup();
2800       HeapDestroy (me_heap);
2801       me_heap = NULL;
2802       break;
2803     }
2804     return TRUE;
2805 }
2806
2807
2808 static const char * const edit_messages[] = {
2809   "EM_GETSEL",
2810   "EM_SETSEL",
2811   "EM_GETRECT",
2812   "EM_SETRECT",
2813   "EM_SETRECTNP",
2814   "EM_SCROLL",
2815   "EM_LINESCROLL",
2816   "EM_SCROLLCARET",
2817   "EM_GETMODIFY",
2818   "EM_SETMODIFY",
2819   "EM_GETLINECOUNT",
2820   "EM_LINEINDEX",
2821   "EM_SETHANDLE",
2822   "EM_GETHANDLE",
2823   "EM_GETTHUMB",
2824   "EM_UNKNOWN_BF",
2825   "EM_UNKNOWN_C0",
2826   "EM_LINELENGTH",
2827   "EM_REPLACESEL",
2828   "EM_UNKNOWN_C3",
2829   "EM_GETLINE",
2830   "EM_LIMITTEXT",
2831   "EM_CANUNDO",
2832   "EM_UNDO",
2833   "EM_FMTLINES",
2834   "EM_LINEFROMCHAR",
2835   "EM_UNKNOWN_CA",
2836   "EM_SETTABSTOPS",
2837   "EM_SETPASSWORDCHAR",
2838   "EM_EMPTYUNDOBUFFER",
2839   "EM_GETFIRSTVISIBLELINE",
2840   "EM_SETREADONLY",
2841   "EM_SETWORDBREAKPROC",
2842   "EM_GETWORDBREAKPROC",
2843   "EM_GETPASSWORDCHAR",
2844   "EM_SETMARGINS",
2845   "EM_GETMARGINS",
2846   "EM_GETLIMITTEXT",
2847   "EM_POSFROMCHAR",
2848   "EM_CHARFROMPOS",
2849   "EM_SETIMESTATUS",
2850   "EM_GETIMESTATUS"
2851 };
2852
2853 static const char * const richedit_messages[] = {
2854   "EM_CANPASTE",
2855   "EM_DISPLAYBAND",
2856   "EM_EXGETSEL",
2857   "EM_EXLIMITTEXT",
2858   "EM_EXLINEFROMCHAR",
2859   "EM_EXSETSEL",
2860   "EM_FINDTEXT",
2861   "EM_FORMATRANGE",
2862   "EM_GETCHARFORMAT",
2863   "EM_GETEVENTMASK",
2864   "EM_GETOLEINTERFACE",
2865   "EM_GETPARAFORMAT",
2866   "EM_GETSELTEXT",
2867   "EM_HIDESELECTION",
2868   "EM_PASTESPECIAL",
2869   "EM_REQUESTRESIZE",
2870   "EM_SELECTIONTYPE",
2871   "EM_SETBKGNDCOLOR",
2872   "EM_SETCHARFORMAT",
2873   "EM_SETEVENTMASK",
2874   "EM_SETOLECALLBACK",
2875   "EM_SETPARAFORMAT",
2876   "EM_SETTARGETDEVICE",
2877   "EM_STREAMIN",
2878   "EM_STREAMOUT",
2879   "EM_GETTEXTRANGE",
2880   "EM_FINDWORDBREAK",
2881   "EM_SETOPTIONS",
2882   "EM_GETOPTIONS",
2883   "EM_FINDTEXTEX",
2884   "EM_GETWORDBREAKPROCEX",
2885   "EM_SETWORDBREAKPROCEX",
2886   "EM_SETUNDOLIMIT",
2887   "EM_UNKNOWN_USER_83",
2888   "EM_REDO",
2889   "EM_CANREDO",
2890   "EM_GETUNDONAME",
2891   "EM_GETREDONAME",
2892   "EM_STOPGROUPTYPING",
2893   "EM_SETTEXTMODE",
2894   "EM_GETTEXTMODE",
2895   "EM_AUTOURLDETECT",
2896   "EM_GETAUTOURLDETECT",
2897   "EM_SETPALETTE",
2898   "EM_GETTEXTEX",
2899   "EM_GETTEXTLENGTHEX",
2900   "EM_SHOWSCROLLBAR",
2901   "EM_SETTEXTEX",
2902   "EM_UNKNOWN_USER_98",
2903   "EM_UNKNOWN_USER_99",
2904   "EM_SETPUNCTUATION",
2905   "EM_GETPUNCTUATION",
2906   "EM_SETWORDWRAPMODE",
2907   "EM_GETWORDWRAPMODE",
2908   "EM_SETIMECOLOR",
2909   "EM_GETIMECOLOR",
2910   "EM_SETIMEOPTIONS",
2911   "EM_GETIMEOPTIONS",
2912   "EM_CONVPOSITION",
2913   "EM_UNKNOWN_USER_109",
2914   "EM_UNKNOWN_USER_110",
2915   "EM_UNKNOWN_USER_111",
2916   "EM_UNKNOWN_USER_112",
2917   "EM_UNKNOWN_USER_113",
2918   "EM_UNKNOWN_USER_114",
2919   "EM_UNKNOWN_USER_115",
2920   "EM_UNKNOWN_USER_116",
2921   "EM_UNKNOWN_USER_117",
2922   "EM_UNKNOWN_USER_118",
2923   "EM_UNKNOWN_USER_119",
2924   "EM_SETLANGOPTIONS",
2925   "EM_GETLANGOPTIONS",
2926   "EM_GETIMECOMPMODE",
2927   "EM_FINDTEXTW",
2928   "EM_FINDTEXTEXW",
2929   "EM_RECONVERSION",
2930   "EM_SETIMEMODEBIAS",
2931   "EM_GETIMEMODEBIAS"
2932 };
2933
2934 static const char *
2935 get_msg_name(UINT msg)
2936 {
2937   if (msg >= EM_GETSEL && msg <= EM_CHARFROMPOS)
2938     return edit_messages[msg - EM_GETSEL];
2939   if (msg >= EM_CANPASTE && msg <= EM_GETIMEMODEBIAS)
2940     return richedit_messages[msg - EM_CANPASTE];
2941   return "";
2942 }
2943
2944 void ME_LinkNotify(ME_TextEditor *editor, UINT msg, WPARAM wParam, LPARAM lParam)
2945 {
2946   int x,y;
2947   ME_Cursor tmpCursor;
2948   BOOL isExact;
2949   int nCharOfs; /* The start of the clicked text. Absolute character offset */
2950
2951   ME_Run *tmpRun;
2952
2953   ENLINK info;
2954   x = (short)LOWORD(lParam);
2955   y = (short)HIWORD(lParam);
2956   nCharOfs = ME_CharFromPos(editor, x, y, &isExact);
2957   if (!isExact) return;
2958
2959   ME_CursorFromCharOfs(editor, nCharOfs, &tmpCursor);
2960   tmpRun = &tmpCursor.pRun->member.run;
2961
2962   if ((tmpRun->style->fmt.dwMask & CFM_LINK)
2963     && (tmpRun->style->fmt.dwEffects & CFE_LINK))
2964   { /* The clicked run has CFE_LINK set */
2965     info.nmhdr.hwndFrom = editor->hWnd;
2966     info.nmhdr.idFrom = GetWindowLongW(editor->hWnd, GWLP_ID);
2967     info.nmhdr.code = EN_LINK;
2968     info.msg = msg;
2969     info.wParam = wParam;
2970     info.lParam = lParam;
2971     info.chrg.cpMin = ME_CharOfsFromRunOfs(editor,tmpCursor.pRun,0);
2972     info.chrg.cpMax = info.chrg.cpMin + ME_StrVLen(tmpRun->strText);
2973     SendMessageW(GetParent(editor->hWnd), WM_NOTIFY,info.nmhdr.idFrom, (LPARAM)&info);
2974   }
2975 }
2976
2977 #define UNSUPPORTED_MSG(e) \
2978   case e:                  \
2979     FIXME(#e ": stub\n");  \
2980     *phresult = S_FALSE;   \
2981     return 0;
2982
2983 /* Handle messages for windowless and windoweded richedit controls.
2984  *
2985  * The LRESULT that is returned is a return value for window procs,
2986  * and the phresult parameter is the COM return code needed by the
2987  * text services interface. */
2988 static LRESULT ME_HandleMessage(ME_TextEditor *editor, UINT msg, WPARAM wParam,
2989                          LPARAM lParam, BOOL unicode, HRESULT* phresult)
2990 {
2991   *phresult = S_OK;
2992
2993   switch(msg) {
2994
2995   UNSUPPORTED_MSG(EM_DISPLAYBAND)
2996   UNSUPPORTED_MSG(EM_FINDWORDBREAK)
2997   UNSUPPORTED_MSG(EM_FMTLINES)
2998   UNSUPPORTED_MSG(EM_FORMATRANGE)
2999   UNSUPPORTED_MSG(EM_GETBIDIOPTIONS)
3000   UNSUPPORTED_MSG(EM_GETEDITSTYLE)
3001   UNSUPPORTED_MSG(EM_GETIMECOMPMODE)
3002   UNSUPPORTED_MSG(EM_GETIMESTATUS)
3003   UNSUPPORTED_MSG(EM_SETIMESTATUS)
3004   UNSUPPORTED_MSG(EM_GETLANGOPTIONS)
3005   /* UNSUPPORTED_MSG(EM_GETOLEINTERFACE) separate stub */
3006   UNSUPPORTED_MSG(EM_GETREDONAME)
3007   UNSUPPORTED_MSG(EM_GETTEXTMODE)
3008   UNSUPPORTED_MSG(EM_GETTYPOGRAPHYOPTIONS)
3009   UNSUPPORTED_MSG(EM_GETUNDONAME)
3010   UNSUPPORTED_MSG(EM_GETWORDBREAKPROCEX)
3011   UNSUPPORTED_MSG(EM_PASTESPECIAL)
3012   UNSUPPORTED_MSG(EM_SELECTIONTYPE)
3013   UNSUPPORTED_MSG(EM_SETBIDIOPTIONS)
3014   UNSUPPORTED_MSG(EM_SETEDITSTYLE)
3015   UNSUPPORTED_MSG(EM_SETFONTSIZE)
3016   UNSUPPORTED_MSG(EM_SETLANGOPTIONS)
3017   UNSUPPORTED_MSG(EM_SETMARGINS)
3018   UNSUPPORTED_MSG(EM_SETPALETTE)
3019   UNSUPPORTED_MSG(EM_SETTABSTOPS)
3020   UNSUPPORTED_MSG(EM_SETTYPOGRAPHYOPTIONS)
3021   UNSUPPORTED_MSG(EM_SETWORDBREAKPROCEX)
3022   UNSUPPORTED_MSG(WM_STYLECHANGING)
3023   UNSUPPORTED_MSG(WM_STYLECHANGED)
3024
3025 /* Messages specific to Richedit controls */
3026
3027   case EM_STREAMIN:
3028    return ME_StreamIn(editor, wParam, (EDITSTREAM*)lParam, TRUE);
3029   case EM_STREAMOUT:
3030    return ME_StreamOut(editor, wParam, (EDITSTREAM *)lParam);
3031   case WM_GETDLGCODE:
3032   {
3033     UINT code = DLGC_WANTCHARS|DLGC_WANTTAB|DLGC_WANTARROWS|DLGC_HASSETSEL;
3034     if (GetWindowLongW(editor->hWnd, GWL_STYLE) & ES_MULTILINE)
3035       code |= DLGC_WANTMESSAGE;
3036     return code;
3037   }
3038   case EM_EMPTYUNDOBUFFER:
3039     ME_EmptyUndoStack(editor);
3040     return 0;
3041   case EM_GETSEL:
3042   {
3043     /* Note: wParam/lParam can be NULL */
3044     UINT from, to;
3045     PUINT pfrom = wParam ? (PUINT)wParam : &from;
3046     PUINT pto = lParam ? (PUINT)lParam : &to;
3047     ME_GetSelection(editor, (int *)pfrom, (int *)pto);
3048     if ((*pfrom|*pto) & 0xFFFF0000)
3049       return -1;
3050     return MAKELONG(*pfrom,*pto);
3051   }
3052   case EM_EXGETSEL:
3053   {
3054     CHARRANGE *pRange = (CHARRANGE *)lParam;
3055     ME_GetSelection(editor, &pRange->cpMin, &pRange->cpMax);
3056     TRACE("EM_EXGETSEL = (%d,%d)\n", pRange->cpMin, pRange->cpMax);
3057     return 0;
3058   }
3059   case EM_SETUNDOLIMIT:
3060   {
3061     if ((int)wParam < 0)
3062       editor->nUndoLimit = STACK_SIZE_DEFAULT;
3063     else
3064       editor->nUndoLimit = min(wParam, STACK_SIZE_MAX);
3065     /* Setting a max stack size keeps wine from getting killed
3066       for hogging memory. Windows allocates all this memory at once, so
3067       no program would realistically set a value above our maximum. */
3068     return editor->nUndoLimit;
3069   }
3070   case EM_CANUNDO:
3071     return editor->pUndoStack != NULL;
3072   case EM_CANREDO:
3073     return editor->pRedoStack != NULL;
3074   case WM_UNDO: /* FIXME: actually not the same */
3075   case EM_UNDO:
3076     return ME_Undo(editor);
3077   case EM_REDO:
3078     return ME_Redo(editor);
3079   case EM_GETOPTIONS:
3080   {
3081     /* these flags are equivalent to the ES_* counterparts */
3082     DWORD mask = ECO_VERTICAL | ECO_AUTOHSCROLL | ECO_AUTOVSCROLL |
3083                  ECO_NOHIDESEL | ECO_READONLY | ECO_WANTRETURN | ECO_SELECTIONBAR;
3084     DWORD settings = GetWindowLongW(editor->hWnd, GWL_STYLE) & mask;
3085
3086     return settings;
3087   }
3088   case EM_SETOPTIONS:
3089   {
3090     /* these flags are equivalent to ES_* counterparts
3091      * ECO_READONLY is already implemented in the code, only requires
3092      * setting the bit to work
3093      */
3094     DWORD mask = ECO_VERTICAL | ECO_AUTOHSCROLL | ECO_AUTOVSCROLL |
3095                  ECO_NOHIDESEL | ECO_READONLY | ECO_WANTRETURN | ECO_SELECTIONBAR;
3096     DWORD raw = GetWindowLongW(editor->hWnd, GWL_STYLE);
3097     DWORD settings = mask & raw;
3098     DWORD oldSettings = settings;
3099     DWORD changedSettings;
3100
3101     switch(wParam)
3102     {
3103       case ECOOP_SET:
3104         settings = lParam;
3105         break;
3106       case ECOOP_OR:
3107         settings |= lParam;
3108         break;
3109       case ECOOP_AND:
3110         settings &= lParam;
3111         break;
3112       case ECOOP_XOR:
3113         settings ^= lParam;
3114     }
3115     SetWindowLongW(editor->hWnd, GWL_STYLE, (raw & ~mask) | (settings & mask));
3116
3117     changedSettings = oldSettings ^ settings;
3118
3119     if (settings & ECO_AUTOWORDSELECTION)
3120       FIXME("ECO_AUTOWORDSELECTION not implemented yet!\n");
3121
3122     if (oldSettings ^ settings) {
3123       if (settings & ECO_SELECTIONBAR) {
3124         editor->selofs = SELECTIONBAR_WIDTH;
3125         editor->rcFormat.left += SELECTIONBAR_WIDTH;
3126       } else {
3127         editor->selofs = 0;
3128         editor->rcFormat.left -= SELECTIONBAR_WIDTH;
3129       }
3130       ME_WrapMarkedParagraphs(editor);
3131     }
3132
3133     if (settings & ECO_VERTICAL)
3134       FIXME("ECO_VERTICAL not implemented yet!\n");
3135     if (settings & ECO_AUTOHSCROLL)
3136       FIXME("ECO_AUTOHSCROLL not implemented yet!\n");
3137     if (settings & ECO_AUTOVSCROLL)
3138       FIXME("ECO_AUTOVSCROLL not implemented yet!\n");
3139     if (settings & ECO_NOHIDESEL)
3140       FIXME("ECO_NOHIDESEL not implemented yet!\n");
3141     if (settings & ECO_WANTRETURN)
3142       FIXME("ECO_WANTRETURN not implemented yet!\n");
3143
3144     return settings;
3145   }
3146   case EM_SETSEL:
3147   {
3148     ME_InvalidateSelection(editor);
3149     ME_SetSelection(editor, wParam, lParam);
3150     ME_InvalidateSelection(editor);
3151     HideCaret(editor->hWnd);
3152     ME_ShowCaret(editor);
3153     ME_SendSelChange(editor);
3154     return 0;
3155   }
3156   case EM_SETSCROLLPOS:
3157   {
3158     POINT *point = (POINT *)lParam;
3159     ME_ScrollAbs(editor, point->y);
3160     return 0;
3161   }
3162   case EM_AUTOURLDETECT:
3163   {
3164     if (wParam==1 || wParam ==0)
3165     {
3166         editor->AutoURLDetect_bEnable = (BOOL)wParam;
3167         return 0;
3168     }
3169     return E_INVALIDARG;
3170   }
3171   case EM_GETAUTOURLDETECT:
3172   {
3173     return editor->AutoURLDetect_bEnable;
3174   }
3175   case EM_EXSETSEL:
3176   {
3177     int end;
3178     CHARRANGE range = *(CHARRANGE *)lParam;
3179
3180     TRACE("EM_EXSETSEL (%d,%d)\n", range.cpMin, range.cpMax);
3181
3182     ME_InvalidateSelection(editor);
3183     end = ME_SetSelection(editor, range.cpMin, range.cpMax);
3184     ME_InvalidateSelection(editor);
3185     HideCaret(editor->hWnd);
3186     ME_ShowCaret(editor);
3187     ME_SendSelChange(editor);
3188
3189     return end;
3190   }
3191   case EM_SHOWSCROLLBAR:
3192   {
3193     ShowScrollBar(editor->hWnd, wParam, lParam);
3194     return 0;
3195   }
3196   case EM_SETTEXTEX:
3197   {
3198     LPWSTR wszText;
3199     SETTEXTEX *pStruct = (SETTEXTEX *)wParam;
3200     size_t len;
3201     int from, to;
3202     ME_Style *style;
3203     int oldModify = editor->nModifyStep;
3204
3205     if (!pStruct) return 0;
3206
3207     TRACE("EM_SETTEXTEX - %s, flags %d, cp %d\n",
3208           pStruct->codepage == 1200 ? debugstr_w((LPCWSTR)lParam) : debugstr_a((LPCSTR)lParam),
3209           pStruct->flags, pStruct->codepage);
3210
3211     /* FIXME: make use of pStruct->codepage in the to unicode translation */
3212     wszText = lParam ? ME_ToUnicode(pStruct->codepage == 1200, (void *)lParam) : NULL;
3213     len = wszText ? lstrlenW(wszText) : 0;
3214
3215     if (pStruct->flags & ST_SELECTION) {
3216       ME_GetSelection(editor, &from, &to);
3217       style = ME_GetSelectionInsertStyle(editor);
3218       ME_InternalDeleteText(editor, from, to - from, FALSE);
3219       if (pStruct->codepage != 1200 && lParam &&
3220           (!strncmp((char *)lParam, "{\\rtf", 5) || !strncmp((char *)lParam, "{\\urtf}", 6)))
3221         ME_StreamInRTFString(editor, 1, (char *)lParam);
3222       else ME_InsertTextFromCursor(editor, 0, wszText, len, style);
3223       ME_ReleaseStyle(style);
3224
3225       if (editor->AutoURLDetect_bEnable) ME_UpdateSelectionLinkAttribute(editor);
3226     }
3227     else {
3228       ME_InternalDeleteText(editor, 0, ME_GetTextLength(editor), FALSE);
3229       if (pStruct->codepage != 1200 && lParam &&
3230           (!strncmp((char *)lParam, "{\\rtf", 5) || !strncmp((char *)lParam, "{\\urtf}", 6)))
3231         ME_StreamInRTFString(editor, 0, (char *)lParam);
3232       else ME_InsertTextFromCursor(editor, 0, wszText, len, editor->pBuffer->pDefaultStyle);
3233       len = 1;
3234
3235       if (editor->AutoURLDetect_bEnable) ME_UpdateLinkAttribute(editor, 0, -1);
3236     }
3237     ME_CommitUndo(editor);
3238     if (!(pStruct->flags & ST_KEEPUNDO))
3239     {
3240       editor->nModifyStep = oldModify;
3241       ME_EmptyUndoStack(editor);
3242     }
3243     ME_UpdateRepaint(editor);
3244     return len;
3245   }
3246   case EM_SETBKGNDCOLOR:
3247   {
3248     LRESULT lColor;
3249     if (editor->rgbBackColor != -1) {
3250       DeleteObject(editor->hbrBackground);
3251       lColor = editor->rgbBackColor;
3252     }
3253     else lColor = GetSysColor(COLOR_WINDOW);
3254
3255     if (wParam)
3256     {
3257       editor->rgbBackColor = -1;
3258       editor->hbrBackground = GetSysColorBrush(COLOR_WINDOW);
3259     }
3260     else
3261     {
3262       editor->rgbBackColor = lParam;
3263       editor->hbrBackground = CreateSolidBrush(editor->rgbBackColor);
3264     }
3265     InvalidateRect(editor->hWnd, NULL, TRUE);
3266     UpdateWindow(editor->hWnd);
3267     return lColor;
3268   }
3269   case EM_GETMODIFY:
3270     return editor->nModifyStep == 0 ? 0 : -1;
3271   case EM_SETMODIFY:
3272   {
3273     if (wParam)
3274       editor->nModifyStep = 1;
3275     else
3276       editor->nModifyStep = 0;
3277
3278     return 0;
3279   }
3280   case EM_SETREADONLY:
3281   {
3282     long nStyle = GetWindowLongW(editor->hWnd, GWL_STYLE);
3283     if (wParam)
3284       nStyle |= ES_READONLY;
3285     else
3286       nStyle &= ~ES_READONLY;
3287     SetWindowLongW(editor->hWnd, GWL_STYLE, nStyle);
3288     return 0;
3289   }
3290   case EM_SETEVENTMASK:
3291   {
3292     DWORD nOldMask = editor->nEventMask;
3293
3294     editor->nEventMask = lParam;
3295     return nOldMask;
3296   }
3297   case EM_GETEVENTMASK:
3298     return editor->nEventMask;
3299   case EM_SETCHARFORMAT:
3300   {
3301     CHARFORMAT2W buf, *p;
3302     BOOL bRepaint = TRUE;
3303     p = ME_ToCF2W(&buf, (CHARFORMAT2W *)lParam);
3304     if (p == NULL) return 0;
3305     if (!wParam)
3306       ME_SetDefaultCharFormat(editor, p);
3307     else if (wParam == (SCF_WORD | SCF_SELECTION)) {
3308       FIXME("EM_SETCHARFORMAT: word selection not supported\n");
3309       return 0;
3310     } else if (wParam == SCF_ALL) {
3311       if (editor->mode & TM_PLAINTEXT)
3312         ME_SetDefaultCharFormat(editor, p);
3313       else {
3314         ME_SetCharFormat(editor, 0, ME_GetTextLength(editor), p);
3315         editor->nModifyStep = 1;
3316       }
3317     } else if (editor->mode & TM_PLAINTEXT) {
3318       return 0;
3319     } else {
3320       int from, to;
3321       ME_GetSelection(editor, &from, &to);
3322       bRepaint = (from != to);
3323       ME_SetSelectionCharFormat(editor, p);
3324       if (from != to) editor->nModifyStep = 1;
3325     }
3326     ME_CommitUndo(editor);
3327     if (bRepaint)
3328     {
3329       ME_WrapMarkedParagraphs(editor);
3330       ME_UpdateScrollBar(editor);
3331       ME_Repaint(editor);
3332     }
3333     return 1;
3334   }
3335   case EM_GETCHARFORMAT:
3336   {
3337     CHARFORMAT2W tmp, *dst = (CHARFORMAT2W *)lParam;
3338     if (dst->cbSize != sizeof(CHARFORMATA) &&
3339         dst->cbSize != sizeof(CHARFORMATW) &&
3340         dst->cbSize != sizeof(CHARFORMAT2A) &&
3341         dst->cbSize != sizeof(CHARFORMAT2W))
3342       return 0;
3343     tmp.cbSize = sizeof(tmp);
3344     if (!wParam)
3345       ME_GetDefaultCharFormat(editor, &tmp);
3346     else
3347       ME_GetSelectionCharFormat(editor, &tmp);
3348     ME_CopyToCFAny(dst, &tmp);
3349     return tmp.dwMask;
3350   }
3351   case EM_SETPARAFORMAT:
3352   {
3353     BOOL result = ME_SetSelectionParaFormat(editor, (PARAFORMAT2 *)lParam);
3354     ME_WrapMarkedParagraphs(editor);
3355     ME_UpdateScrollBar(editor);
3356     ME_Repaint(editor);
3357     ME_CommitUndo(editor);
3358     return result;
3359   }
3360   case EM_GETPARAFORMAT:
3361     ME_GetSelectionParaFormat(editor, (PARAFORMAT2 *)lParam);
3362     return ((PARAFORMAT2 *)lParam)->dwMask;
3363   case EM_GETFIRSTVISIBLELINE:
3364   {
3365     ME_DisplayItem *p = editor->pBuffer->pFirst;
3366     int y = ME_GetYScrollPos(editor);
3367     int ypara = 0;
3368     int count = 0;
3369     int ystart, yend;
3370     while(p) {
3371       p = ME_FindItemFwd(p, diStartRowOrParagraphOrEnd);
3372       if (p->type == diTextEnd)
3373         break;
3374       if (p->type == diParagraph) {
3375         ypara = p->member.para.pt.y;
3376         continue;
3377       }
3378       ystart = ypara + p->member.row.pt.y;
3379       yend = ystart + p->member.row.nHeight;
3380       if (y < yend) {
3381         break;
3382       }
3383       count++;
3384     }
3385     return count;
3386   }
3387   case EM_HIDESELECTION:
3388   {
3389      editor->bHideSelection = (wParam != 0);
3390      ME_InvalidateSelection(editor);
3391      return 0;
3392   }
3393   case EM_LINESCROLL:
3394   {
3395     ME_ScrollDown(editor, lParam * 8); /* FIXME follow the original */
3396     return TRUE; /* Should return false if a single line richedit control */
3397   }
3398   case WM_CLEAR:
3399   {
3400     int from, to;
3401     ME_GetSelection(editor, &from, &to);
3402     ME_InternalDeleteText(editor, from, to-from, FALSE);
3403     ME_CommitUndo(editor);
3404     ME_UpdateRepaint(editor);
3405     return 0;
3406   }
3407   case EM_REPLACESEL:
3408   {
3409     int from, to;
3410     ME_Style *style;
3411     LPWSTR wszText = lParam ? ME_ToUnicode(unicode, (void *)lParam) : NULL;
3412     size_t len = wszText ? lstrlenW(wszText) : 0;
3413     TRACE("EM_REPLACESEL - %s\n", debugstr_w(wszText));
3414
3415     ME_GetSelection(editor, &from, &to);
3416     style = ME_GetSelectionInsertStyle(editor);
3417     ME_InternalDeleteText(editor, from, to-from, FALSE);
3418     ME_InsertTextFromCursor(editor, 0, wszText, len, style);
3419     ME_ReleaseStyle(style);
3420     /* drop temporary style if line end */
3421     /*
3422      * FIXME question: does abc\n mean: put abc,
3423      * clear temp style, put \n? (would require a change)
3424      */
3425     if (len>0 && wszText[len-1] == '\n')
3426       ME_ClearTempStyle(editor);
3427     ME_EndToUnicode(unicode, wszText);
3428     ME_CommitUndo(editor);
3429     if (editor->AutoURLDetect_bEnable) ME_UpdateSelectionLinkAttribute(editor);
3430     if (!wParam)
3431       ME_EmptyUndoStack(editor);
3432     ME_UpdateRepaint(editor);
3433     return len;
3434   }
3435   case EM_SCROLLCARET:
3436     ME_EnsureVisible(editor, editor->pCursors[0].pRun);
3437     return 0;
3438   case WM_SETFONT:
3439   {
3440     LOGFONTW lf;
3441     CHARFORMAT2W fmt;
3442     HDC hDC;
3443     BOOL bRepaint = LOWORD(lParam);
3444
3445     if (!wParam)
3446       wParam = (WPARAM)GetStockObject(SYSTEM_FONT);
3447     GetObjectW((HGDIOBJ)wParam, sizeof(LOGFONTW), &lf);
3448     hDC = GetDC(editor->hWnd);
3449     ME_CharFormatFromLogFont(hDC, &lf, &fmt);
3450     ReleaseDC(editor->hWnd, hDC);
3451     ME_SetCharFormat(editor, 0, ME_GetTextLength(editor), &fmt);
3452     ME_SetDefaultCharFormat(editor, &fmt);
3453
3454     ME_CommitUndo(editor);
3455     if (bRepaint)
3456       ME_RewrapRepaint(editor);
3457     return 0;
3458   }
3459   case WM_SETTEXT:
3460   {
3461     ME_InternalDeleteText(editor, 0, ME_GetTextLength(editor), FALSE);
3462     if (lParam)
3463     {
3464       TRACE("WM_SETTEXT lParam==%lx\n",lParam);
3465       if (!unicode && !strncmp((char *)lParam, "{\\rtf", 5))
3466       {
3467         /* Undocumented: WM_SETTEXT supports RTF text */
3468         ME_StreamInRTFString(editor, 0, (char *)lParam);
3469       }
3470       else
3471       {
3472         LPWSTR wszText = ME_ToUnicode(unicode, (void *)lParam);
3473         TRACE("WM_SETTEXT - %s\n", debugstr_w(wszText)); /* debugstr_w() */
3474         if (lstrlenW(wszText) > 0)
3475         {
3476           int len = -1;
3477
3478           /* uses default style! */
3479           if (!(GetWindowLongW(editor->hWnd, GWL_STYLE) & ES_MULTILINE))
3480           {
3481             WCHAR * p;
3482
3483             p = wszText;
3484             while (*p != '\0' && *p != '\r' && *p != '\n') p++;
3485             len = p - wszText;
3486           }
3487           ME_InsertTextFromCursor(editor, 0, wszText, len, editor->pBuffer->pDefaultStyle);
3488         }
3489         ME_EndToUnicode(unicode, wszText);
3490       }
3491     }
3492     else
3493       TRACE("WM_SETTEXT - NULL\n");
3494     if (editor->AutoURLDetect_bEnable)
3495     {
3496       ME_UpdateLinkAttribute(editor, 0, -1);
3497     }
3498     ME_SetSelection(editor, 0, 0);
3499     editor->nModifyStep = 0;
3500     ME_CommitUndo(editor);
3501     ME_EmptyUndoStack(editor);
3502     ME_UpdateRepaint(editor);
3503     return 1;
3504   }
3505   case EM_CANPASTE:
3506   {
3507     UINT nRTFFormat = RegisterClipboardFormatA("Rich Text Format");
3508     if (IsClipboardFormatAvailable(nRTFFormat))
3509       return TRUE;
3510     if (IsClipboardFormatAvailable(CF_UNICODETEXT))
3511       return TRUE;
3512     return FALSE;
3513   }
3514   case WM_PASTE:
3515     ME_Paste(editor);
3516     return 0;
3517   case WM_CUT:
3518   case WM_COPY:
3519   {
3520     CHARRANGE range;
3521     ME_GetSelection(editor, &range.cpMin, &range.cpMax);
3522
3523     if (ME_Copy(editor, &range) && msg == WM_CUT)
3524     {
3525       ME_InternalDeleteText(editor, range.cpMin, range.cpMax-range.cpMin, FALSE);
3526       ME_CommitUndo(editor);
3527       ME_UpdateRepaint(editor);
3528     }
3529     return 0;
3530   }
3531   case WM_GETTEXTLENGTH:
3532   {
3533     GETTEXTLENGTHEX how;
3534
3535     /* CR/LF conversion required in 2.0 mode, verbatim in 1.0 mode */
3536     how.flags = GTL_CLOSE | (editor->bEmulateVersion10 ? 0 : GTL_USECRLF) | GTL_NUMCHARS;
3537     how.codepage = unicode ? 1200 : CP_ACP;
3538     return ME_GetTextLengthEx(editor, &how);
3539   }
3540   case EM_GETTEXTLENGTHEX:
3541     return ME_GetTextLengthEx(editor, (GETTEXTLENGTHEX *)wParam);
3542   case WM_GETTEXT:
3543   {
3544     GETTEXTEX ex;
3545     LRESULT rc;
3546     LPSTR bufferA = NULL;
3547     LPWSTR bufferW = NULL;
3548
3549     if (unicode)
3550         bufferW = heap_alloc((wParam + 2) * sizeof(WCHAR));
3551     else
3552         bufferA = heap_alloc(wParam + 2);
3553
3554     ex.cb = (wParam + 2) * (unicode ? sizeof(WCHAR) : sizeof(CHAR));
3555     ex.flags = GT_USECRLF;
3556     ex.codepage = unicode ? 1200 : CP_ACP;
3557     ex.lpDefaultChar = NULL;
3558     ex.lpUsedDefChar = NULL;
3559
3560     rc = ME_GetTextEx(editor, &ex, unicode ? (LPARAM)bufferW : (LPARAM)bufferA);
3561
3562     if (unicode)
3563     {
3564         memcpy((LPWSTR)lParam, bufferW, wParam * sizeof(WCHAR));
3565         if (strlenW(bufferW) >= wParam) rc = 0;
3566     }
3567     else
3568     {
3569         memcpy((LPSTR)lParam, bufferA, wParam);
3570         if (strlen(bufferA) >= wParam) rc = 0;
3571     }
3572     heap_free(bufferA);
3573     heap_free(bufferW);
3574     return rc;
3575   }
3576   case EM_GETTEXTEX:
3577     return ME_GetTextEx(editor, (GETTEXTEX*)wParam, lParam);
3578   case EM_GETSELTEXT:
3579   {
3580     int from, to;
3581     TEXTRANGEW tr; /* W and A differ only by rng->lpstrText */
3582     ME_GetSelection(editor, &from, &to);
3583     tr.chrg.cpMin = from;
3584     tr.chrg.cpMax = to;
3585     tr.lpstrText = (WCHAR *)lParam;
3586     return ME_GetTextRange(editor, &tr, unicode);
3587   }
3588   case EM_GETSCROLLPOS:
3589   {
3590       POINT *point = (POINT *)lParam;
3591       point->x = 0; /* FIXME side scrolling not implemented */
3592       point->y = ME_GetYScrollPos(editor);
3593       return 1;
3594   }
3595   case EM_GETTEXTRANGE:
3596   {
3597     TEXTRANGEW *rng = (TEXTRANGEW *)lParam;
3598     TRACE("EM_GETTEXTRANGE min=%d max=%d unicode=%d emul1.0=%d length=%d\n",
3599       rng->chrg.cpMin, rng->chrg.cpMax, unicode,
3600       editor->bEmulateVersion10, ME_GetTextLength(editor));
3601     return ME_GetTextRange(editor, rng, unicode);
3602   }
3603   case EM_GETLINE:
3604   {
3605     ME_DisplayItem *run;
3606     const unsigned int nMaxChars = *(WORD *) lParam;
3607     unsigned int nCharsLeft = nMaxChars;
3608     char *dest = (char *) lParam;
3609     BOOL wroteNull = FALSE;
3610
3611     TRACE("EM_GETLINE: row=%d, nMaxChars=%d (%s)\n", (int) wParam, nMaxChars,
3612           unicode ? "Unicode" : "Ansi");
3613
3614     run = ME_FindRowWithNumber(editor, wParam);
3615     if (run == NULL)
3616       return 0;
3617
3618     while (nCharsLeft && (run = ME_FindItemFwd(run, diRunOrStartRow))
3619            && !(run->member.run.nFlags & MERF_ENDPARA))
3620     {
3621       unsigned int nCopy;
3622       ME_String *strText;
3623       if (run->type != diRun)
3624         break;
3625       strText = run->member.run.strText;
3626       nCopy = min(nCharsLeft, strText->nLen);
3627
3628       if (unicode)
3629         memcpy(dest, strText->szData, nCopy * sizeof(WCHAR));
3630       else
3631         nCopy = WideCharToMultiByte(CP_ACP, 0, strText->szData, nCopy, dest,
3632                                     nCharsLeft, NULL, NULL);
3633       dest += nCopy * (unicode ? sizeof(WCHAR) : 1);
3634       nCharsLeft -= nCopy;
3635     }
3636
3637     /* append line termination, space allowing */
3638     if (nCharsLeft > 0)
3639     {
3640       if (run && (run->member.run.nFlags & MERF_ENDPARA))
3641       {
3642         int i;
3643         /* Write as many \r as encoded in end-of-paragraph, space allowing */
3644         for (i = 0; i < run->member.run.nCR && nCharsLeft > 0; i++, nCharsLeft--)
3645         {
3646           *((WCHAR *)dest) = '\r';
3647           dest += unicode ? sizeof(WCHAR) : 1;
3648         }
3649         /* Write as many \n as encoded in end-of-paragraph, space allowing */
3650         for (i = 0; i < run->member.run.nLF && nCharsLeft > 0; i++, nCharsLeft--)
3651         {
3652           *((WCHAR *)dest) = '\n';
3653           dest += unicode ? sizeof(WCHAR) : 1;
3654         }
3655       }
3656       if (nCharsLeft > 0)
3657       {
3658         if (unicode)
3659           *((WCHAR *)dest) = '\0';
3660         else
3661           *dest = '\0';
3662         nCharsLeft--;
3663         wroteNull = TRUE;
3664       }
3665     }
3666
3667     TRACE("EM_GETLINE: got %u characters\n", nMaxChars - nCharsLeft);
3668     return nMaxChars - nCharsLeft - (wroteNull ? 1 : 0);
3669   }
3670   case EM_GETLINECOUNT:
3671   {
3672     ME_DisplayItem *item = editor->pBuffer->pFirst->next;
3673     int nRows = 0;
3674
3675     ME_DisplayItem *prev_para = NULL, *last_para = NULL;
3676
3677     while (item != editor->pBuffer->pLast)
3678     {
3679       assert(item->type == diParagraph);
3680       prev_para = ME_FindItemBack(item, diRun);
3681       if (prev_para) {
3682         assert(prev_para->member.run.nFlags & MERF_ENDPARA);
3683       }
3684       nRows += item->member.para.nRows;
3685       item = item->member.para.next_para;
3686     }
3687     last_para = ME_FindItemBack(item, diRun);
3688     assert(last_para);
3689     assert(last_para->member.run.nFlags & MERF_ENDPARA);
3690     if (editor->bEmulateVersion10 && prev_para && last_para->member.run.nCharOfs == 0
3691         && prev_para->member.run.nCR == 1 && prev_para->member.run.nLF == 0)
3692     {
3693       /* In 1.0 emulation, the last solitary \r at the very end of the text
3694          (if one exists) is NOT a line break.
3695          FIXME: this is an ugly hack. This should have a more regular model. */
3696       nRows--;
3697     }
3698
3699     TRACE("EM_GETLINECOUNT: nRows==%d\n", nRows);
3700     return max(1, nRows);
3701   }
3702   case EM_LINEFROMCHAR:
3703   {
3704     if (wParam == -1)
3705       return ME_RowNumberFromCharOfs(editor, ME_GetCursorOfs(editor, 1));
3706     else
3707       return ME_RowNumberFromCharOfs(editor, wParam);
3708   }
3709   case EM_EXLINEFROMCHAR:
3710   {
3711     if (lParam == -1)
3712       return ME_RowNumberFromCharOfs(editor, ME_GetCursorOfs(editor,1));
3713     else
3714       return ME_RowNumberFromCharOfs(editor, lParam);
3715   }
3716   case EM_LINEINDEX:
3717   {
3718     ME_DisplayItem *item, *para;
3719     int nCharOfs;
3720
3721     if (wParam == -1)
3722       item = ME_FindItemBack(editor->pCursors[0].pRun, diStartRow);
3723     else
3724       item = ME_FindRowWithNumber(editor, wParam);
3725     if (!item)
3726       return -1;
3727     para = ME_GetParagraph(item);
3728     item = ME_FindItemFwd(item, diRun);
3729     nCharOfs = para->member.para.nCharOfs + item->member.run.nCharOfs;
3730     TRACE("EM_LINEINDEX: nCharOfs==%d\n", nCharOfs);
3731     return nCharOfs;
3732   }
3733   case EM_LINELENGTH:
3734   {
3735     ME_DisplayItem *item, *item_end;
3736     int nChars = 0, nThisLineOfs = 0, nNextLineOfs = 0;
3737
3738     if (wParam > ME_GetTextLength(editor))
3739       return 0;
3740     if (wParam == -1)
3741     {
3742       FIXME("EM_LINELENGTH: returning number of unselected characters on lines with selection unsupported.\n");
3743       return 0;
3744     }
3745     item = ME_FindItemAtOffset(editor, diRun, wParam, NULL);
3746     item = ME_RowStart(item);
3747     nThisLineOfs = ME_CharOfsFromRunOfs(editor, ME_FindItemFwd(item, diRun), 0);
3748     item_end = ME_FindItemFwd(item, diStartRowOrParagraphOrEnd);
3749     if (item_end->type == diStartRow)
3750       nNextLineOfs = ME_CharOfsFromRunOfs(editor, ME_FindItemFwd(item_end, diRun), 0);
3751     else
3752     {
3753       ME_DisplayItem *endPara;
3754
3755       nNextLineOfs = ME_FindItemFwd(item, diParagraphOrEnd)->member.para.nCharOfs;
3756       endPara = ME_FindItemFwd(item, diParagraphOrEnd);
3757       endPara = ME_FindItemBack(endPara, diRun);
3758       assert(endPara);
3759       assert(endPara->type == diRun);
3760       assert(endPara->member.run.nFlags & MERF_ENDPARA);
3761       nNextLineOfs -= endPara->member.run.nCR + endPara->member.run.nLF;
3762     }
3763     nChars = nNextLineOfs - nThisLineOfs;
3764     TRACE("EM_LINELENGTH(%ld)==%d\n",wParam, nChars);
3765     return nChars;
3766   }
3767   case EM_EXLIMITTEXT:
3768   {
3769     if ((int)lParam < 0)
3770      return 0;
3771     if (lParam == 0)
3772       editor->nTextLimit = 65536;
3773     else
3774       editor->nTextLimit = (int) lParam;
3775     return 0;
3776   }
3777   case EM_LIMITTEXT:
3778   {
3779     if (wParam == 0)
3780       editor->nTextLimit = 65536;
3781     else
3782       editor->nTextLimit = (int) wParam;
3783     return 0;
3784   }
3785   case EM_GETLIMITTEXT:
3786   {
3787     return editor->nTextLimit;
3788   }
3789   case EM_FINDTEXT:
3790   {
3791     FINDTEXTA *ft = (FINDTEXTA *)lParam;
3792     int nChars = MultiByteToWideChar(CP_ACP, 0, ft->lpstrText, -1, NULL, 0);
3793     WCHAR *tmp;
3794     LRESULT r;
3795
3796     if ((tmp = ALLOC_N_OBJ(WCHAR, nChars)) != NULL)
3797       MultiByteToWideChar(CP_ACP, 0, ft->lpstrText, -1, tmp, nChars);
3798     r = ME_FindText(editor, wParam, &ft->chrg, tmp, NULL);
3799     FREE_OBJ( tmp );
3800     return r;
3801   }
3802   case EM_FINDTEXTEX:
3803   {
3804     FINDTEXTEXA *ex = (FINDTEXTEXA *)lParam;
3805     int nChars = MultiByteToWideChar(CP_ACP, 0, ex->lpstrText, -1, NULL, 0);
3806     WCHAR *tmp;
3807     LRESULT r;
3808
3809     if ((tmp = ALLOC_N_OBJ(WCHAR, nChars)) != NULL)
3810       MultiByteToWideChar(CP_ACP, 0, ex->lpstrText, -1, tmp, nChars);
3811     r = ME_FindText(editor, wParam, &ex->chrg, tmp, &ex->chrgText);
3812     FREE_OBJ( tmp );
3813     return r;
3814   }
3815   case EM_FINDTEXTW:
3816   {
3817     FINDTEXTW *ft = (FINDTEXTW *)lParam;
3818     return ME_FindText(editor, wParam, &ft->chrg, ft->lpstrText, NULL);
3819   }
3820   case EM_FINDTEXTEXW:
3821   {
3822     FINDTEXTEXW *ex = (FINDTEXTEXW *)lParam;
3823     return ME_FindText(editor, wParam, &ex->chrg, ex->lpstrText, &ex->chrgText);
3824   }
3825   case EM_GETZOOM:
3826     if (!wParam || !lParam)
3827       return FALSE;
3828     *(int *)wParam = editor->nZoomNumerator;
3829     *(int *)lParam = editor->nZoomDenominator;
3830     return TRUE;
3831   case EM_SETZOOM:
3832     return ME_SetZoom(editor, wParam, lParam);
3833   case EM_CHARFROMPOS:
3834     return ME_CharFromPos(editor, ((POINTL *)lParam)->x, ((POINTL *)lParam)->y, NULL);
3835   case EM_POSFROMCHAR:
3836   {
3837     ME_DisplayItem *pRun;
3838     int nCharOfs, nOffset, nLength;
3839     POINTL pt = {0,0};
3840     SCROLLINFO si;
3841
3842     nCharOfs = wParam;
3843     /* detect which API version we're dealing with */
3844     if (wParam >= 0x40000)
3845         nCharOfs = lParam;
3846     nLength = ME_GetTextLength(editor);
3847     nCharOfs = min(nCharOfs, nLength);
3848     nCharOfs = max(nCharOfs, 0);
3849
3850     ME_RunOfsFromCharOfs(editor, nCharOfs, &pRun, &nOffset);
3851     assert(pRun->type == diRun);
3852     pt.y = pRun->member.run.pt.y;
3853     pt.x = pRun->member.run.pt.x + ME_PointFromChar(editor, &pRun->member.run, nOffset);
3854     pt.y += ME_GetParagraph(pRun)->member.para.pt.y + editor->rcFormat.top;
3855     pt.x += editor->rcFormat.left;
3856
3857     pt.y -= editor->vert_si.nPos;
3858     si.cbSize = sizeof(si);
3859     si.fMask = SIF_POS;
3860     if (GetScrollInfo(editor->hWnd, SB_HORZ, &si)) pt.x -= si.nPos;
3861
3862     if (wParam >= 0x40000) {
3863         *(POINTL *)wParam = pt;
3864     }
3865     return (wParam >= 0x40000) ? 0 : MAKELONG( pt.x, pt.y );
3866   }
3867   case WM_CREATE:
3868   {
3869     SCROLLINFO si;
3870
3871     ME_SetDefaultFormatRect(editor);
3872     if (GetWindowLongW(editor->hWnd, GWL_STYLE) & WS_HSCROLL)
3873     { /* Squelch the default horizontal scrollbar it would make */
3874       ShowScrollBar(editor->hWnd, SB_HORZ, FALSE);
3875     }
3876
3877     si.cbSize = sizeof(si);
3878     si.fMask = SIF_PAGE | SIF_RANGE;
3879     if (GetWindowLongW(editor->hWnd, GWL_STYLE) & ES_DISABLENOSCROLL)
3880       si.fMask |= SIF_DISABLENOSCROLL;
3881     si.nMax = (si.fMask & SIF_DISABLENOSCROLL) ? 1 : 0;
3882     si.nMin = 0;
3883     si.nPage = 0;
3884     SetScrollInfo(editor->hWnd, SB_VERT, &si, TRUE);
3885
3886     ME_CommitUndo(editor);
3887     ME_WrapMarkedParagraphs(editor);
3888     ME_MoveCaret(editor);
3889     return 0;
3890   }
3891   case WM_DESTROY:
3892     ME_DestroyEditor(editor);
3893     return 0;
3894   case WM_SETCURSOR:
3895   {
3896     return ME_SetCursor(editor);
3897   }
3898   case WM_LBUTTONDBLCLK:
3899   case WM_LBUTTONDOWN:
3900   {
3901     ME_CommitUndo(editor); /* End coalesced undos for typed characters */
3902     if ((editor->nEventMask & ENM_MOUSEEVENTS) &&
3903         !ME_FilterEvent(editor, msg, &wParam, &lParam))
3904       return 0;
3905     SetFocus(editor->hWnd);
3906     ME_LButtonDown(editor, (short)LOWORD(lParam), (short)HIWORD(lParam),
3907                    ME_CalculateClickCount(editor, msg, wParam, lParam));
3908     SetCapture(editor->hWnd);
3909     editor->bMouseCaptured = TRUE;
3910     ME_LinkNotify(editor,msg,wParam,lParam);
3911     if (!ME_SetCursor(editor)) goto do_default;
3912     break;
3913   }
3914   case WM_MOUSEMOVE:
3915     if ((editor->nEventMask & ENM_MOUSEEVENTS) &&
3916         !ME_FilterEvent(editor, msg, &wParam, &lParam))
3917       return 0;
3918     if (editor->bMouseCaptured)
3919       ME_MouseMove(editor, (short)LOWORD(lParam), (short)HIWORD(lParam));
3920     ME_LinkNotify(editor,msg,wParam,lParam);
3921     /* Set cursor if mouse is captured, since WM_SETCURSOR won't be received. */
3922     if (editor->bMouseCaptured)
3923         ME_SetCursor(editor);
3924     break;
3925   case WM_LBUTTONUP:
3926     if (editor->bMouseCaptured) {
3927       ReleaseCapture();
3928       editor->bMouseCaptured = FALSE;
3929     }
3930     if (editor->nSelectionType == stDocument)
3931       editor->nSelectionType = stPosition;
3932     if ((editor->nEventMask & ENM_MOUSEEVENTS) &&
3933         !ME_FilterEvent(editor, msg, &wParam, &lParam))
3934       return 0;
3935     else
3936     {
3937       ME_SetCursor(editor);
3938       ME_LinkNotify(editor,msg,wParam,lParam);
3939     }
3940     break;
3941   case WM_RBUTTONUP:
3942   case WM_RBUTTONDOWN:
3943     ME_CommitUndo(editor); /* End coalesced undos for typed characters */
3944     if ((editor->nEventMask & ENM_MOUSEEVENTS) &&
3945         !ME_FilterEvent(editor, msg, &wParam, &lParam))
3946       return 0;
3947     goto do_default;
3948   case WM_CONTEXTMENU:
3949     if (!ME_ShowContextMenu(editor, (short)LOWORD(lParam), (short)HIWORD(lParam)))
3950       goto do_default;
3951     break;
3952   case WM_PAINT:
3953     {
3954       HDC hDC;
3955       RECT rc;
3956       PAINTSTRUCT ps;
3957
3958       hDC = BeginPaint(editor->hWnd, &ps);
3959       /* Erase area outside of the formatting rectangle */
3960       if (ps.rcPaint.top < editor->rcFormat.top)
3961       {
3962         rc = ps.rcPaint;
3963         rc.bottom = editor->rcFormat.top;
3964         FillRect(hDC, &rc, editor->hbrBackground);
3965         ps.rcPaint.top = editor->rcFormat.top;
3966       }
3967       if (ps.rcPaint.bottom > editor->rcFormat.bottom) {
3968         rc = ps.rcPaint;
3969         rc.top = editor->rcFormat.bottom;
3970         FillRect(hDC, &rc, editor->hbrBackground);
3971         ps.rcPaint.bottom = editor->rcFormat.bottom;
3972       }
3973       if (ps.rcPaint.left < editor->rcFormat.left) {
3974         rc = ps.rcPaint;
3975         rc.right = editor->rcFormat.left;
3976         FillRect(hDC, &rc, editor->hbrBackground);
3977         ps.rcPaint.left = editor->rcFormat.left;
3978       }
3979       if (ps.rcPaint.right > editor->rcFormat.right) {
3980         rc = ps.rcPaint;
3981         rc.left = editor->rcFormat.right;
3982         FillRect(hDC, &rc, editor->hbrBackground);
3983         ps.rcPaint.right = editor->rcFormat.right;
3984       }
3985
3986       ME_PaintContent(editor, hDC, FALSE, &ps.rcPaint);
3987       EndPaint(editor->hWnd, &ps);
3988     }
3989     break;
3990   case WM_SETFOCUS:
3991     editor->bHaveFocus = TRUE;
3992     ME_ShowCaret(editor);
3993     ME_SendOldNotify(editor, EN_SETFOCUS);
3994     return 0;
3995   case WM_KILLFOCUS:
3996     ME_CommitUndo(editor); /* End coalesced undos for typed characters */
3997     editor->bHaveFocus = FALSE;
3998     ME_HideCaret(editor);
3999     ME_SendOldNotify(editor, EN_KILLFOCUS);
4000     return 0;
4001   case WM_ERASEBKGND:
4002   {
4003     HDC hDC = (HDC)wParam;
4004     RECT rc;
4005     if (GetUpdateRect(editor->hWnd,&rc,TRUE))
4006     {
4007       FillRect(hDC, &rc, editor->hbrBackground);
4008     }
4009     return 1;
4010   }
4011   case WM_COMMAND:
4012     TRACE("editor wnd command = %d\n", LOWORD(wParam));
4013     return 0;
4014   case WM_KEYUP:
4015     if ((editor->nEventMask & ENM_KEYEVENTS) &&
4016         !ME_FilterEvent(editor, msg, &wParam, &lParam))
4017       return 0;
4018     goto do_default;
4019   case WM_KEYDOWN:
4020     if ((editor->nEventMask & ENM_KEYEVENTS) &&
4021         !ME_FilterEvent(editor, msg, &wParam, &lParam))
4022       return 0;
4023     if (ME_KeyDown(editor, LOWORD(wParam)))
4024       return 0;
4025     goto do_default;
4026   case WM_CHAR:
4027     return ME_Char(editor, wParam, lParam, unicode);
4028   case WM_UNICHAR:
4029     if (unicode)
4030     {
4031         if(wParam == UNICODE_NOCHAR) return TRUE;
4032         if(wParam <= 0x000fffff)
4033         {
4034             if(wParam > 0xffff) /* convert to surrogates */
4035             {
4036                 wParam -= 0x10000;
4037                 ME_Char(editor, (wParam >> 10) + 0xd800, 0, TRUE);
4038                 ME_Char(editor, (wParam & 0x03ff) + 0xdc00, 0, TRUE);
4039             } else {
4040               ME_Char(editor, wParam, 0, TRUE);
4041             }
4042         }
4043         return 0;
4044     }
4045     break;
4046   case EM_STOPGROUPTYPING:
4047     ME_CommitUndo(editor); /* End coalesced undos for typed characters */
4048     return 0;
4049   case EM_SCROLL: /* fall through */
4050   case WM_VSCROLL:
4051   {
4052     int origNPos;
4053     int lineHeight;
4054
4055     origNPos = ME_GetYScrollPos(editor);
4056     lineHeight = 24;
4057
4058     if (editor && editor->pBuffer && editor->pBuffer->pDefaultStyle)
4059       lineHeight = editor->pBuffer->pDefaultStyle->tm.tmHeight;
4060     if (lineHeight <= 0) lineHeight = 24;
4061
4062     switch(LOWORD(wParam))
4063     {
4064       case SB_LINEUP:
4065         ME_ScrollUp(editor,lineHeight);
4066         break;
4067       case SB_LINEDOWN:
4068         ME_ScrollDown(editor,lineHeight);
4069         break;
4070       case SB_PAGEUP:
4071         ME_ScrollUp(editor,editor->sizeWindow.cy);
4072         break;
4073       case SB_PAGEDOWN:
4074         ME_ScrollDown(editor,editor->sizeWindow.cy);
4075         break;
4076       case SB_THUMBTRACK:
4077       case SB_THUMBPOSITION:
4078       {
4079         SCROLLINFO sbi;
4080         sbi.cbSize = sizeof(sbi);
4081         sbi.fMask = SIF_TRACKPOS;
4082         /* Try to get 32-bit track position value. */
4083         if (!GetScrollInfo(editor->hWnd, SB_VERT, &sbi))
4084           /* GetScrollInfo failed, settle for 16-bit value in wParam. */
4085           sbi.nTrackPos = HIWORD(wParam);
4086
4087         ME_ScrollAbs(editor, sbi.nTrackPos);
4088         break;
4089       }
4090     }
4091     if (msg == EM_SCROLL)
4092       return 0x00010000 | (((ME_GetYScrollPos(editor) - origNPos)/lineHeight) & 0xffff);
4093     break;
4094   }
4095   case WM_MOUSEWHEEL:
4096   {
4097     int gcWheelDelta;
4098     UINT pulScrollLines;
4099     BOOL ctrl_is_down;
4100
4101     if ((editor->nEventMask & ENM_MOUSEEVENTS) &&
4102         !ME_FilterEvent(editor, msg, &wParam, &lParam))
4103       return 0;
4104
4105     ctrl_is_down = GetKeyState(VK_CONTROL) & 0x8000;
4106
4107     gcWheelDelta = GET_WHEEL_DELTA_WPARAM(wParam);
4108
4109     if (abs(gcWheelDelta) >= WHEEL_DELTA)
4110     {
4111       if (ctrl_is_down) {
4112         int numerator;
4113         if (!editor->nZoomNumerator || !editor->nZoomDenominator)
4114         {
4115           numerator = 100;
4116         } else {
4117           numerator = editor->nZoomNumerator * 100 / editor->nZoomDenominator;
4118         }
4119         numerator = numerator + (gcWheelDelta / WHEEL_DELTA) * 10;
4120         if (numerator >= 10 && numerator <= 500)
4121           ME_SetZoom(editor, numerator, 100);
4122       } else {
4123         SystemParametersInfoW(SPI_GETWHEELSCROLLLINES,0, &pulScrollLines, 0);
4124         /* FIXME follow the original */
4125         if (pulScrollLines)
4126           ME_ScrollDown(editor,pulScrollLines * (-gcWheelDelta / WHEEL_DELTA) * 8);
4127       }
4128     }
4129     break;
4130   }
4131   case EM_GETRECT:
4132   {
4133     *((RECT *)lParam) = editor->rcFormat;
4134     if (editor->bDefaultFormatRect)
4135       ((RECT *)lParam)->left -= editor->selofs;
4136     return 0;
4137   }
4138   case EM_SETRECT:
4139   case EM_SETRECTNP:
4140   {
4141     if (lParam)
4142     {
4143       DWORD exstyle = GetWindowLongW(editor->hWnd, GWL_EXSTYLE);
4144       int border = (exstyle & WS_EX_CLIENTEDGE) ? 1 : 0;
4145       RECT clientRect;
4146       RECT *rc = (RECT *)lParam;
4147
4148       GetClientRect(editor->hWnd, &clientRect);
4149       if (wParam == 0)
4150       {
4151         editor->rcFormat.top = max(0, rc->top - border);
4152         editor->rcFormat.left = max(0, rc->left - border);
4153         editor->rcFormat.bottom = min(clientRect.bottom, rc->bottom);
4154         editor->rcFormat.right = min(clientRect.right, rc->right + border);
4155       } else if (wParam == 1) {
4156         /* MSDN incorrectly says a wParam value of 1 causes the
4157          * lParam rect to be used as a relative offset,
4158          * however, the tests show it just prevents min/max bound
4159          * checking. */
4160         editor->rcFormat.top = rc->top - border;
4161         editor->rcFormat.left = rc->left - border;
4162         editor->rcFormat.bottom = rc->bottom;
4163         editor->rcFormat.right = rc->right + border;
4164       } else {
4165         return 0;
4166       }
4167       editor->bDefaultFormatRect = FALSE;
4168     }
4169     else
4170     {
4171       ME_SetDefaultFormatRect(editor);
4172       editor->bDefaultFormatRect = TRUE;
4173     }
4174     if (msg != EM_SETRECTNP)
4175       ME_RewrapRepaint(editor);
4176     return 0;
4177   }
4178   case EM_REQUESTRESIZE:
4179     ME_SendRequestResize(editor, TRUE);
4180     return 0;
4181   case WM_SETREDRAW:
4182     goto do_default;
4183   case WM_SIZE:
4184   {
4185     RECT clientRect;
4186
4187     GetClientRect(editor->hWnd, &clientRect);
4188     if (editor->bDefaultFormatRect) {
4189       ME_SetDefaultFormatRect(editor);
4190     } else {
4191       editor->rcFormat.right += clientRect.right - editor->prevClientRect.right;
4192       editor->rcFormat.bottom += clientRect.bottom - editor->prevClientRect.bottom;
4193     }
4194     editor->prevClientRect = clientRect;
4195     ME_RewrapRepaint(editor);
4196     goto do_default;
4197   }
4198   /* IME messages to make richedit controls IME aware */
4199   case WM_IME_SETCONTEXT:
4200   case WM_IME_CONTROL:
4201   case WM_IME_SELECT:
4202   case WM_IME_COMPOSITIONFULL:
4203     return 0;
4204   case WM_IME_STARTCOMPOSITION:
4205   {
4206     editor->imeStartIndex=ME_GetCursorOfs(editor,0);
4207     ME_DeleteSelection(editor);
4208     ME_CommitUndo(editor);
4209     ME_UpdateRepaint(editor);
4210     return 0;
4211   }
4212   case WM_IME_COMPOSITION:
4213   {
4214     HIMC hIMC;
4215
4216     ME_Style *style = ME_GetInsertStyle(editor, 0);
4217     hIMC = ImmGetContext(editor->hWnd);
4218     ME_DeleteSelection(editor);
4219     ME_CommitUndo(editor);
4220     ME_SaveTempStyle(editor);
4221     if (lParam & GCS_RESULTSTR)
4222     {
4223         LPWSTR lpCompStr = NULL;
4224         DWORD dwBufLen;
4225
4226         dwBufLen = ImmGetCompositionStringW(hIMC, GCS_RESULTSTR, NULL, 0);
4227         lpCompStr = HeapAlloc(GetProcessHeap(),0,dwBufLen + sizeof(WCHAR));
4228         ImmGetCompositionStringW(hIMC, GCS_RESULTSTR, lpCompStr, dwBufLen);
4229         lpCompStr[dwBufLen/sizeof(WCHAR)] = 0;
4230         ME_InsertTextFromCursor(editor,0,lpCompStr,dwBufLen/sizeof(WCHAR),style);
4231     }
4232     else if (lParam & GCS_COMPSTR)
4233     {
4234         LPWSTR lpCompStr = NULL;
4235         DWORD dwBufLen;
4236
4237         dwBufLen = ImmGetCompositionStringW(hIMC, GCS_COMPSTR, NULL, 0);
4238         lpCompStr = HeapAlloc(GetProcessHeap(),0,dwBufLen + sizeof(WCHAR));
4239         ImmGetCompositionStringW(hIMC, GCS_COMPSTR, lpCompStr, dwBufLen);
4240         lpCompStr[dwBufLen/sizeof(WCHAR)] = 0;
4241
4242         ME_InsertTextFromCursor(editor,0,lpCompStr,dwBufLen/sizeof(WCHAR),style);
4243         ME_SetSelection(editor,editor->imeStartIndex,
4244                         editor->imeStartIndex + dwBufLen/sizeof(WCHAR));
4245     }
4246     ME_ReleaseStyle(style);
4247     ME_UpdateRepaint(editor);
4248     return 0;
4249   }
4250   case WM_IME_ENDCOMPOSITION:
4251   {
4252     ME_DeleteSelection(editor);
4253     editor->imeStartIndex=-1;
4254     return 0;
4255   }
4256   case EM_GETOLEINTERFACE:
4257   {
4258     LPVOID *ppvObj = (LPVOID*) lParam;
4259     return CreateIRichEditOle(editor, ppvObj);
4260   }
4261   case EM_GETPASSWORDCHAR:
4262   {
4263     return editor->cPasswordMask;
4264   }
4265   case EM_SETOLECALLBACK:
4266     if(editor->lpOleCallback)
4267       IUnknown_Release(editor->lpOleCallback);
4268     editor->lpOleCallback = (LPRICHEDITOLECALLBACK)lParam;
4269     if(editor->lpOleCallback)
4270       IUnknown_AddRef(editor->lpOleCallback);
4271     return TRUE;
4272   case EM_GETWORDBREAKPROC:
4273     return (LRESULT)editor->pfnWordBreak;
4274   case EM_SETWORDBREAKPROC:
4275   {
4276     EDITWORDBREAKPROCW pfnOld = editor->pfnWordBreak;
4277
4278     editor->pfnWordBreak = (EDITWORDBREAKPROCW)lParam;
4279     return (LRESULT)pfnOld;
4280   }
4281   case EM_SETTEXTMODE:
4282   {
4283     LRESULT ret;
4284     int mask = 0;
4285     int changes = 0;
4286     GETTEXTLENGTHEX how;
4287
4288     /* CR/LF conversion required in 2.0 mode, verbatim in 1.0 mode */
4289     how.flags = GTL_CLOSE | (editor->bEmulateVersion10 ? 0 : GTL_USECRLF) | GTL_NUMCHARS;
4290     how.codepage = unicode ? 1200 : CP_ACP;
4291     ret = ME_GetTextLengthEx(editor, &how);
4292     if (!ret)
4293     {
4294       /*Check for valid wParam*/
4295       if ((((wParam & TM_RICHTEXT) && ((wParam & TM_PLAINTEXT) << 1))) ||
4296           (((wParam & TM_MULTILEVELUNDO) && ((wParam & TM_SINGLELEVELUNDO) << 1))) ||
4297           (((wParam & TM_MULTICODEPAGE) && ((wParam & TM_SINGLECODEPAGE) << 1))))
4298         return 1;
4299       else
4300       {
4301         if (wParam & (TM_RICHTEXT | TM_PLAINTEXT))
4302         {
4303           mask |= (TM_RICHTEXT | TM_PLAINTEXT);
4304           changes |= (wParam & (TM_RICHTEXT | TM_PLAINTEXT));
4305         }
4306         /*FIXME: Currently no support for undo level and code page options*/
4307         editor->mode = (editor->mode & (~mask)) | changes;
4308         return 0;
4309       }
4310     }
4311     return ret;
4312   }
4313   case EM_SETPASSWORDCHAR:
4314   {
4315     editor->cPasswordMask = wParam;
4316     ME_RewrapRepaint(editor);
4317     return 0;
4318   }
4319   case EM_SETTARGETDEVICE:
4320     if (wParam == 0)
4321     {
4322       BOOL new = (lParam == 0);
4323       if (editor->bWordWrap != new)
4324       {
4325         editor->bWordWrap = new;
4326         ME_RewrapRepaint(editor);
4327       }
4328     }
4329     else FIXME("Unsupported yet non NULL device in EM_SETTARGETDEVICE\n");
4330     break;
4331   default:
4332   do_default:
4333     *phresult = S_FALSE;
4334     break;
4335   }
4336   return 0L;
4337 }
4338
4339 static LRESULT RichEditWndProc_common(HWND hWnd, UINT msg, WPARAM wParam,
4340                                       LPARAM lParam, BOOL unicode)
4341 {
4342   ME_TextEditor *editor;
4343   HRESULT hresult;
4344   LRESULT lresult;
4345
4346   TRACE("enter hwnd %p msg %04x (%s) %lx %lx, unicode %d\n",
4347         hWnd, msg, get_msg_name(msg), wParam, lParam, unicode);
4348
4349   editor = (ME_TextEditor *)GetWindowLongPtrW(hWnd, 0);
4350   if (!editor)
4351   {
4352     if (msg == WM_NCCREATE)
4353     {
4354       CREATESTRUCTW *pcs = (CREATESTRUCTW *)lParam;
4355       TRACE("WM_NCCREATE: hWnd %p style 0x%08x\n", hWnd, pcs->style);
4356       editor = ME_MakeEditor(hWnd, FALSE);
4357       SetWindowLongPtrW(hWnd, 0, (LONG_PTR)editor);
4358       return TRUE;
4359     }
4360     else if (msg != WM_NCDESTROY)
4361     {
4362       ERR("called with invalid hWnd %p - application bug?\n", hWnd);
4363       return 0;
4364     }
4365   }
4366
4367   lresult = ME_HandleMessage(editor, msg, wParam, lParam, unicode, &hresult);
4368
4369   if (hresult == S_FALSE)
4370     lresult = DefWindowProcW(hWnd, msg, wParam, lParam);
4371
4372   TRACE("exit hwnd %p msg %04x (%s) %lx %lx, unicode %d -> %lu\n",
4373         hWnd, msg, get_msg_name(msg), wParam, lParam, unicode, lresult);
4374
4375   return lresult;
4376 }
4377
4378 static LRESULT WINAPI RichEditWndProcW(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
4379 {
4380     BOOL unicode = TRUE;
4381
4382     /* Under Win9x RichEdit20W returns ANSI strings, see the tests. */
4383     if (msg == WM_GETTEXT && (GetVersion() & 0x80000000))
4384         unicode = FALSE;
4385
4386     return RichEditWndProc_common(hWnd, msg, wParam, lParam, unicode);
4387 }
4388
4389 static LRESULT WINAPI RichEditWndProcA(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
4390 {
4391     return RichEditWndProc_common(hWnd, msg, wParam, lParam, FALSE);
4392 }
4393
4394 /******************************************************************
4395  *        RichEditANSIWndProc (RICHED20.10)
4396  */
4397 LRESULT WINAPI RichEditANSIWndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
4398 {
4399     return RichEditWndProcA(hWnd, msg, wParam, lParam);
4400 }
4401
4402 /******************************************************************
4403  *        RichEdit10ANSIWndProc (RICHED20.9)
4404  */
4405 LRESULT WINAPI RichEdit10ANSIWndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
4406 {
4407   if (msg == WM_NCCREATE && !GetWindowLongPtrW(hWnd, 0))
4408   {
4409     ME_TextEditor *editor;
4410     CREATESTRUCTW *pcs = (CREATESTRUCTW *)lParam;
4411
4412     TRACE("WM_NCCREATE: hWnd %p style 0x%08x\n", hWnd, pcs->style);
4413     editor = ME_MakeEditor(hWnd, TRUE);
4414     SetWindowLongPtrW(hWnd, 0, (LONG_PTR)editor);
4415     return TRUE;
4416   }
4417   return RichEditANSIWndProc(hWnd, msg, wParam, lParam);
4418 }
4419
4420 void ME_SendOldNotify(ME_TextEditor *editor, int nCode)
4421 {
4422   HWND hWnd = editor->hWnd;
4423   SendMessageA(GetParent(hWnd), WM_COMMAND, MAKEWPARAM(GetWindowLongW(hWnd, GWLP_ID), nCode), (LPARAM)hWnd);
4424 }
4425
4426 int ME_CountParagraphsBetween(ME_TextEditor *editor, int from, int to)
4427 {
4428   ME_DisplayItem *item = ME_FindItemFwd(editor->pBuffer->pFirst, diParagraph);
4429   int i = 0;
4430
4431   while(item && item->member.para.next_para->member.para.nCharOfs <= from)
4432     item = item->member.para.next_para;
4433   if (!item)
4434     return 0;
4435   while(item && item->member.para.next_para->member.para.nCharOfs <= to) {
4436     item = item->member.para.next_para;
4437     i++;
4438   }
4439   return i;
4440 }
4441
4442
4443 int ME_GetTextW(ME_TextEditor *editor, WCHAR *buffer, int nStart, int nChars, int bCRLF)
4444 {
4445   ME_DisplayItem *item = ME_FindItemAtOffset(editor, diRun, nStart, &nStart);
4446   int nWritten = 0;
4447   WCHAR *pStart = buffer;
4448
4449   if (!item) {
4450     *buffer = 0;
4451     return 0;
4452   }
4453
4454   /* bCRLF flag is only honored in 2.0 and up. 1.0 must always return text verbatim */
4455   if (editor->bEmulateVersion10) bCRLF = 0;
4456
4457   if (nStart)
4458   {
4459     int nLen = ME_StrLen(item->member.run.strText) - nStart;
4460     if (nLen > nChars)
4461       nLen = nChars;
4462     CopyMemory(buffer, item->member.run.strText->szData + nStart, sizeof(WCHAR)*nLen);
4463     nChars -= nLen;
4464     nWritten += nLen;
4465     buffer += nLen;
4466     if (!nChars) {
4467       *buffer = 0;
4468       return nWritten;
4469     }
4470     nStart = 0;
4471     item = ME_FindItemFwd(item, diRun);
4472   }
4473
4474   while(nChars && item)
4475   {
4476     int nLen = ME_StrLen(item->member.run.strText);
4477     if (item->member.run.nFlags & MERF_ENDPARA)
4478        nLen = item->member.run.nCR + item->member.run.nLF;
4479     if (nLen > nChars)
4480       nLen = nChars;
4481
4482     if (item->member.run.nFlags & MERF_ENDCELL &&
4483         item->member.run.nFlags & MERF_ENDPARA)
4484     {
4485       *buffer = '\t';
4486     }
4487     else if (item->member.run.nFlags & MERF_ENDPARA)
4488     {
4489       if (!ME_FindItemFwd(item, diRun))
4490         /* No '\r' is appended to the last paragraph. */
4491         nLen = 0;
4492       else if (bCRLF && nChars == 1) {
4493         nLen = 0;
4494         nChars = 0;
4495       } else {
4496         if (bCRLF)
4497         {
4498           /* richedit 2.0 case - actual line-break is \r but should report \r\n */
4499           if (ME_GetParagraph(item)->member.para.nFlags & (MEPF_ROWSTART|MEPF_ROWEND))
4500             assert(nLen == 2);
4501           else
4502             assert(nLen == 1);
4503           *buffer++ = '\r';
4504           *buffer = '\n'; /* Later updated by nLen==1 at the end of the loop */
4505           if (nLen == 1)
4506             nWritten++;
4507           else
4508             buffer--;
4509         }
4510         else
4511         {
4512           int i, j;
4513
4514           /* richedit 2.0 verbatim has only \r. richedit 1.0 should honor encodings */
4515           i = 0;
4516           while (nChars - i > 0 && i < item->member.run.nCR)
4517           {
4518             buffer[i] = '\r'; i++;
4519           }
4520           j = 0;
4521           while (nChars - i - j > 0 && j < item->member.run.nLF)
4522           {
4523             buffer[i+j] = '\n'; j++;
4524           }
4525         }
4526       }
4527     }
4528     else
4529       CopyMemory(buffer, item->member.run.strText->szData, sizeof(WCHAR)*nLen);
4530     nChars -= nLen;
4531     nWritten += nLen;
4532     buffer += nLen;
4533
4534     if (!nChars)
4535     {
4536       TRACE("nWritten=%d, actual=%d\n", nWritten, buffer-pStart);
4537       *buffer = 0;
4538       return nWritten;
4539     }
4540     item = ME_FindItemFwd(item, diRun);
4541   }
4542   *buffer = 0;
4543   TRACE("nWritten=%d, actual=%d\n", nWritten, buffer-pStart);
4544   return nWritten;
4545 }
4546
4547 static BOOL ME_RegisterEditorClass(HINSTANCE hInstance)
4548 {
4549   WNDCLASSW wcW;
4550   WNDCLASSA wcA;
4551
4552   wcW.style = CS_DBLCLKS | CS_HREDRAW | CS_VREDRAW | CS_GLOBALCLASS;
4553   wcW.lpfnWndProc = RichEditWndProcW;
4554   wcW.cbClsExtra = 0;
4555   wcW.cbWndExtra = sizeof(ME_TextEditor *);
4556   wcW.hInstance = NULL; /* hInstance would register DLL-local class */
4557   wcW.hIcon = NULL;
4558   wcW.hCursor = LoadCursorW(NULL, MAKEINTRESOURCEW(IDC_IBEAM));
4559   wcW.hbrBackground = GetStockObject(NULL_BRUSH);
4560   wcW.lpszMenuName = NULL;
4561
4562   if (is_version_nt())
4563   {
4564     wcW.lpszClassName = RichEdit20W;
4565     if (!RegisterClassW(&wcW)) return FALSE;
4566     wcW.lpszClassName = RichEdit50W;
4567     if (!RegisterClassW(&wcW)) return FALSE;
4568   }
4569   else
4570   {
4571     /* WNDCLASSA/W have the same layout */
4572     wcW.lpszClassName = (LPCWSTR)"RichEdit20W";
4573     if (!RegisterClassA((WNDCLASSA *)&wcW)) return FALSE;
4574     wcW.lpszClassName = (LPCWSTR)"RichEdit50W";
4575     if (!RegisterClassA((WNDCLASSA *)&wcW)) return FALSE;
4576   }
4577
4578   wcA.style = CS_DBLCLKS | CS_HREDRAW | CS_VREDRAW | CS_GLOBALCLASS;
4579   wcA.lpfnWndProc = RichEditWndProcA;
4580   wcA.cbClsExtra = 0;
4581   wcA.cbWndExtra = sizeof(ME_TextEditor *);
4582   wcA.hInstance = NULL; /* hInstance would register DLL-local class */
4583   wcA.hIcon = NULL;
4584   wcA.hCursor = LoadCursorW(NULL, MAKEINTRESOURCEW(IDC_IBEAM));
4585   wcA.hbrBackground = GetStockObject(NULL_BRUSH);
4586   wcA.lpszMenuName = NULL;
4587   wcA.lpszClassName = "RichEdit20A";
4588   if (!RegisterClassA(&wcA)) return FALSE;
4589   wcA.lpszClassName = "RichEdit50A";
4590   if (!RegisterClassA(&wcA)) return FALSE;
4591
4592   return TRUE;
4593 }
4594
4595 LRESULT WINAPI REComboWndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam) {
4596   /* FIXME: Not implemented */
4597   TRACE("hWnd %p msg %04x (%s) %08lx %08lx\n",
4598         hWnd, msg, get_msg_name(msg), wParam, lParam);
4599   return DefWindowProcW(hWnd, msg, wParam, lParam);
4600 }
4601
4602 LRESULT WINAPI REListWndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam) {
4603   /* FIXME: Not implemented */
4604   TRACE("hWnd %p msg %04x (%s) %08lx %08lx\n",
4605         hWnd, msg, get_msg_name(msg), wParam, lParam);
4606   return DefWindowProcW(hWnd, msg, wParam, lParam);
4607 }
4608
4609 /******************************************************************
4610  *        REExtendedRegisterClass (RICHED20.8)
4611  *
4612  * FIXME undocumented
4613  * Need to check for errors and implement controls and callbacks
4614  */
4615 LRESULT WINAPI REExtendedRegisterClass(void)
4616 {
4617   WNDCLASSW wcW;
4618   UINT result;
4619
4620   FIXME("semi stub\n");
4621
4622   wcW.cbClsExtra = 0;
4623   wcW.cbWndExtra = 4;
4624   wcW.hInstance = NULL;
4625   wcW.hIcon = NULL;
4626   wcW.hCursor = NULL;
4627   wcW.hbrBackground = (HBRUSH)(COLOR_WINDOW+1);
4628   wcW.lpszMenuName = NULL;
4629
4630   if (!ME_ListBoxRegistered)
4631   {
4632       wcW.style = CS_PARENTDC | CS_DBLCLKS | CS_GLOBALCLASS;
4633       wcW.lpfnWndProc = REListWndProc;
4634       wcW.lpszClassName = REListBox20W;
4635       if (RegisterClassW(&wcW)) ME_ListBoxRegistered = TRUE;
4636   }
4637
4638   if (!ME_ComboBoxRegistered)
4639   {
4640       wcW.style = CS_PARENTDC | CS_DBLCLKS | CS_GLOBALCLASS | CS_VREDRAW | CS_HREDRAW;
4641       wcW.lpfnWndProc = REComboWndProc;
4642       wcW.lpszClassName = REComboBox20W;
4643       if (RegisterClassW(&wcW)) ME_ComboBoxRegistered = TRUE;
4644   }
4645
4646   result = 0;
4647   if (ME_ListBoxRegistered)
4648       result += 1;
4649   if (ME_ComboBoxRegistered)
4650       result += 2;
4651
4652   return result;
4653 }
4654
4655 static BOOL isurlspecial(WCHAR c)
4656 {
4657   static const WCHAR special_chars[] = {'.','/','%','@','*','|','\\','+','#',0};
4658   return strchrW( special_chars, c ) != NULL;
4659 }
4660
4661 /**
4662  * This proc takes a selection, and scans it forward in order to select the span
4663  * of a possible URL candidate. A possible URL candidate must start with isalnum
4664  * or one of the following special characters: *|/\+%#@ and must consist entirely
4665  * of the characters allowed to start the URL, plus : (colon) which may occur
4666  * at most once, and not at either end.
4667  *
4668  * sel_max == -1 indicates scan to end of text.
4669  */
4670 static BOOL ME_FindNextURLCandidate(ME_TextEditor *editor, int sel_min, int sel_max,
4671         int * candidate_min, int * candidate_max)
4672 {
4673   ME_DisplayItem * item;
4674   ME_DisplayItem * para;
4675   int nStart;
4676   BOOL foundColon = FALSE;
4677   WCHAR lastAcceptedChar = '\0';
4678
4679   TRACE("sel_min = %d sel_max = %d\n", sel_min, sel_max);
4680
4681   *candidate_min = *candidate_max = -1;
4682   item = ME_FindItemAtOffset(editor, diRun, sel_min, &nStart);
4683   if (!item) return FALSE;
4684   TRACE("nStart = %d\n", nStart);
4685   para = ME_GetParagraph(item);
4686   if (sel_max == -1) sel_max = ME_GetTextLength(editor);
4687   while (item && para->member.para.nCharOfs + item->member.run.nCharOfs + nStart < sel_max)
4688   {
4689     ME_DisplayItem * next_item;
4690
4691     if (!(item->member.run.nFlags & MERF_ENDPARA)) {
4692       /* Find start of candidate */
4693       if (*candidate_min == -1) {
4694         while (nStart < ME_StrLen(item->member.run.strText) &&
4695                 !(isalnumW(item->member.run.strText->szData[nStart]) ||
4696                   isurlspecial(item->member.run.strText->szData[nStart]))) {
4697           nStart++;
4698         }
4699         if (nStart < ME_StrLen(item->member.run.strText) &&
4700                 (isalnumW(item->member.run.strText->szData[nStart]) ||
4701                  isurlspecial(item->member.run.strText->szData[nStart]))) {
4702           *candidate_min = para->member.para.nCharOfs + item->member.run.nCharOfs + nStart;
4703           lastAcceptedChar = item->member.run.strText->szData[nStart];
4704           nStart++;
4705         }
4706       }
4707
4708       /* Find end of candidate */
4709       if (*candidate_min >= 0) {
4710         while (nStart < ME_StrLen(item->member.run.strText) &&
4711                 (isalnumW(item->member.run.strText->szData[nStart]) ||
4712                  isurlspecial(item->member.run.strText->szData[nStart]) ||
4713                  (!foundColon && item->member.run.strText->szData[nStart] == ':') )) {
4714           if (item->member.run.strText->szData[nStart] == ':') foundColon = TRUE;
4715           lastAcceptedChar = item->member.run.strText->szData[nStart];
4716           nStart++;
4717         }
4718         if (nStart < ME_StrLen(item->member.run.strText) &&
4719                 !(isalnumW(item->member.run.strText->szData[nStart]) ||
4720                  isurlspecial(item->member.run.strText->szData[nStart]) )) {
4721           *candidate_max = para->member.para.nCharOfs + item->member.run.nCharOfs + nStart;
4722           nStart++;
4723           if (lastAcceptedChar == ':') (*candidate_max)--;
4724           return TRUE;
4725         }
4726       }
4727     } else {
4728       /* End of paragraph: skip it if before candidate span, or terminates
4729          current active span */
4730       if (*candidate_min >= 0) {
4731         *candidate_max = para->member.para.nCharOfs + item->member.run.nCharOfs;
4732         if (lastAcceptedChar == ':') (*candidate_max)--;
4733         return TRUE;
4734       }
4735     }
4736
4737     /* Reaching this point means no span was found, so get next span */
4738     next_item = ME_FindItemFwd(item, diRun);
4739     if (!next_item) {
4740       if (*candidate_min >= 0) {
4741         /* There are no further runs, so take end of text as end of candidate */
4742         *candidate_max = para->member.para.nCharOfs + item->member.run.nCharOfs + nStart;
4743         if (lastAcceptedChar == ':') (*candidate_max)--;
4744         return TRUE;
4745       }
4746     }
4747     item = next_item;
4748     para = ME_GetParagraph(item);
4749     nStart = 0;
4750   }
4751
4752   if (item) {
4753     if (*candidate_min >= 0) {
4754       /* There are no further runs, so take end of text as end of candidate */
4755       *candidate_max = para->member.para.nCharOfs + item->member.run.nCharOfs + nStart;
4756       if (lastAcceptedChar == ':') (*candidate_max)--;
4757       return TRUE;
4758     }
4759   }
4760   return FALSE;
4761 }
4762
4763 /**
4764  * This proc evaluates the selection and returns TRUE if it can be considered an URL
4765  */
4766 static BOOL ME_IsCandidateAnURL(ME_TextEditor *editor, int sel_min, int sel_max)
4767 {
4768   struct prefix_s {
4769     const char *text;
4770     int length;
4771   } prefixes[12] = {
4772     /* Code below depends on these being in decreasing length order! */
4773     {"prospero:", 10},
4774     {"telnet:", 8},
4775     {"gopher:", 8},
4776     {"mailto:", 8},
4777     {"https:", 7},
4778     {"file:", 6},
4779     {"news:", 6},
4780     {"wais:", 6},
4781     {"nntp:", 6},
4782     {"http:", 5},
4783     {"www.", 5},
4784     {"ftp:", 5},
4785   };
4786   LPWSTR bufferW = NULL;
4787   WCHAR bufW[32];
4788   unsigned int i;
4789
4790   if (sel_max == -1) sel_max = ME_GetTextLength(editor);
4791   assert(sel_min <= sel_max);
4792   for (i = 0; i < sizeof(prefixes) / sizeof(struct prefix_s); i++)
4793   {
4794     if (sel_max - sel_min < prefixes[i].length) continue;
4795     if (bufferW == NULL) {
4796       bufferW = heap_alloc((sel_max - sel_min + 1) * sizeof(WCHAR));
4797     }
4798     ME_GetTextW(editor, bufferW, sel_min, min(sel_max - sel_min, lstrlenA(prefixes[i].text)), 0);
4799     MultiByteToWideChar(CP_ACP, 0, prefixes[i].text, -1, bufW, 32);
4800     if (!lstrcmpW(bufW, bufferW))
4801     {
4802       heap_free(bufferW);
4803       return TRUE;
4804     }
4805   }
4806   heap_free(bufferW);
4807   return FALSE;
4808 }
4809
4810 /**
4811  * This proc walks through the indicated selection and evaluates whether each
4812  * section identified by ME_FindNextURLCandidate and in-between sections have
4813  * their proper CFE_LINK attributes set or unset. If the CFE_LINK attribute is
4814  * not what it is supposed to be, this proc sets or unsets it as appropriate.
4815  *
4816  * Returns TRUE if at least one section was modified.
4817  */
4818 static BOOL ME_UpdateLinkAttribute(ME_TextEditor *editor, int sel_min, int sel_max)
4819 {
4820   BOOL modified = FALSE;
4821   int cMin, cMax;
4822
4823   if (sel_max == -1) sel_max = ME_GetTextLength(editor);
4824   do
4825   {
4826     int beforeURL[2];
4827     int inURL[2];
4828     CHARFORMAT2W link;
4829
4830     if (ME_FindNextURLCandidate(editor, sel_min, sel_max, &cMin, &cMax))
4831     {
4832       /* Section before candidate is not an URL */
4833       beforeURL[0] = sel_min;
4834       beforeURL[1] = cMin;
4835
4836       if (ME_IsCandidateAnURL(editor, cMin, cMax))
4837       {
4838         inURL[0] = cMin; inURL[1] = cMax;
4839       }
4840       else
4841       {
4842         beforeURL[1] = cMax;
4843         inURL[0] = inURL[1] = -1;
4844       }
4845       sel_min = cMax;
4846     }
4847     else
4848     {
4849       /* No more candidates until end of selection */
4850       beforeURL[0] = sel_min;
4851       beforeURL[1] = sel_max;
4852       inURL[0] = inURL[1] = -1;
4853       sel_min = sel_max;
4854     }
4855
4856     if (beforeURL[0] < beforeURL[1])
4857     {
4858       /* CFE_LINK effect should be consistently unset */
4859       link.cbSize = sizeof(link);
4860       ME_GetCharFormat(editor, beforeURL[0], beforeURL[1], &link);
4861       if (!(link.dwMask & CFM_LINK) || (link.dwEffects & CFE_LINK))
4862       {
4863         /* CFE_LINK must be unset from this range */
4864         memset(&link, 0, sizeof(CHARFORMAT2W));
4865         link.cbSize = sizeof(link);
4866         link.dwMask = CFM_LINK;
4867         link.dwEffects = 0;
4868         ME_SetCharFormat(editor, beforeURL[0], beforeURL[1] - beforeURL[0], &link);
4869         modified = TRUE;
4870       }
4871     }
4872     if (inURL[0] < inURL[1])
4873     {
4874       /* CFE_LINK effect should be consistently set */
4875       link.cbSize = sizeof(link);
4876       ME_GetCharFormat(editor, inURL[0], inURL[1], &link);
4877       if (!(link.dwMask & CFM_LINK) || !(link.dwEffects & CFE_LINK))
4878       {
4879         /* CFE_LINK must be set on this range */
4880         memset(&link, 0, sizeof(CHARFORMAT2W));
4881         link.cbSize = sizeof(link);
4882         link.dwMask = CFM_LINK;
4883         link.dwEffects = CFE_LINK;
4884         ME_SetCharFormat(editor, inURL[0], inURL[1] - inURL[0], &link);
4885         modified = TRUE;
4886       }
4887     }
4888   } while (sel_min < sel_max);
4889   return modified;
4890 }