?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
qmgr: Implement IEnumBackgroundCopyFiles_Next.
[wine.git] / dlls / riched20 / editor.c
blob6aa21a7de6e09ba4b94b7f2e134ce0c190871dba
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_SETLANGOPTIONS 2.0
103 - EM_SETLIMITTEXT
104 + EM_SETMODIFY (not sure if implementation is correct)
105 - EM_SETOLECALLBACK
106 + EM_SETOPTIONS (partially implemented)
107 - EM_SETPALETTE 2.0
108 + EM_SETPARAFORMAT
109 + EM_SETPASSWORDCHAR 2.0
110 - EM_SETPUNCTUATION 1.0asian
111 + EM_SETREADONLY no beep on modification attempt
112 + EM_SETRECT
113 + EM_SETRECTNP (EM_SETRECT without repainting)
114 + EM_SETSEL
115 + EM_SETSCROLLPOS 3.0
116 - EM_SETTABSTOPS 3.0
117 - EM_SETTARGETDEVICE
118 + EM_SETTEXTEX 3.0 (no rich text insertion handling, proper style?)
119 - EM_SETTEXTMODE 2.0
120 - EM_SETTYPOGRAPHYOPTIONS 3.0
121 + EM_SETUNDOLIMIT 2.0
122 + EM_SETWORDBREAKPROC (used only for word movement at the moment)
123 - EM_SETWORDBREAKPROCEX
124 - EM_SETWORDWRAPMODE 1.0asian
125 + EM_SETZOOM 3.0
126 + EM_SHOWSCROLLBAR 2.0
127 - EM_STOPGROUPTYPING 2.0
128 + EM_STREAMIN
129 + EM_STREAMOUT
130 + EM_UNDO
131 + WM_CHAR
132 + WM_CLEAR
133 + WM_COPY
134 + WM_CUT
135 + WM_GETDLGCODE (the current implementation is incomplete)
136 + WM_GETTEXT (ANSI&Unicode)
137 + WM_GETTEXTLENGTH (ANSI version sucks)
138 + WM_PASTE
139 + WM_SETFONT
140 + WM_SETTEXT (resets undo stack !) (proper style?) ANSI&Unicode
141 - WM_STYLECHANGING
142 - WM_STYLECHANGED (things like read-only flag)
143 - WM_UNICHAR
144
145 Notifications
146
147 * EN_CHANGE (sent from the wrong place)
148 - EN_CORRECTTEXT
149 - EN_DROPFILES
150 - EN_ERRSPACE
151 - EN_HSCROLL
152 - EN_IMECHANGE
153 + EN_KILLFOCUS
154 - EN_LINK
155 - EN_MAXTEXT
156 - EN_MSGFILTER
157 - EN_OLEOPFAILED
158 - EN_PROTECTED
159 + EN_REQUESTRESIZE
160 - EN_SAVECLIPBOARD
161 + EN_SELCHANGE
162 + EN_SETFOCUS
163 - EN_STOPNOUNDO
164 * EN_UPDATE (sent from the wrong place)
165 - EN_VSCROLL
166
167 Styles
168
169 - ES_AUTOHSCROLL
170 - ES_AUTOVSCROLL
171 - ES_CENTER
172 + ES_DISABLENOSCROLL (scrollbar is always visible)
173 - ES_EX_NOCALLOLEINIT
174 - ES_LEFT
175 - ES_MULTILINE (currently single line controls aren't supported)
176 - ES_NOIME
177 - ES_READONLY (I'm not sure if beeping is the proper behaviour)
178 - ES_RIGHT
179 - ES_SAVESEL
180 - ES_SELFIME
181 - ES_SUNKEN
182 - ES_VERTICAL
183 - ES_WANTRETURN (don't know how to do WM_GETDLGCODE part)
184 - WS_SETFONT
185 - WS_HSCROLL
186 + WS_VSCROLL
187 */
188
189 /*
190 * RICHED20 TODO (incomplete):
191 *
192 * - messages/styles/notifications listed above
193 * - Undo coalescing
194 * - add remaining CHARFORMAT/PARAFORMAT fields
195 * - right/center align should strip spaces from the beginning
196 * - pictures/OLE objects (not just smiling faces that lack API support ;-) )
197 * - COM interface (looks like a major pain in the TODO list)
198 * - calculate heights of pictures (half-done)
199 * - horizontal scrolling (not even started)
200 * - hysteresis during wrapping (related to scrollbars appearing/disappearing)
201 * - find/replace
202 * - how to implement EM_FORMATRANGE and EM_DISPLAYBAND ? (Mission Impossible)
203 * - italic caret with italic fonts
204 * - IME
205 * - most notifications aren't sent at all (the most important ones are)
206 * - when should EN_SELCHANGE be sent after text change ? (before/after EN_UPDATE?)
207 * - WM_SETTEXT may use wrong style (but I'm 80% sure it's OK)
208 * - EM_GETCHARFORMAT with SCF_SELECTION may not behave 100% like in original (but very close)
209 * - full justification
210 * - hyphenation
211 * - tables
212 * - ListBox & ComboBox not implemented
213 *
214 * Bugs that are probably fixed, but not so easy to verify:
215 * - EN_UPDATE/EN_CHANGE are handled very incorrectly (should be OK now)
216 * - undo for ME_JoinParagraphs doesn't store paragraph format ? (it does)
217 * - check/fix artificial EOL logic (bCursorAtEnd, hardly logical)
218 * - caret shouldn't be displayed when selection isn't empty
219 * - check refcounting in style management functions (looks perfect now, but no bugs is suspicious)
220 * - undo for setting default format (done, might be buggy)
221 * - styles might be not released properly (looks like they work like charm, but who knows?
222 *
223 */
224
225 #include "editor.h"
226 #include "commdlg.h"
227 #include "winreg.h"
228 #define NO_SHLWAPI_STREAM
229 #include "shlwapi.h"
230 #include "rtf.h"
231 #include "imm.h"
232 #include "res.h"
233
234 #define STACK_SIZE_DEFAULT 100
235 #define STACK_SIZE_MAX 1000
236
237 #define TEXT_LIMIT_DEFAULT 32767
238
239 WINE_DEFAULT_DEBUG_CHANNEL(richedit);
240
241 static BOOL ME_RegisterEditorClass(HINSTANCE);
242
243 static const WCHAR RichEdit20W[] = {'R', 'i', 'c', 'h', 'E', 'd', 'i', 't', '2', '0', 'W', 0};
244 static const WCHAR RichEdit50W[] = {'R', 'i', 'c', 'h', 'E', 'd', 'i', 't', '5', '0', 'W', 0};
245 static const WCHAR REListBox20W[] = {'R','E','L','i','s','t','B','o','x','2','0','W', 0};
246 static const WCHAR REComboBox20W[] = {'R','E','C','o','m','b','o','B','o','x','2','0','W', 0};
247 static HCURSOR hLeft;
248 static HCURSOR hBeam;
249
250 int me_debug = 0;
251 HANDLE me_heap = NULL;
252
253 static BOOL ME_ListBoxRegistered = FALSE;
254 static BOOL ME_ComboBoxRegistered = FALSE;
255
256 static inline int is_version_nt(void)
257 {
258 return !(GetVersion() & 0x80000000);
259 }
260
261 static ME_TextBuffer *ME_MakeText(void) {
262
263 ME_TextBuffer *buf = ALLOC_OBJ(ME_TextBuffer);
264
265 ME_DisplayItem *p1 = ME_MakeDI(diTextStart);
266 ME_DisplayItem *p2 = ME_MakeDI(diTextEnd);
267
268 p1->prev = NULL;
269 p1->next = p2;
270 p2->prev = p1;
271 p2->next = NULL;
272 p1->member.para.next_para = p2;
273 p2->member.para.prev_para = p1;
274 p2->member.para.nCharOfs = 0;
275
276 buf->pFirst = p1;
277 buf->pLast = p2;
278 buf->pCharStyle = NULL;
279
280 return buf;
281 }
282
283
284 static LRESULT ME_StreamInText(ME_TextEditor *editor, DWORD dwFormat, ME_InStream *stream, ME_Style *style)
285 {
286 WCHAR wszText[STREAMIN_BUFFER_SIZE+1];
287 WCHAR *pText;
288
289 TRACE("%08x %p\n", dwFormat, stream);
290
291 do {
292 long nWideChars = 0;
293
294 if (!stream->dwSize)
295 {
296 ME_StreamInFill(stream);
297 if (stream->editstream->dwError)
298 break;
299 if (!stream->dwSize)
300 break;
301 }
302
303 if (!(dwFormat & SF_UNICODE))
304 {
305 /* FIXME? this is doomed to fail on true MBCS like UTF-8, luckily they're unlikely to be used as CP_ACP */
306 nWideChars = MultiByteToWideChar(CP_ACP, 0, stream->buffer, stream->dwSize, wszText, STREAMIN_BUFFER_SIZE);
307 pText = wszText;
308 }
309 else
310 {
311 nWideChars = stream->dwSize >> 1;
312 pText = (WCHAR *)stream->buffer;
313 }
314
315 ME_InsertTextFromCursor(editor, 0, pText, nWideChars, style);
316 if (stream->dwSize == 0)
317 break;
318 stream->dwSize = 0;
319 } while(1);
320 ME_CommitUndo(editor);
321 ME_UpdateRepaint(editor);
322 return 0;
323 }
324
325 static void ME_RTFCharAttrHook(RTF_Info *info)
326 {
327 CHARFORMAT2W fmt;
328 fmt.cbSize = sizeof(fmt);
329 fmt.dwMask = 0;
330 fmt.dwEffects = 0;
331
332 switch(info->rtfMinor)
333 {
334 case rtfPlain:
335 /* FIXME add more flags once they're implemented */
336 fmt.dwMask = CFM_BOLD | CFM_ITALIC | CFM_UNDERLINETYPE | CFM_STRIKEOUT | CFM_COLOR | CFM_BACKCOLOR | CFM_SIZE | CFM_WEIGHT;
337 fmt.dwEffects = CFE_AUTOCOLOR | CFE_AUTOBACKCOLOR;
338 fmt.yHeight = 12*20; /* 12pt */
339 fmt.wWeight = 400;
340 fmt.bUnderlineType = CFU_UNDERLINENONE;
341 break;
342 case rtfBold:
343 fmt.dwMask = CFM_BOLD;
344 fmt.dwEffects = info->rtfParam ? fmt.dwMask : 0;
345 break;
346 case rtfItalic:
347 fmt.dwMask = CFM_ITALIC;
348 fmt.dwEffects = info->rtfParam ? fmt.dwMask : 0;
349 break;
350 case rtfUnderline:
351 fmt.dwMask = CFM_UNDERLINETYPE;
352 fmt.bUnderlineType = info->rtfParam ? CFU_CF1UNDERLINE : CFU_UNDERLINENONE;
353 break;
354 case rtfDotUnderline:
355 fmt.dwMask = CFM_UNDERLINETYPE;
356 fmt.bUnderlineType = info->rtfParam ? CFU_UNDERLINEDOTTED : CFU_UNDERLINENONE;
357 break;
358 case rtfDbUnderline:
359 fmt.dwMask = CFM_UNDERLINETYPE;
360 fmt.bUnderlineType = info->rtfParam ? CFU_UNDERLINEDOUBLE : CFU_UNDERLINENONE;
361 break;
362 case rtfWordUnderline:
363 fmt.dwMask = CFM_UNDERLINETYPE;
364 fmt.bUnderlineType = info->rtfParam ? CFU_UNDERLINEWORD : CFU_UNDERLINENONE;
365 break;
366 case rtfNoUnderline:
367 fmt.dwMask = CFM_UNDERLINETYPE;
368 fmt.bUnderlineType = CFU_UNDERLINENONE;
369 break;
370 case rtfStrikeThru:
371 fmt.dwMask = CFM_STRIKEOUT;
372 fmt.dwEffects = info->rtfParam ? fmt.dwMask : 0;
373 break;
374 case rtfSubScript:
375 case rtfSuperScript:
376 case rtfSubScrShrink:
377 case rtfSuperScrShrink:
378 case rtfNoSuperSub:
379 fmt.dwMask = CFM_SUBSCRIPT|CFM_SUPERSCRIPT;
380 if (info->rtfMinor == rtfSubScrShrink) fmt.dwEffects = CFE_SUBSCRIPT;
381 if (info->rtfMinor == rtfSuperScrShrink) fmt.dwEffects = CFE_SUPERSCRIPT;
382 if (info->rtfMinor == rtfNoSuperSub) fmt.dwEffects = 0;
383 break;
384 case rtfInvisible:
385 fmt.dwMask = CFM_HIDDEN;
386 fmt.dwEffects = info->rtfParam ? fmt.dwMask : 0;
387 break;
388 case rtfBackColor:
389 fmt.dwMask = CFM_BACKCOLOR;
390 fmt.dwEffects = 0;
391 if (info->rtfParam == 0)
392 fmt.dwEffects = CFE_AUTOBACKCOLOR;
393 else if (info->rtfParam != rtfNoParam)
394 {
395 RTFColor *c = RTFGetColor(info, info->rtfParam);
396 fmt.crTextColor = (c->rtfCBlue<<16)|(c->rtfCGreen<<8)|(c->rtfCRed);
397 }
398 break;
399 case rtfForeColor:
400 fmt.dwMask = CFM_COLOR;
401 fmt.dwEffects = 0;
402 if (info->rtfParam == 0)
403 fmt.dwEffects = CFE_AUTOCOLOR;
404 else if (info->rtfParam != rtfNoParam)
405 {
406 RTFColor *c = RTFGetColor(info, info->rtfParam);
407 if (c)
408 fmt.crTextColor = (c->rtfCBlue<<16)|(c->rtfCGreen<<8)|(c->rtfCRed);
409 else
410 fmt.crTextColor = 0;
411 }
412 break;
413 case rtfFontNum:
414 if (info->rtfParam != rtfNoParam)
415 {
416 RTFFont *f = RTFGetFont(info, info->rtfParam);
417 if (f)
418 {
419 MultiByteToWideChar(CP_ACP, 0, f->rtfFName, -1, fmt.szFaceName, sizeof(fmt.szFaceName)/sizeof(WCHAR));
420 fmt.szFaceName[sizeof(fmt.szFaceName)/sizeof(WCHAR)-1] = '\0';
421 fmt.bCharSet = f->rtfFCharSet;
422 fmt.dwMask = CFM_FACE | CFM_CHARSET;
423 fmt.bPitchAndFamily = DEFAULT_PITCH | FF_DONTCARE;
424 }
425 }
426 break;
427 case rtfFontSize:
428 fmt.dwMask = CFM_SIZE;
429 if (info->rtfParam != rtfNoParam)
430 fmt.yHeight = info->rtfParam*10;
431 break;
432 }
433 if (fmt.dwMask) {
434 ME_Style *style2;
435 RTFFlushOutputBuffer(info);
436 /* FIXME too slow ? how come ? */
437 style2 = ME_ApplyStyle(info->style, &fmt);
438 ME_ReleaseStyle(info->style);
439 info->style = style2;
440 info->styleChanged = TRUE;
441 }
442 }
443
444 /* FIXME this function doesn't get any information about context of the RTF tag, which is very bad,
445 the same tags mean different things in different contexts */
446 static void ME_RTFParAttrHook(RTF_Info *info)
447 {
448 PARAFORMAT2 fmt;
449 fmt.cbSize = sizeof(fmt);
450 fmt.dwMask = 0;
451
452 switch(info->rtfMinor)
453 {
454 case rtfParDef: /* restores default paragraph attributes */
455 fmt.dwMask = PFM_ALIGNMENT | PFM_TABSTOPS | PFM_OFFSET | PFM_STARTINDENT;
456 fmt.wAlignment = PFA_LEFT;
457 fmt.cTabCount = 0;
458 fmt.dxOffset = fmt.dxStartIndent = 0;
459 RTFFlushOutputBuffer(info);
460 ME_GetParagraph(info->editor->pCursors[0].pRun)->member.para.bTable = FALSE;
461 break;
462 case rtfInTable:
463 {
464 ME_DisplayItem *para;
465
466 RTFFlushOutputBuffer(info);
467 para = ME_GetParagraph(info->editor->pCursors[0].pRun);
468 assert(para->member.para.pCells);
469 para->member.para.bTable = TRUE;
470 return;
471 }
472 case rtfFirstIndent:
473 ME_GetSelectionParaFormat(info->editor, &fmt);
474 fmt.dwMask = PFM_STARTINDENT | PFM_OFFSET;
475 fmt.dxStartIndent += info->rtfParam + fmt.dxOffset;
476 fmt.dxOffset = -info->rtfParam;
477 break;
478 case rtfLeftIndent:
479 ME_GetSelectionParaFormat(info->editor, &fmt);
480 fmt.dwMask = PFM_STARTINDENT;
481 fmt.dxStartIndent = -fmt.dxOffset + info->rtfParam;
482 break;
483 case rtfRightIndent:
484 fmt.dwMask = PFM_RIGHTINDENT;
485 fmt.dxRightIndent = info->rtfParam;
486 break;
487 case rtfQuadLeft:
488 case rtfQuadJust:
489 fmt.dwMask = PFM_ALIGNMENT;
490 fmt.wAlignment = PFA_LEFT;
491 break;
492 case rtfQuadRight:
493 fmt.dwMask = PFM_ALIGNMENT;
494 fmt.wAlignment = PFA_RIGHT;
495 break;
496 case rtfQuadCenter:
497 fmt.dwMask = PFM_ALIGNMENT;
498 fmt.wAlignment = PFA_CENTER;
499 break;
500 case rtfTabPos:
501 ME_GetSelectionParaFormat(info->editor, &fmt);
502 if (!(fmt.dwMask & PFM_TABSTOPS))
503 {
504 fmt.dwMask |= PFM_TABSTOPS;
505 fmt.cTabCount = 0;
506 }
507 if (fmt.cTabCount < MAX_TAB_STOPS)
508 fmt.rgxTabs[fmt.cTabCount++] = info->rtfParam;
509 break;
510 case rtfKeep:
511 fmt.dwMask = PFM_KEEP;
512 fmt.wEffects = PFE_KEEP;
513 break;
514 case rtfNoWidowControl:
515 fmt.dwMask = PFM_NOWIDOWCONTROL;
516 fmt.wEffects = PFE_NOWIDOWCONTROL;
517 break;
518 case rtfKeepNext:
519 fmt.dwMask = PFM_KEEPNEXT;
520 fmt.wEffects = PFE_KEEPNEXT;
521 break;
522 case rtfSpaceAfter:
523 fmt.dwMask = PFM_SPACEAFTER;
524 fmt.dySpaceAfter = info->rtfParam;
525 break;
526 case rtfSpaceBefore:
527 fmt.dwMask = PFM_SPACEBEFORE;
528 fmt.dySpaceBefore = info->rtfParam;
529 break;
530 case rtfSpaceBetween:
531 fmt.dwMask = PFM_LINESPACING;
532 if ((int)info->rtfParam > 0)
533 {
534 fmt.dyLineSpacing = info->rtfParam;
535 fmt.bLineSpacingRule = 3;
536 }
537 else
538 {
539 fmt.dyLineSpacing = info->rtfParam;
540 fmt.bLineSpacingRule = 4;
541 }
542 case rtfSpaceMultiply:
543 fmt.dwMask = PFM_LINESPACING;
544 fmt.dyLineSpacing = info->rtfParam * 20;
545 fmt.bLineSpacingRule = 5;
546 break;
547 case rtfParBullet:
548 fmt.dwMask = PFM_NUMBERING;
549 fmt.wNumbering = PFN_BULLET;
550 break;
551 case rtfParSimple:
552 fmt.dwMask = PFM_NUMBERING;
553 fmt.wNumbering = 2; /* FIXME: MSDN says it's not used ?? */
554 break;
555 case rtfParNumDecimal:
556 fmt.dwMask = PFM_NUMBERING;
557 fmt.wNumbering = 2; /* FIXME: MSDN says it's not used ?? */
558 break;
559 case rtfParNumIndent:
560 fmt.dwMask = PFM_NUMBERINGTAB;
561 fmt.wNumberingTab = info->rtfParam;
562 break;
563 case rtfParNumStartAt:
564 fmt.dwMask = PFM_NUMBERINGSTART;
565 fmt.wNumberingStart = info->rtfParam;
566 break;
567 case rtfBorderLeft:
568 ME_GetSelectionParaFormat(info->editor, &fmt);
569 if (!(fmt.dwMask & PFM_BORDER))
570 {
571 fmt.dwMask |= PFM_BORDER;
572 fmt.wBorderSpace = 0;
573 fmt.wBorderWidth = 1;
574 fmt.wBorders = 0;
575 }
576 fmt.wBorders |= 1;
577 break;
578 case rtfBorderRight:
579 ME_GetSelectionParaFormat(info->editor, &fmt);
580 if (!(fmt.dwMask & PFM_BORDER))
581 {
582 fmt.dwMask |= PFM_BORDER;
583 fmt.wBorderSpace = 0;
584 fmt.wBorderWidth = 1;
585 fmt.wBorders = 0;
586 }
587 fmt.wBorders |= 2;
588 break;
589 case rtfBorderTop:
590 ME_GetSelectionParaFormat(info->editor, &fmt);
591 if (!(fmt.dwMask & PFM_BORDER))
592 {
593 fmt.dwMask |= PFM_BORDER;
594 fmt.wBorderSpace = 0;
595 fmt.wBorderWidth = 1;
596 fmt.wBorders = 0;
597 }
598 fmt.wBorders |= 4;
599 break;
600 case rtfBorderBottom:
601 ME_GetSelectionParaFormat(info->editor, &fmt);
602 if (!(fmt.dwMask & PFM_BORDER))
603 {
604 fmt.dwMask |= PFM_BORDER;
605 fmt.wBorderSpace = 0;
606 fmt.wBorderWidth = 1;
607 fmt.wBorders = 0;
608 }
609 fmt.wBorders |= 8;
610 break;
611 case rtfBorderSingle:
612 ME_GetSelectionParaFormat(info->editor, &fmt);
613 /* we assume that borders have been created before (RTF spec) */
614 fmt.wBorders &= ~0x70;
615 fmt.wBorders |= 1 << 8;
616 break;
617 case rtfBorderThick:
618 ME_GetSelectionParaFormat(info->editor, &fmt);
619 /* we assume that borders have been created before (RTF spec) */
620 fmt.wBorders &= ~0x70;
621 fmt.wBorders |= 2 << 8;
622 break;
623 case rtfBorderShadow:
624 ME_GetSelectionParaFormat(info->editor, &fmt);
625 /* we assume that borders have been created before (RTF spec) */
626 fmt.wBorders &= ~0x70;
627 fmt.wBorders |= 10 << 8;
628 break;
629 case rtfBorderDouble:
630 ME_GetSelectionParaFormat(info->editor, &fmt);
631 /* we assume that borders have been created before (RTF spec) */
632 fmt.wBorders &= ~0x70;
633 fmt.wBorders |= 7 << 8;
634 break;
635 case rtfBorderDot:
636 ME_GetSelectionParaFormat(info->editor, &fmt);
637 /* we assume that borders have been created before (RTF spec) */
638 fmt.wBorders &= ~0x70;
639 fmt.wBorders |= 11 << 8;
640 break;
641 case rtfBorderWidth:
642 ME_GetSelectionParaFormat(info->editor, &fmt);
643 /* we assume that borders have been created before (RTF spec) */
644 fmt.wBorders &= ~0x70;
645 fmt.wBorders |= ((info->rtfParam / 15) & 7) << 8;
646 break;
647 case rtfBorderSpace:
648 ME_GetSelectionParaFormat(info->editor, &fmt);
649 /* we assume that borders have been created before (RTF spec) */
650 fmt.wBorderSpace = info->rtfParam;
651 break;
652 }
653 if (fmt.dwMask) {
654 RTFFlushOutputBuffer(info);
655 /* FIXME too slow ? how come ?*/
656 ME_SetSelectionParaFormat(info->editor, &fmt);
657 }
658 }
659
660 static void ME_RTFTblAttrHook(RTF_Info *info)
661 {
662 ME_DisplayItem *para;
663
664 switch (info->rtfMinor)
665 {
666 case rtfRowDef:
667 RTFFlushOutputBuffer(info);
668 para = ME_GetParagraph(info->editor->pCursors[0].pRun);
669
670 /* Release possibly inherited cell definitions */
671 ME_DestroyTableCellList(para);
672
673 para->member.para.pCells = ALLOC_OBJ(ME_TableCell);
674 para->member.para.pCells->nRightBoundary = 0;
675 para->member.para.pCells->next = NULL;
676 para->member.para.pLastCell = para->member.para.pCells;
677 break;
678 case rtfCellPos:
679 RTFFlushOutputBuffer(info);
680 para = ME_GetParagraph(info->editor->pCursors[0].pRun);
681
682 if (para->member.para.pLastCell->nRightBoundary)
683 {
684 ME_TableCell *pCell = ALLOC_OBJ(ME_TableCell);
685
686 pCell->next = NULL;
687 para->member.para.pLastCell->next = pCell;
688 para->member.para.pLastCell = pCell;
689 }
690 para->member.para.pLastCell->nRightBoundary = info->rtfParam;
691 break;
692 }
693 }
694
695 static BOOL ME_RTFInsertOleObject(RTF_Info *info, HENHMETAFILE h, const SIZEL* sz)
696 {
697 LPOLEOBJECT lpObject = NULL;
698 LPSTORAGE lpStorage = NULL;
699 LPOLECLIENTSITE lpClientSite = NULL;
700 LPDATAOBJECT lpDataObject = NULL;
701 LPOLECACHE lpOleCache = NULL;
702 STGMEDIUM stgm;
703 FORMATETC fm;
704 CLSID clsid;
705 BOOL ret = FALSE;
706 DWORD conn;
707
708 stgm.tymed = TYMED_ENHMF;
709 stgm.u.hEnhMetaFile = h;
710 stgm.pUnkForRelease = NULL;
711
712 fm.cfFormat = CF_ENHMETAFILE;
713 fm.ptd = NULL;
714 fm.dwAspect = DVASPECT_CONTENT;
715 fm.lindex = -1;
716 fm.tymed = stgm.tymed;
717
718 if (!info->lpRichEditOle)
719 {
720 CreateIRichEditOle(info->editor, (VOID**)&info->lpRichEditOle);
721 }
722
723 if (OleCreateDefaultHandler(&CLSID_NULL, NULL, &IID_IOleObject, (void**)&lpObject) == S_OK &&
724 #if 0
725 /* FIXME: enable it when rich-edit properly implements this method */
726 IRichEditOle_GetClientSite(info->lpRichEditOle, &lpClientSite) == S_OK &&
727 IOleObject_SetClientSite(lpObject, lpClientSite) == S_OK &&
728 #endif
729 IOleObject_GetUserClassID(lpObject, &clsid) == S_OK &&
730 IOleObject_QueryInterface(lpObject, &IID_IOleCache, (void**)&lpOleCache) == S_OK &&
731 IOleCache_Cache(lpOleCache, &fm, 0, &conn) == S_OK &&
732 IOleObject_QueryInterface(lpObject, &IID_IDataObject, (void**)&lpDataObject) == S_OK &&
733 IDataObject_SetData(lpDataObject, &fm, &stgm, TRUE) == S_OK)
734 {
735 REOBJECT reobject;
736
737 reobject.cbStruct = sizeof(reobject);
738 reobject.cp = REO_CP_SELECTION;
739 reobject.clsid = clsid;
740 reobject.poleobj = lpObject;
741 reobject.pstg = lpStorage;
742 reobject.polesite = lpClientSite;
743 /* convert from twips to .01 mm */
744 reobject.sizel.cx = MulDiv(sz->cx, 254, 144);
745 reobject.sizel.cy = MulDiv(sz->cy, 254, 144);
746 reobject.dvaspect = DVASPECT_CONTENT;
747 reobject.dwFlags = 0; /* FIXME */
748 reobject.dwUser = 0;
749
750 /* FIXME: could be simpler */
751 ret = IRichEditOle_InsertObject(info->lpRichEditOle, &reobject) == S_OK;
752 }
753
754 if (lpObject) IOleObject_Release(lpObject);
755 if (lpClientSite) IOleClientSite_Release(lpClientSite);
756 if (lpStorage) IStorage_Release(lpStorage);
757 if (lpDataObject) IDataObject_Release(lpDataObject);
758 if (lpOleCache) IOleCache_Release(lpOleCache);
759
760 return ret;
761 }
762
763 static void ME_RTFReadPictGroup(RTF_Info *info)
764 {
765 SIZEL sz;
766 BYTE* buffer = NULL;
767 unsigned bufsz, bufidx;
768 BOOL flip;
769 BYTE val;
770 METAFILEPICT mfp;
771 HENHMETAFILE hemf;
772
773 RTFGetToken (info);
774 if (info->rtfClass == rtfEOF)
775 return;
776 mfp.mm = MM_TEXT;
777 /* fetch picture type */
778 if (RTFCheckMM (info, rtfPictAttr, rtfWinMetafile))
779 {
780 mfp.mm = info->rtfParam;
781 }
782 else
783 {
784 FIXME("%d %d\n", info->rtfMajor, info->rtfMinor);
785 goto skip_group;
786 }
787 sz.cx = sz.cy = 0;
788 /* fetch picture attributes */
789 for (;;)
790 {
791 RTFGetToken (info);
792 if (info->rtfClass == rtfEOF)
793 return;
794 if (info->rtfClass == rtfText)
795 break;
796 if (!RTFCheckCM (info, rtfControl, rtfPictAttr))
797 {
798 ERR("Expected picture attribute (%d %d)\n",
799 info->rtfClass, info->rtfMajor);
800 goto skip_group;
801 }
802 else if (RTFCheckMM (info, rtfPictAttr, rtfPicWid))
803 mfp.xExt = info->rtfParam;
804 else if (RTFCheckMM (info, rtfPictAttr, rtfPicHt))
805 mfp.yExt = info->rtfParam;
806 else if (RTFCheckMM (info, rtfPictAttr, rtfPicGoalWid))
807 sz.cx = info->rtfParam;
808 else if (RTFCheckMM (info, rtfPictAttr, rtfPicGoalHt))
809 sz.cy = info->rtfParam;
810 else
811 FIXME("Non supported attribute: %d %d %d\n", info->rtfClass, info->rtfMajor, info->rtfMinor);
812 }
813 /* fetch picture data */
814 bufsz = 1024;
815 bufidx = 0;
816 buffer = HeapAlloc(GetProcessHeap(), 0, bufsz);
817 val = info->rtfMajor;
818 for (flip = TRUE;; flip = !flip)
819 {
820 RTFGetToken (info);
821 if (info->rtfClass == rtfEOF)
822 {
823 HeapFree(GetProcessHeap(), 0, buffer);
824 return; /* Warn ?? */
825 }
826 if (RTFCheckCM(info, rtfGroup, rtfEndGroup))
827 break;
828 if (info->rtfClass != rtfText) goto skip_group;
829 if (flip)
830 {
831 if (bufidx >= bufsz &&
832 !(buffer = HeapReAlloc(GetProcessHeap(), 0, buffer, bufsz += 1024)))
833 goto skip_group;
834 buffer[bufidx++] = RTFCharToHex(val) * 16 + RTFCharToHex(info->rtfMajor);
835 }
836 else
837 val = info->rtfMajor;
838 }
839 if (flip) FIXME("wrong hex string\n");
840
841 if ((hemf = SetWinMetaFileBits(bufidx, buffer, NULL, &mfp)))
842 ME_RTFInsertOleObject(info, hemf, &sz);
843 HeapFree(GetProcessHeap(), 0, buffer);
844 RTFRouteToken (info); /* feed "}" back to router */
845 return;
846 skip_group:
847 HeapFree(GetProcessHeap(), 0, buffer);
848 RTFSkipGroup(info);
849 RTFRouteToken(info); /* feed "}" back to router */
850 }
851
852 /* for now, lookup the \result part and use it, whatever the object */
853 static void ME_RTFReadObjectGroup(RTF_Info *info)
854 {
855 for (;;)
856 {
857 RTFGetToken (info);
858 if (info->rtfClass == rtfEOF)
859 return;
860 if (RTFCheckCM(info, rtfGroup, rtfEndGroup))
861 break;
862 if (RTFCheckCM(info, rtfGroup, rtfBeginGroup))
863 {
864 RTFGetToken (info);
865 if (info->rtfClass == rtfEOF)
866 return;
867 if (RTFCheckCMM(info, rtfControl, rtfDestination, rtfObjResult))
868 {
869 int level = 1;
870
871 while (RTFGetToken (info) != rtfEOF)
872 {
873 if (info->rtfClass == rtfGroup)
874 {
875 if (info->rtfMajor == rtfBeginGroup) level++;
876 else if (info->rtfMajor == rtfEndGroup && --level < 0) break;
877 }
878 RTFRouteToken(info);
879 }
880 }
881 else RTFSkipGroup(info);
882 continue;
883 }
884 if (!RTFCheckCM (info, rtfControl, rtfObjAttr))
885 {
886 FIXME("Non supported attribute: %d %d %d\n", info->rtfClass, info->rtfMajor, info->rtfMinor);
887 return;
888 }
889 }
890 RTFRouteToken(info); /* feed "}" back to router */
891 }
892
893 static void ME_RTFReadHook(RTF_Info *info) {
894 switch(info->rtfClass)
895 {
896 case rtfGroup:
897 switch(info->rtfMajor)
898 {
899 case rtfBeginGroup:
900 if (info->stackTop < maxStack) {
901 memcpy(&info->stack[info->stackTop].fmt, &info->style->fmt, sizeof(CHARFORMAT2W));
902 info->stack[info->stackTop].codePage = info->codePage;
903 info->stack[info->stackTop].unicodeLength = info->unicodeLength;
904 }
905 info->stackTop++;
906 info->styleChanged = FALSE;
907 break;
908 case rtfEndGroup:
909 {
910 ME_Style *s;
911 RTFFlushOutputBuffer(info);
912 if (info->stackTop<=1) {
913 info->rtfClass = rtfEOF;
914 return;
915 }
916 info->stackTop--;
917 assert(info->stackTop >= 0);
918 if (info->styleChanged)
919 {
920 /* FIXME too slow ? how come ? */
921 s = ME_ApplyStyle(info->style, &info->stack[info->stackTop].fmt);
922 ME_ReleaseStyle(info->style);
923 info->style = s;
924 info->codePage = info->stack[info->stackTop].codePage;
925 info->unicodeLength = info->stack[info->stackTop].unicodeLength;
926 }
927 break;
928 }
929 }
930 break;
931 case rtfControl:
932 switch(info->rtfMajor)
933 {
934 case rtfCharAttr:
935 ME_RTFCharAttrHook(info);
936 break;
937 case rtfParAttr:
938 ME_RTFParAttrHook(info);
939 break;
940 case rtfTblAttr:
941 ME_RTFTblAttrHook(info);
942 break;
943 case rtfSpecialChar:
944 if (info->rtfMinor == rtfCell)
945 {
946 RTFFlushOutputBuffer(info);
947 ME_InsertTableCellFromCursor(info->editor, 0);
948 }
949 }
950 break;
951 }
952 }
953
954 void
955 ME_StreamInFill(ME_InStream *stream)
956 {
957 stream->editstream->dwError = stream->editstream->pfnCallback(stream->editstream->dwCookie,
958 (BYTE *)stream->buffer,
959 sizeof(stream->buffer),
960 (LONG *)&stream->dwSize);
961 stream->dwUsed = 0;
962 }
963
964 static LRESULT ME_StreamIn(ME_TextEditor *editor, DWORD format, EDITSTREAM *stream)
965 {
966 RTF_Info parser;
967 ME_Style *style;
968 int from, to, to2, nUndoMode;
969 int nEventMask = editor->nEventMask;
970 ME_InStream inStream;
971
972 TRACE("stream==%p hWnd==%p format==0x%X\n", stream, editor->hWnd, format);
973 editor->nEventMask = 0;
974
975 ME_GetSelection(editor, &from, &to);
976 if ((format & SFF_SELECTION) && (editor->mode & TM_RICHTEXT)) {
977 style = ME_GetSelectionInsertStyle(editor);
978
979 ME_InternalDeleteText(editor, from, to-from);
980 }
981 else {
982 style = editor->pBuffer->pDefaultStyle;
983 ME_AddRefStyle(style);
984 SendMessageA(editor->hWnd, EM_SETSEL, 0, 0);
985 ME_InternalDeleteText(editor, 0, ME_GetTextLength(editor));
986 from = to = 0;
987 ME_ClearTempStyle(editor);
988 /* FIXME restore default paragraph formatting ! */
989 }
990
991
992 /* Back up undo mode to a local variable */
993 nUndoMode = editor->nUndoMode;
994
995 /* Only create an undo if SFF_SELECTION is set */
996 if (!(format & SFF_SELECTION))
997 editor->nUndoMode = umIgnore;
998
999 inStream.editstream = stream;
1000 inStream.editstream->dwError = 0;
1001 inStream.dwSize = 0;
1002 inStream.dwUsed = 0;
1003
1004 if (format & SF_RTF)
1005 {
1006 /* Check if it's really RTF, and if it is not, use plain text */
1007 ME_StreamInFill(&inStream);
1008 if (!inStream.editstream->dwError)
1009 {
1010 if (strncmp(inStream.buffer, "{\\rtf", 5) && strncmp(inStream.buffer, "{\\urtf", 6))
1011 {
1012 format &= ~SF_RTF;
1013 format |= SF_TEXT;
1014 }
1015 }
1016 }
1017
1018 if (!inStream.editstream->dwError)
1019 {
1020 if (format & SF_RTF) {
1021 /* setup the RTF parser */
1022 memset(&parser, 0, sizeof parser);
1023 RTFSetEditStream(&parser, &inStream);
1024 parser.rtfFormat = format&(SF_TEXT|SF_RTF);
1025 parser.hwndEdit = editor->hWnd;
1026 parser.editor = editor;
1027 parser.style = style;
1028 WriterInit(&parser);
1029 RTFInit(&parser);
1030 RTFSetReadHook(&parser, ME_RTFReadHook);
1031 RTFSetDestinationCallback(&parser, rtfPict, ME_RTFReadPictGroup);
1032 RTFSetDestinationCallback(&parser, rtfObject, ME_RTFReadObjectGroup);
1033 BeginFile(&parser);
1034
1035 /* do the parsing */
1036 RTFRead(&parser);
1037 RTFFlushOutputBuffer(&parser);
1038 RTFDestroy(&parser);
1039 if (parser.lpRichEditOle)
1040 IRichEditOle_Release(parser.lpRichEditOle);
1041
1042 style = parser.style;
1043 }
1044 else if (format & SF_TEXT)
1045 ME_StreamInText(editor, format, &inStream, style);
1046 else
1047 ERR("EM_STREAMIN without SF_TEXT or SF_RTF\n");
1048 ME_GetSelection(editor, &to, &to2);
1049 /* put the cursor at the top */
1050 if (!(format & SFF_SELECTION))
1051 SendMessageA(editor->hWnd, EM_SETSEL, 0, 0);
1052 }
1053
1054 /* Restore saved undo mode */
1055 editor->nUndoMode = nUndoMode;
1056
1057 /* even if we didn't add an undo, we need to commit anything on the stack */
1058 ME_CommitUndo(editor);
1059
1060 /* If SFF_SELECTION isn't set, delete any undos from before we started too */
1061 if (!(format & SFF_SELECTION))
1062 ME_EmptyUndoStack(editor);
1063
1064 ME_ReleaseStyle(style);
1065 editor->nEventMask = nEventMask;
1066 if (editor->bRedraw)
1067 {
1068 ME_UpdateRepaint(editor);
1069 }
1070 if (!(format & SFF_SELECTION)) {
1071 ME_ClearTempStyle(editor);
1072 }
1073 ME_MoveCaret(editor);
1074 ME_SendSelChange(editor);
1075 ME_SendRequestResize(editor, FALSE);
1076
1077 return 0;
1078 }
1079
1080
1081 typedef struct tagME_RTFStringStreamStruct
1082 {
1083 char *string;
1084 int pos;
1085 int length;
1086 } ME_RTFStringStreamStruct;
1087
1088 static DWORD CALLBACK ME_ReadFromRTFString(DWORD_PTR dwCookie, LPBYTE lpBuff, LONG cb, LONG *pcb)
1089 {
1090 ME_RTFStringStreamStruct *pStruct = (ME_RTFStringStreamStruct *)dwCookie;
1091 int count;
1092
1093 count = min(cb, pStruct->length - pStruct->pos);
1094 memmove(lpBuff, pStruct->string + pStruct->pos, count);
1095 pStruct->pos += count;
1096 *pcb = count;
1097 return 0;
1098 }
1099
1100 static void
1101 ME_StreamInRTFString(ME_TextEditor *editor, BOOL selection, char *string)
1102 {
1103 EDITSTREAM es;
1104 ME_RTFStringStreamStruct data;
1105
1106 data.string = string;
1107 data.length = strlen(string);
1108 data.pos = 0;
1109 es.dwCookie = (DWORD)&data;
1110 es.pfnCallback = ME_ReadFromRTFString;
1111 ME_StreamIn(editor, SF_RTF | (selection ? SFF_SELECTION : 0), &es);
1112 }
1113
1114
1115 ME_DisplayItem *
1116 ME_FindItemAtOffset(ME_TextEditor *editor, ME_DIType nItemType, int nOffset, int *nItemOffset)
1117 {
1118 ME_DisplayItem *item = ME_FindItemFwd(editor->pBuffer->pFirst, diParagraph);
1119
1120 while (item && item->member.para.next_para->member.para.nCharOfs <= nOffset)
1121 item = ME_FindItemFwd(item, diParagraph);
1122
1123 if (!item)
1124 return item;
1125
1126 nOffset -= item->member.para.nCharOfs;
1127 if (nItemType == diParagraph) {
1128 if (nItemOffset)
1129 *nItemOffset = nOffset;
1130 return item;
1131 }
1132
1133 do {
1134 item = ME_FindItemFwd(item, diRun);
1135 } while (item && (item->member.run.nCharOfs + ME_StrLen(item->member.run.strText) <= nOffset));
1136 if (item) {
1137 nOffset -= item->member.run.nCharOfs;
1138 if (nItemOffset)
1139 *nItemOffset = nOffset;
1140 }
1141 return item;
1142 }
1143
1144
1145 static int
1146 ME_FindText(ME_TextEditor *editor, DWORD flags, const CHARRANGE *chrg, const WCHAR *text, CHARRANGE *chrgText)
1147 {
1148 const int nLen = lstrlenW(text);
1149 const int nTextLen = ME_GetTextLength(editor);
1150 int nStart, nEnd;
1151 int nMin, nMax;
1152 ME_DisplayItem *item;
1153 ME_DisplayItem *para;
1154 WCHAR wLastChar = ' ';
1155
1156 TRACE("flags==0x%08x, chrg->cpMin==%d, chrg->cpMax==%d text==%s\n",
1157 flags, chrg->cpMin, chrg->cpMax, debugstr_w(text));
1158
1159 if (flags & ~(FR_DOWN | FR_MATCHCASE | FR_WHOLEWORD))
1160 FIXME("Flags 0x%08x not implemented\n",
1161 flags & ~(FR_DOWN | FR_MATCHCASE | FR_WHOLEWORD));
1162
1163 nMin = chrg->cpMin;
1164 if (chrg->cpMax == -1)
1165 nMax = nTextLen;
1166 else
1167 nMax = chrg->cpMax > nTextLen ? nTextLen : chrg->cpMax;
1168
1169 /* when searching up, if cpMin < cpMax, then instead of searching
1170 * on [cpMin,cpMax], we search on [0,cpMin], otherwise, search on
1171 * [cpMax, cpMin]. The exception is when cpMax is -1, in which
1172 * case, it is always bigger than cpMin.
1173 */
1174 if (!(flags & FR_DOWN))
1175 {
1176 int nSwap = nMax;
1177
1178 nMax = nMin > nTextLen ? nTextLen : nMin;
1179 if (nMin < nSwap || chrg->cpMax == -1)
1180 nMin = 0;
1181 else
1182 nMin = nSwap;
1183 }
1184
1185 if (!nLen || nMin < 0 || nMax < 0 || nMax < nMin)
1186 {
1187 if (chrgText)
1188 chrgText->cpMin = chrgText->cpMax = -1;
1189 return -1;
1190 }
1191
1192 if (flags & FR_DOWN) /* Forward search */
1193 {
1194 /* If possible, find the character before where the search starts */
1195 if ((flags & FR_WHOLEWORD) && nMin)
1196 {
1197 nStart = nMin - 1;
1198 item = ME_FindItemAtOffset(editor, diRun, nStart, &nStart);
1199 if (!item)
1200 {
1201 if (chrgText)
1202 chrgText->cpMin = chrgText->cpMax = -1;
1203 return -1;
1204 }
1205 wLastChar = item->member.run.strText->szData[nStart];
1206 }
1207
1208 nStart = nMin;
1209 item = ME_FindItemAtOffset(editor, diRun, nStart, &nStart);
1210 if (!item)
1211 {
1212 if (chrgText)
1213 chrgText->cpMin = chrgText->cpMax = -1;
1214 return -1;
1215 }
1216
1217 para = ME_GetParagraph(item);
1218 while (item
1219 && para->member.para.nCharOfs + item->member.run.nCharOfs + nStart + nLen <= nMax)
1220 {
1221 ME_DisplayItem *pCurItem = item;
1222 int nCurStart = nStart;
1223 int nMatched = 0;
1224
1225 while (pCurItem && ME_CharCompare(pCurItem->member.run.strText->szData[nCurStart + nMatched], text[nMatched], (flags & FR_MATCHCASE)))
1226 {
1227 if ((flags & FR_WHOLEWORD) && isalnumW(wLastChar))
1228 break;
1229
1230 nMatched++;
1231 if (nMatched == nLen)
1232 {
1233 ME_DisplayItem *pNextItem = pCurItem;
1234 int nNextStart = nCurStart;
1235 WCHAR wNextChar;
1236
1237 /* Check to see if next character is a whitespace */
1238 if (flags & FR_WHOLEWORD)
1239 {
1240 if (nCurStart + nMatched == ME_StrLen(pCurItem->member.run.strText))
1241 {
1242 pNextItem = ME_FindItemFwd(pCurItem, diRun);
1243 nNextStart = -nMatched;
1244 }
1245
1246 if (pNextItem)
1247 wNextChar = pNextItem->member.run.strText->szData[nNextStart + nMatched];
1248 else
1249 wNextChar = ' ';
1250
1251 if (isalnumW(wNextChar))
1252 break;
1253 }
1254
1255 nStart += para->member.para.nCharOfs + pCurItem->member.run.nCharOfs;
1256 if (chrgText)
1257 {
1258 chrgText->cpMin = nStart;
1259 chrgText->cpMax = nStart + nLen;
1260 }
1261 TRACE("found at %d-%d\n", nStart, nStart + nLen);
1262 return nStart;
1263 }
1264 if (nCurStart + nMatched == ME_StrLen(pCurItem->member.run.strText))
1265 {
1266 pCurItem = ME_FindItemFwd(pCurItem, diRun);
1267 para = ME_GetParagraph(pCurItem);
1268 nCurStart = -nMatched;
1269 }
1270 }
1271 if (pCurItem)
1272 wLastChar = pCurItem->member.run.strText->szData[nCurStart + nMatched];
1273 else
1274 wLastChar = ' ';
1275
1276 nStart++;
1277 if (nStart == ME_StrLen(item->member.run.strText))
1278 {
1279 item = ME_FindItemFwd(item, diRun);
1280 para = ME_GetParagraph(item);
1281 nStart = 0;
1282 }
1283 }
1284 }
1285 else /* Backward search */
1286 {
1287 /* If possible, find the character after where the search ends */
1288 if ((flags & FR_WHOLEWORD) && nMax < nTextLen - 1)
1289 {
1290 nEnd = nMax + 1;
1291 item = ME_FindItemAtOffset(editor, diRun, nEnd, &nEnd);
1292 if (!item)
1293 {
1294 if (chrgText)
1295 chrgText->cpMin = chrgText->cpMax = -1;
1296 return -1;
1297 }
1298 wLastChar = item->member.run.strText->szData[nEnd];
1299 }
1300
1301 nEnd = nMax;
1302 item = ME_FindItemAtOffset(editor, diRun, nEnd, &nEnd);
1303 if (!item)
1304 {
1305 if (chrgText)
1306 chrgText->cpMin = chrgText->cpMax = -1;
1307 return -1;
1308 }
1309
1310 para = ME_GetParagraph(item);
1311
1312 while (item
1313 && para->member.para.nCharOfs + item->member.run.nCharOfs + nEnd - nLen >= nMin)
1314 {
1315 ME_DisplayItem *pCurItem = item;
1316 int nCurEnd = nEnd;
1317 int nMatched = 0;
1318
1319 if (nCurEnd - nMatched == 0)
1320 {
1321 pCurItem = ME_FindItemBack(pCurItem, diRun);
1322 para = ME_GetParagraph(pCurItem);
1323 nCurEnd = ME_StrLen(pCurItem->member.run.strText) + nMatched;
1324 }
1325
1326 while (pCurItem && ME_CharCompare(pCurItem->member.run.strText->szData[nCurEnd - nMatched - 1], text[nLen - nMatched - 1], (flags & FR_MATCHCASE)))
1327 {
1328 if ((flags & FR_WHOLEWORD) && isalnumW(wLastChar))
1329 break;
1330
1331 nMatched++;
1332 if (nMatched == nLen)
1333 {
1334 ME_DisplayItem *pPrevItem = pCurItem;
1335 int nPrevEnd = nCurEnd;
1336 WCHAR wPrevChar;
1337
1338 /* Check to see if previous character is a whitespace */
1339 if (flags & FR_WHOLEWORD)
1340 {
1341 if (nPrevEnd - nMatched == 0)
1342 {
1343 pPrevItem = ME_FindItemBack(pCurItem, diRun);
1344 if (pPrevItem)
1345 nPrevEnd = ME_StrLen(pPrevItem->member.run.strText) + nMatched;
1346 }
1347
1348 if (pPrevItem)
1349 wPrevChar = pPrevItem->member.run.strText->szData[nPrevEnd - nMatched - 1];
1350 else
1351 wPrevChar = ' ';
1352
1353 if (isalnumW(wPrevChar))
1354 break;
1355 }
1356
1357 nStart = para->member.para.nCharOfs + pCurItem->member.run.nCharOfs + nCurEnd - nMatched;
1358 if (chrgText)
1359 {
1360 chrgText->cpMin = nStart;
1361 chrgText->cpMax = nStart + nLen;
1362 }
1363 TRACE("found at %d-%d\n", nStart, nStart + nLen);
1364 return nStart;
1365 }
1366 if (nCurEnd - nMatched == 0)
1367 {
1368 pCurItem = ME_FindItemBack(pCurItem, diRun);
1369 /* Don't care about pCurItem becoming NULL here; it's already taken
1370 * care of in the exterior loop condition */
1371 para = ME_GetParagraph(pCurItem);
1372 nCurEnd = ME_StrLen(pCurItem->member.run.strText) + nMatched;
1373 }
1374 }
1375 if (pCurItem)
1376 wLastChar = pCurItem->member.run.strText->szData[nCurEnd - nMatched - 1];
1377 else
1378 wLastChar = ' ';
1379
1380 nEnd--;
1381 if (nEnd < 0)
1382 {
1383 item = ME_FindItemBack(item, diRun);
1384 para = ME_GetParagraph(item);
1385 nEnd = ME_StrLen(item->member.run.strText);
1386 }
1387 }
1388 }
1389 TRACE("not found\n");
1390 if (chrgText)
1391 chrgText->cpMin = chrgText->cpMax = -1;
1392 return -1;
1393 }
1394
1395 /* helper to send a msg filter notification */
1396 static BOOL
1397 ME_FilterEvent(ME_TextEditor *editor, UINT msg, WPARAM* wParam, LPARAM* lParam)
1398 {
1399 MSGFILTER msgf;
1400
1401 msgf.nmhdr.hwndFrom = editor->hWnd;
1402 msgf.nmhdr.idFrom = GetWindowLongW(editor->hWnd, GWLP_ID);
1403 msgf.nmhdr.code = EN_MSGFILTER;
1404 msgf.msg = msg;
1405
1406 msgf.wParam = *wParam;
1407 msgf.lParam = *lParam;
1408 if (SendMessageW(GetParent(editor->hWnd), WM_NOTIFY, msgf.nmhdr.idFrom, (LPARAM)&msgf))
1409 return FALSE;
1410 *wParam = msgf.wParam;
1411 *lParam = msgf.lParam;
1412 msgf.wParam = *wParam;
1413
1414 return TRUE;
1415 }
1416
1417 static BOOL
1418 ME_KeyDown(ME_TextEditor *editor, WORD nKey)
1419 {
1420 BOOL ctrl_is_down = GetKeyState(VK_CONTROL) & 0x8000;
1421 BOOL shift_is_down = GetKeyState(VK_SHIFT) & 0x8000;
1422
1423 switch (nKey)
1424 {
1425 case VK_LEFT:
1426 case VK_RIGHT:
1427 case VK_UP:
1428 case VK_DOWN:
1429 case VK_HOME:
1430 case VK_END:
1431 case VK_PRIOR:
1432 case VK_NEXT:
1433 ME_ArrowKey(editor, nKey, shift_is_down, ctrl_is_down);
1434 return TRUE;
1435 case VK_BACK:
1436 case VK_DELETE:
1437 /* FIXME backspace and delete aren't the same, they act different wrt paragraph style of the merged paragraph */
1438 if (GetWindowLongW(editor->hWnd, GWL_STYLE) & ES_READONLY)
1439 return FALSE;
1440 if (ME_IsSelection(editor))
1441 ME_DeleteSelection(editor);
1442 else if (nKey == VK_DELETE || ME_ArrowKey(editor, VK_LEFT, FALSE, FALSE))
1443 ME_DeleteTextAtCursor(editor, 1, 1);
1444 else
1445 return TRUE;
1446 ME_CommitUndo(editor);
1447 ME_UpdateRepaint(editor);
1448 ME_SendRequestResize(editor, FALSE);
1449 return TRUE;
1450
1451 default:
1452 if (ctrl_is_down)
1453 {
1454 if (nKey == 'W')
1455 {
1456 CHARFORMAT2W chf;
1457 char buf[2048];
1458 chf.cbSize = sizeof(chf);
1459
1460 ME_GetSelectionCharFormat(editor, &chf);
1461 ME_DumpStyleToBuf(&chf, buf);
1462 MessageBoxA(NULL, buf, "Style dump", MB_OK);
1463 }
1464 if (nKey == 'Q')
1465 {
1466 ME_CheckCharOffsets(editor);
1467 }
1468 }
1469 }
1470 return FALSE;
1471 }
1472
1473 static void ME_SetCursor(ME_TextEditor *editor, int x)
1474 {
1475 if (x < editor->selofs || editor->linesel)
1476 SetCursor(hLeft);
1477 else
1478 SetCursor(hBeam);
1479 }
1480
1481 static BOOL ME_ShowContextMenu(ME_TextEditor *editor, int x, int y)
1482 {
1483 CHARRANGE selrange;
1484 HMENU menu;
1485 int seltype = 0;
1486 if(!editor->lpOleCallback)
1487 return FALSE;
1488 ME_GetSelection(editor, &selrange.cpMin, &selrange.cpMax);
1489 if(selrange.cpMin == selrange.cpMax)
1490 seltype |= SEL_EMPTY;
1491 else
1492 {
1493 /* FIXME: Handle objects */
1494 seltype |= SEL_TEXT;
1495 if(selrange.cpMax-selrange.cpMin > 1)
1496 seltype |= SEL_MULTICHAR;
1497 }
1498 if(SUCCEEDED(IRichEditOleCallback_GetContextMenu(editor->lpOleCallback, seltype, NULL, &selrange, &menu)))
1499 {
1500 TrackPopupMenu(menu, TPM_LEFTALIGN | TPM_RIGHTBUTTON, x, y, 0, GetParent(editor->hWnd), NULL);
1501 DestroyMenu(menu);
1502 }
1503 return TRUE;
1504 }
1505
1506 ME_TextEditor *ME_MakeEditor(HWND hWnd) {
1507 ME_TextEditor *ed = ALLOC_OBJ(ME_TextEditor);
1508 int i;
1509 ed->hWnd = hWnd;
1510 ed->bEmulateVersion10 = FALSE;
1511 ed->pBuffer = ME_MakeText();
1512 ed->nZoomNumerator = ed->nZoomDenominator = 0;
1513 ME_MakeFirstParagraph(ed);
1514 ed->bCaretShown = FALSE;
1515 ed->nCursors = 4;
1516 ed->pCursors = ALLOC_N_OBJ(ME_Cursor, ed->nCursors);
1517 ed->pCursors[0].pRun = ME_FindItemFwd(ed->pBuffer->pFirst, diRun);
1518 ed->pCursors[0].nOffset = 0;
1519 ed->pCursors[1].pRun = ME_FindItemFwd(ed->pBuffer->pFirst, diRun);
1520 ed->pCursors[1].nOffset = 0;
1521 ed->pCursors[2] = ed->pCursors[0];
1522 ed->pCursors[3] = ed->pCursors[1];
1523 ed->nLastTotalLength = ed->nTotalLength = 0;
1524 ed->nHeight = 0;
1525 ed->nUDArrowX = -1;
1526 ed->nSequence = 0;
1527 ed->rgbBackColor = -1;
1528 ed->hbrBackground = GetSysColorBrush(COLOR_WINDOW);
1529 ed->bCaretAtEnd = FALSE;
1530 ed->nEventMask = 0;
1531 ed->nModifyStep = 0;
1532 ed->nTextLimit = TEXT_LIMIT_DEFAULT;
1533 ed->pUndoStack = ed->pRedoStack = ed->pUndoStackBottom = NULL;
1534 ed->nUndoStackSize = 0;
1535 ed->nUndoLimit = STACK_SIZE_DEFAULT;
1536 ed->nUndoMode = umAddToUndo;
1537 ed->nParagraphs = 1;
1538 ed->nLastSelStart = ed->nLastSelEnd = 0;
1539 ed->pLastSelStartPara = ed->pLastSelEndPara = ME_FindItemFwd(ed->pBuffer->pFirst, diParagraph);
1540 ed->bRedraw = TRUE;
1541 ed->bHideSelection = FALSE;
1542 ed->nInvalidOfs = -1;
1543 ed->pfnWordBreak = NULL;
1544 ed->lpOleCallback = NULL;
1545 ed->mode = TM_RICHTEXT | TM_MULTILEVELUNDO | TM_MULTICODEPAGE;
1546 ed->AutoURLDetect_bEnable = FALSE;
1547 ed->bHaveFocus = FALSE;
1548 GetClientRect(hWnd, &ed->rcFormat);
1549 for (i=0; i<HFONT_CACHE_SIZE; i++)
1550 {
1551 ed->pFontCache[i].nRefs = 0;
1552 ed->pFontCache[i].nAge = 0;
1553 ed->pFontCache[i].hFont = NULL;
1554 }
1555
1556 ME_CheckCharOffsets(ed);
1557 if (GetWindowLongW(hWnd, GWL_STYLE) & ES_SELECTIONBAR)
1558 ed->selofs = 16;
1559 else
1560 ed->selofs = 0;
1561 ed->linesel = 0;
1562
1563 if (GetWindowLongW(hWnd, GWL_STYLE) & ES_PASSWORD)
1564 ed->cPasswordMask = '*';
1565 else
1566 ed->cPasswordMask = 0;
1567
1568 return ed;
1569 }
1570
1571 typedef struct tagME_GlobalDestStruct
1572 {
1573 HGLOBAL hData;
1574 int nLength;
1575 } ME_GlobalDestStruct;
1576
1577 static DWORD CALLBACK ME_ReadFromHGLOBALUnicode(DWORD_PTR dwCookie, LPBYTE lpBuff, LONG cb, LONG *pcb)
1578 {
1579 ME_GlobalDestStruct *pData = (ME_GlobalDestStruct *)dwCookie;
1580 int i;
1581 WORD *pSrc, *pDest;
1582
1583 cb = cb >> 1;
1584 pDest = (WORD *)lpBuff;
1585 pSrc = (WORD *)GlobalLock(pData->hData);
1586 for (i = 0; i<cb && pSrc[pData->nLength+i]; i++) {
1587 pDest[i] = pSrc[pData->nLength+i];
1588 }
1589 pData->nLength += i;
1590 *pcb = 2*i;
1591 GlobalUnlock(pData->hData);
1592 return 0;
1593 }
1594
1595 static DWORD CALLBACK ME_ReadFromHGLOBALRTF(DWORD_PTR dwCookie, LPBYTE lpBuff, LONG cb, LONG *pcb)
1596 {
1597 ME_GlobalDestStruct *pData = (ME_GlobalDestStruct *)dwCookie;
1598 int i;
1599 BYTE *pSrc, *pDest;
1600
1601 pDest = lpBuff;
1602 pSrc = (BYTE *)GlobalLock(pData->hData);
1603 for (i = 0; i<cb && pSrc[pData->nLength+i]; i++) {
1604 pDest[i] = pSrc[pData->nLength+i];
1605 }
1606 pData->nLength += i;
1607 *pcb = i;
1608 GlobalUnlock(pData->hData);
1609 return 0;
1610 }
1611
1612
1613 void ME_DestroyEditor(ME_TextEditor *editor)
1614 {
1615 ME_DisplayItem *pFirst = editor->pBuffer->pFirst;
1616 ME_DisplayItem *p = pFirst, *pNext = NULL;
1617 int i;
1618
1619 ME_ClearTempStyle(editor);
1620 ME_EmptyUndoStack(editor);
1621 while(p) {
1622 pNext = p->next;
1623 ME_DestroyDisplayItem(p);
1624 p = pNext;
1625 }
1626 ME_ReleaseStyle(editor->pBuffer->pDefaultStyle);
1627 for (i=0; i<HFONT_CACHE_SIZE; i++)
1628 {
1629 if (editor->pFontCache[i].hFont)
1630 DeleteObject(editor->pFontCache[i].hFont);
1631 }
1632 if (editor->rgbBackColor != -1)
1633 DeleteObject(editor->hbrBackground);
1634 if(editor->lpOleCallback)
1635 IUnknown_Release(editor->lpOleCallback);
1636
1637 FREE_OBJ(editor->pBuffer);
1638 FREE_OBJ(editor->pCursors);
1639
1640 FREE_OBJ(editor);
1641 }
1642
1643 BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
1644 {
1645 TRACE("\n");
1646 switch (fdwReason)
1647 {
1648 case DLL_PROCESS_ATTACH:
1649 DisableThreadLibraryCalls(hinstDLL);
1650 me_heap = HeapCreate (0, 0x10000, 0);
1651 if (!ME_RegisterEditorClass(hinstDLL)) return FALSE;
1652 hLeft = LoadCursorW(hinstDLL, MAKEINTRESOURCEW(OCR_REVERSE));
1653 hBeam = LoadCursorW(NULL, MAKEINTRESOURCEW(IDC_IBEAM));
1654 LookupInit();
1655 break;
1656
1657 case DLL_PROCESS_DETACH:
1658 UnregisterClassW(RichEdit20W, 0);
1659 UnregisterClassW(RichEdit50W, 0);
1660 UnregisterClassA("RichEdit20A", 0);
1661 UnregisterClassA("RichEdit50A", 0);
1662 if (ME_ListBoxRegistered)
1663 UnregisterClassW(REListBox20W, 0);
1664 if (ME_ComboBoxRegistered)
1665 UnregisterClassW(REComboBox20W, 0);
1666 LookupCleanup();
1667 HeapDestroy (me_heap);
1668 me_heap = NULL;
1669 break;
1670 }
1671 return TRUE;
1672 }
1673
1674
1675 #define UNSUPPORTED_MSG(e) \
1676 case e: \
1677 FIXME(#e ": stub\n"); \
1678 return DefWindowProcW(hWnd, msg, wParam, lParam);
1679
1680 static const char * const edit_messages[] = {
1681 "EM_GETSEL",
1682 "EM_SETSEL",
1683 "EM_GETRECT",
1684 "EM_SETRECT",
1685 "EM_SETRECTNP",
1686 "EM_SCROLL",
1687 "EM_LINESCROLL",
1688 "EM_SCROLLCARET",
1689 "EM_GETMODIFY",
1690 "EM_SETMODIFY",
1691 "EM_GETLINECOUNT",
1692 "EM_LINEINDEX",
1693 "EM_SETHANDLE",
1694 "EM_GETHANDLE",
1695 "EM_GETTHUMB",
1696 "EM_UNKNOWN_BF",
1697 "EM_UNKNOWN_C0",
1698 "EM_LINELENGTH",
1699 "EM_REPLACESEL",
1700 "EM_UNKNOWN_C3",
1701 "EM_GETLINE",
1702 "EM_LIMITTEXT",
1703 "EM_CANUNDO",
1704 "EM_UNDO",
1705 "EM_FMTLINES",
1706 "EM_LINEFROMCHAR",
1707 "EM_UNKNOWN_CA",
1708 "EM_SETTABSTOPS",
1709 "EM_SETPASSWORDCHAR",
1710 "EM_EMPTYUNDOBUFFER",
1711 "EM_GETFIRSTVISIBLELINE",
1712 "EM_SETREADONLY",
1713 "EM_SETWORDBREAKPROC",
1714 "EM_GETWORDBREAKPROC",
1715 "EM_GETPASSWORDCHAR",
1716 "EM_SETMARGINS",
1717 "EM_GETMARGINS",
1718 "EM_GETLIMITTEXT",
1719 "EM_POSFROMCHAR",
1720 "EM_CHARFROMPOS"
1721 };
1722
1723 static const char * const richedit_messages[] = {
1724 "EM_CANPASTE",
1725 "EM_DISPLAYBAND",
1726 "EM_EXGETSEL",
1727 "EM_EXLIMITTEXT",
1728 "EM_EXLINEFROMCHAR",
1729 "EM_EXSETSEL",
1730 "EM_FINDTEXT",
1731 "EM_FORMATRANGE",
1732 "EM_GETCHARFORMAT",
1733 "EM_GETEVENTMASK",
1734 "EM_GETOLEINTERFACE",
1735 "EM_GETPARAFORMAT",
1736 "EM_GETSELTEXT",
1737 "EM_HIDESELECTION",
1738 "EM_PASTESPECIAL",
1739 "EM_REQUESTRESIZE",
1740 "EM_SELECTIONTYPE",
1741 "EM_SETBKGNDCOLOR",
1742 "EM_SETCHARFORMAT",
1743 "EM_SETEVENTMASK",
1744 "EM_SETOLECALLBACK",
1745 "EM_SETPARAFORMAT",
1746 "EM_SETTARGETDEVICE",
1747 "EM_STREAMIN",
1748 "EM_STREAMOUT",
1749 "EM_GETTEXTRANGE",
1750 "EM_FINDWORDBREAK",
1751 "EM_SETOPTIONS",
1752 "EM_GETOPTIONS",
1753 "EM_FINDTEXTEX",
1754 "EM_GETWORDBREAKPROCEX",
1755 "EM_SETWORDBREAKPROCEX",
1756 "EM_SETUNDOLIMIT",
1757 "EM_UNKNOWN_USER_83",
1758 "EM_REDO",
1759 "EM_CANREDO",
1760 "EM_GETUNDONAME",
1761 "EM_GETREDONAME",
1762 "EM_STOPGROUPTYPING",
1763 "EM_SETTEXTMODE",
1764 "EM_GETTEXTMODE",
1765 "EM_AUTOURLDETECT",
1766 "EM_GETAUTOURLDETECT",
1767 "EM_SETPALETTE",
1768 "EM_GETTEXTEX",
1769 "EM_GETTEXTLENGTHEX",
1770 "EM_SHOWSCROLLBAR",
1771 "EM_SETTEXTEX",
1772 "EM_UNKNOWN_USER_98",
1773 "EM_UNKNOWN_USER_99",
1774 "EM_SETPUNCTUATION",
1775 "EM_GETPUNCTUATION",
1776 "EM_SETWORDWRAPMODE",
1777 "EM_GETWORDWRAPMODE",
1778 "EM_SETIMECOLOR",
1779 "EM_GETIMECOLOR",
1780 "EM_SETIMEOPTIONS",
1781 "EM_GETIMEOPTIONS",
1782 "EM_CONVPOSITION",
1783 "EM_UNKNOWN_USER_109",
1784 "EM_UNKNOWN_USER_110",
1785 "EM_UNKNOWN_USER_111",
1786 "EM_UNKNOWN_USER_112",
1787 "EM_UNKNOWN_USER_113",
1788 "EM_UNKNOWN_USER_114",
1789 "EM_UNKNOWN_USER_115",
1790 "EM_UNKNOWN_USER_116",
1791 "EM_UNKNOWN_USER_117",
1792 "EM_UNKNOWN_USER_118",
1793 "EM_UNKNOWN_USER_119",
1794 "EM_SETLANGOPTIONS",
1795 "EM_GETLANGOPTIONS",
1796 "EM_GETIMECOMPMODE",
1797 "EM_FINDTEXTW",
1798 "EM_FINDTEXTEXW",
1799 "EM_RECONVERSION",
1800 "EM_SETIMEMODEBIAS",
1801 "EM_GETIMEMODEBIAS"
1802 };
1803
1804 static const char *
1805 get_msg_name(UINT msg)
1806 {
1807 if (msg >= EM_GETSEL && msg <= EM_CHARFROMPOS)
1808 return edit_messages[msg - EM_GETSEL];
1809 if (msg >= EM_CANPASTE && msg <= EM_GETIMEMODEBIAS)
1810 return richedit_messages[msg - EM_CANPASTE];
1811 return "";
1812 }
1813
1814 static LRESULT RichEditWndProc_common(HWND hWnd, UINT msg, WPARAM wParam,
1815 LPARAM lParam, BOOL unicode)
1816 {
1817 ME_TextEditor *editor = (ME_TextEditor *)GetWindowLongPtrW(hWnd, 0);
1818
1819 TRACE("hwnd %p msg %04x (%s) %lx %lx, unicode %d\n",
1820 hWnd, msg, get_msg_name(msg), wParam, lParam, unicode);
1821
1822 if (!editor && msg != WM_NCCREATE && msg != WM_NCDESTROY) {
1823 ERR("called with invalid hWnd %p - application bug?\n", hWnd);
1824 return 0;
1825 }
1826
1827 switch(msg) {
1828
1829 UNSUPPORTED_MSG(EM_DISPLAYBAND)
1830 UNSUPPORTED_MSG(EM_FINDWORDBREAK)
1831 UNSUPPORTED_MSG(EM_FMTLINES)
1832 UNSUPPORTED_MSG(EM_FORMATRANGE)
1833 UNSUPPORTED_MSG(EM_GETBIDIOPTIONS)
1834 UNSUPPORTED_MSG(EM_GETEDITSTYLE)
1835 UNSUPPORTED_MSG(EM_GETIMECOMPMODE)
1836 /* UNSUPPORTED_MSG(EM_GETIMESTATUS) missing in Wine headers */
1837 UNSUPPORTED_MSG(EM_GETLANGOPTIONS)
1838 /* UNSUPPORTED_MSG(EM_GETOLEINTERFACE) separate stub */
1839 UNSUPPORTED_MSG(EM_GETREDONAME)
1840 UNSUPPORTED_MSG(EM_GETTEXTMODE)
1841 UNSUPPORTED_MSG(EM_GETTYPOGRAPHYOPTIONS)
1842 UNSUPPORTED_MSG(EM_GETUNDONAME)
1843 UNSUPPORTED_MSG(EM_GETWORDBREAKPROCEX)
1844 UNSUPPORTED_MSG(EM_PASTESPECIAL)
1845 UNSUPPORTED_MSG(EM_SELECTIONTYPE)
1846 UNSUPPORTED_MSG(EM_SETBIDIOPTIONS)
1847 UNSUPPORTED_MSG(EM_SETEDITSTYLE)
1848 UNSUPPORTED_MSG(EM_SETFONTSIZE)
1849 UNSUPPORTED_MSG(EM_SETLANGOPTIONS)
1850 UNSUPPORTED_MSG(EM_SETPALETTE)
1851 UNSUPPORTED_MSG(EM_SETTABSTOPS)
1852 UNSUPPORTED_MSG(EM_SETTARGETDEVICE)
1853 UNSUPPORTED_MSG(EM_SETTYPOGRAPHYOPTIONS)
1854 UNSUPPORTED_MSG(EM_SETWORDBREAKPROCEX)
1855 UNSUPPORTED_MSG(WM_STYLECHANGING)
1856 UNSUPPORTED_MSG(WM_STYLECHANGED)
1857 /* UNSUPPORTED_MSG(WM_UNICHAR) FIXME missing in Wine headers */
1858
1859 /* Messages specific to Richedit controls */
1860
1861 case EM_STREAMIN:
1862 return ME_StreamIn(editor, wParam, (EDITSTREAM*)lParam);
1863 case EM_STREAMOUT:
1864 return ME_StreamOut(editor, wParam, (EDITSTREAM *)lParam);
1865 case WM_GETDLGCODE:
1866 {
1867 UINT code = DLGC_WANTCHARS|DLGC_WANTARROWS;
1868 if(lParam && (((LPMSG)lParam)->message == WM_KEYDOWN))
1869 {
1870 int vk = (int)((LPMSG)lParam)->wParam;
1871 /* if style says we want return key */
1872 if((vk == VK_RETURN) && (GetWindowLongW(hWnd, GWL_STYLE) & ES_WANTRETURN))
1873 {
1874 code |= DLGC_WANTMESSAGE;
1875 }
1876 /* we always handle ctrl-tab */
1877 if((vk == VK_TAB) && (GetKeyState(VK_CONTROL) & 0x8000))
1878 {
1879 code |= DLGC_WANTMESSAGE;
1880 }
1881 }
1882 return code;
1883 }
1884 case WM_NCCREATE:
1885 {
1886 CREATESTRUCTW *pcs = (CREATESTRUCTW *)lParam;
1887 TRACE("WM_NCCREATE: style 0x%08x\n", pcs->style);
1888 editor = ME_MakeEditor(hWnd);
1889 SetWindowLongPtrW(hWnd, 0, (LONG_PTR)editor);
1890 return TRUE;
1891 }
1892 case EM_EMPTYUNDOBUFFER:
1893 ME_EmptyUndoStack(editor);
1894 return 0;
1895 case EM_GETSEL:
1896 {
1897 /* Note: wParam/lParam can be NULL */
1898 UINT from, to;
1899 PUINT pfrom = wParam ? (PUINT)wParam : &from;
1900 PUINT pto = lParam ? (PUINT)lParam : &to;
1901 ME_GetSelection(editor, (int *)pfrom, (int *)pto);
1902 if ((*pfrom|*pto) & 0xFFFF0000)
1903 return -1;
1904 return MAKELONG(*pfrom,*pto);
1905 }
1906 case EM_EXGETSEL:
1907 {
1908 CHARRANGE *pRange = (CHARRANGE *)lParam;
1909 ME_GetSelection(editor, &pRange->cpMin, &pRange->cpMax);
1910 TRACE("EM_EXGETSEL = (%d,%d)\n", pRange->cpMin, pRange->cpMax);
1911 return 0;
1912 }
1913 case EM_SETUNDOLIMIT:
1914 {
1915 if ((int)wParam < 0)
1916 editor->nUndoLimit = STACK_SIZE_DEFAULT;
1917 else
1918 editor->nUndoLimit = min(wParam, STACK_SIZE_MAX);
1919 /* Setting a max stack size keeps wine from getting killed
1920 for hogging memory. Windows allocates all this memory at once, so
1921 no program would realistically set a value above our maximum. */
1922 return editor->nUndoLimit;
1923 }
1924 case EM_CANUNDO:
1925 return editor->pUndoStack != NULL;
1926 case EM_CANREDO:
1927 return editor->pRedoStack != NULL;
1928 case WM_UNDO: /* FIXME: actually not the same */
1929 case EM_UNDO:
1930 ME_Undo(editor);
1931 return 0;
1932 case EM_REDO:
1933 ME_Redo(editor);
1934 return 0;
1935 case EM_GETOPTIONS:
1936 {
1937 /* these flags are equivalent to the ES_* counterparts */
1938 DWORD mask = ECO_VERTICAL | ECO_AUTOHSCROLL | ECO_AUTOVSCROLL |
1939 ECO_NOHIDESEL | ECO_READONLY | ECO_WANTRETURN;
1940 DWORD settings = GetWindowLongW(hWnd, GWL_STYLE) & mask;
1941
1942 return settings;
1943 }
1944 case EM_SETOPTIONS:
1945 {
1946 /* these flags are equivalent to ES_* counterparts
1947 * ECO_READONLY is already implemented in the code, only requires
1948 * setting the bit to work
1949 */
1950 DWORD mask = ECO_VERTICAL | ECO_AUTOHSCROLL | ECO_AUTOVSCROLL |
1951 ECO_NOHIDESEL | ECO_READONLY | ECO_WANTRETURN | ECO_SELECTIONBAR;
1952 DWORD raw = GetWindowLongW(hWnd, GWL_STYLE);
1953 DWORD settings = mask & raw;
1954
1955 switch(wParam)
1956 {
1957 case ECOOP_SET:
1958 settings = lParam;
1959 break;
1960 case ECOOP_OR:
1961 settings |= lParam;
1962 break;
1963 case ECOOP_AND:
1964 settings &= lParam;
1965 break;
1966 case ECOOP_XOR:
1967 settings ^= lParam;
1968 }
1969 SetWindowLongW(hWnd, GWL_STYLE, (raw & ~mask) | (settings & mask));
1970
1971 if (settings & ECO_AUTOWORDSELECTION)
1972 FIXME("ECO_AUTOWORDSELECTION not implemented yet!\n");
1973 if (settings & ECO_SELECTIONBAR)
1974 editor->selofs = 16;
1975 else
1976 editor->selofs = 0;
1977 ME_WrapMarkedParagraphs(editor);
1978
1979 if (settings & ECO_VERTICAL)
1980 FIXME("ECO_VERTICAL not implemented yet!\n");
1981 if (settings & ECO_AUTOHSCROLL)
1982 FIXME("ECO_AUTOHSCROLL not implemented yet!\n");
1983 if (settings & ECO_AUTOVSCROLL)
1984 FIXME("ECO_AUTOVSCROLL not implemented yet!\n");
1985 if (settings & ECO_NOHIDESEL)
1986 FIXME("ECO_NOHIDESEL not implemented yet!\n");
1987 if (settings & ECO_WANTRETURN)
1988 FIXME("ECO_WANTRETURN not implemented yet!\n");
1989
1990 return settings;
1991 }
1992 case EM_SETSEL:
1993 {
1994 ME_InvalidateSelection(editor);
1995 ME_SetSelection(editor, wParam, lParam);
1996 ME_InvalidateSelection(editor);
1997 ME_SendSelChange(editor);
1998 return 0;
1999 }
2000 case EM_SETSCROLLPOS:
2001 {
2002 POINT *point = (POINT *)lParam;
2003 ME_ScrollAbs(editor, point->y);
2004 return 0;
2005 }
2006 case EM_AUTOURLDETECT:
2007 {
2008 if (wParam==1 || wParam ==0)
2009 {
2010 editor->AutoURLDetect_bEnable = (BOOL)wParam;
2011 return 0;
2012 }
2013 return E_INVALIDARG;
2014 }
2015 case EM_GETAUTOURLDETECT:
2016 {
2017 return editor->AutoURLDetect_bEnable;
2018 }
2019 case EM_EXSETSEL:
2020 {
2021 int end;
2022 CHARRANGE range = *(CHARRANGE *)lParam;
2023
2024 TRACE("EM_EXSETSEL (%d,%d)\n", range.cpMin, range.cpMax);
2025
2026 ME_InvalidateSelection(editor);
2027 end = ME_SetSelection(editor, range.cpMin, range.cpMax);
2028 ME_InvalidateSelection(editor);
2029 ME_SendSelChange(editor);
2030
2031 return end;
2032 }
2033 case EM_SHOWSCROLLBAR:
2034 {
2035 ShowScrollBar(editor->hWnd, wParam, lParam);
2036 return 0;
2037 }
2038 case EM_SETTEXTEX:
2039 {
2040 LPWSTR wszText;
2041 SETTEXTEX *pStruct = (SETTEXTEX *)wParam;
2042 size_t len;
2043 int from, to;
2044 ME_Style *style;
2045 int oldModify = editor->nModifyStep;
2046
2047 if (!pStruct) return 0;
2048
2049 TRACE("EM_SETTEXTEX - %s, flags %d, cp %d\n",
2050 pStruct->codepage == 1200 ? debugstr_w((LPCWSTR)lParam) : debugstr_a((LPCSTR)lParam),
2051 pStruct->flags, pStruct->codepage);
2052
2053 /* FIXME: make use of pStruct->codepage in the to unicode translation */
2054 wszText = lParam ? ME_ToUnicode(pStruct->codepage == 1200, (void *)lParam) : NULL;
2055 len = wszText ? lstrlenW(wszText) : 0;
2056
2057 /* FIXME: this should support RTF strings too, according to MSDN */
2058 if (pStruct->flags & ST_SELECTION) {
2059 ME_GetSelection(editor, &from, &to);
2060 style = ME_GetSelectionInsertStyle(editor);
2061 ME_InternalDeleteText(editor, from, to - from);
2062 ME_InsertTextFromCursor(editor, 0, wszText, len, style);
2063 ME_ReleaseStyle(style);
2064 }
2065 else {
2066 ME_InternalDeleteText(editor, 0, ME_GetTextLength(editor));
2067 ME_InsertTextFromCursor(editor, 0, wszText, len, editor->pBuffer->pDefaultStyle);
2068 len = 1;
2069 }
2070 ME_CommitUndo(editor);
2071 if (!(pStruct->flags & ST_KEEPUNDO))
2072 {
2073 editor->nModifyStep = oldModify;
2074 ME_EmptyUndoStack(editor);
2075 }
2076 ME_UpdateRepaint(editor);
2077 return len;
2078 }
2079 case EM_SETBKGNDCOLOR:
2080 {
2081 LRESULT lColor;
2082 if (editor->rgbBackColor != -1) {
2083 DeleteObject(editor->hbrBackground);
2084 lColor = editor->rgbBackColor;
2085 }
2086 else lColor = GetSysColor(COLOR_WINDOW);
2087
2088 if (wParam)
2089 {
2090 editor->rgbBackColor = -1;
2091 editor->hbrBackground = GetSysColorBrush(COLOR_WINDOW);
2092 }
2093 else
2094 {
2095 editor->rgbBackColor = lParam;
2096 editor->hbrBackground = CreateSolidBrush(editor->rgbBackColor);
2097 }
2098 if (editor->bRedraw)
2099 {
2100 InvalidateRect(hWnd, NULL, TRUE);
2101 UpdateWindow(hWnd);
2102 }
2103 return lColor;
2104 }
2105 case EM_GETMODIFY:
2106 return editor->nModifyStep == 0 ? 0 : 1;
2107 case EM_SETMODIFY:
2108 {
2109 if (wParam)
2110 editor->nModifyStep = 1;
2111 else
2112 editor->nModifyStep = 0;
2113
2114 return 0;
2115 }
2116 case EM_SETREADONLY:
2117 {
2118 long nStyle = GetWindowLongW(hWnd, GWL_STYLE);
2119 if (wParam)
2120 nStyle |= ES_READONLY;
2121 else
2122 nStyle &= ~ES_READONLY;
2123 SetWindowLongW(hWnd, GWL_STYLE, nStyle);
2124 return 0;
2125 }
2126 case EM_SETEVENTMASK:
2127 {
2128 DWORD nOldMask = editor->nEventMask;
2129
2130 editor->nEventMask = lParam;
2131 return nOldMask;
2132 }
2133 case EM_GETEVENTMASK:
2134 return editor->nEventMask;
2135 case EM_SETCHARFORMAT:
2136 {
2137 CHARFORMAT2W buf, *p;
2138 BOOL bRepaint = TRUE;
2139 p = ME_ToCF2W(&buf, (CHARFORMAT2W *)lParam);
2140 if (p == NULL) return 0;
2141 if (!wParam)
2142 ME_SetDefaultCharFormat(editor, p);
2143 else if (wParam == (SCF_WORD | SCF_SELECTION)) {
2144 FIXME("EM_SETCHARFORMAT: word selection not supported\n");
2145 return 0;
2146 } else if (wParam == SCF_ALL) {
2147 if (editor->mode & TM_PLAINTEXT)
2148 ME_SetDefaultCharFormat(editor, p);
2149 else
2150 ME_SetCharFormat(editor, 0, ME_GetTextLength(editor), p);
2151 } else if (editor->mode & TM_PLAINTEXT) {
2152 return 0;
2153 } else {
2154 int from, to;
2155 ME_GetSelection(editor, &from, &to);
2156 bRepaint = (from != to);
2157 ME_SetSelectionCharFormat(editor, p);
2158 }
2159 editor->nModifyStep = 1;
2160 ME_CommitUndo(editor);
2161 if (bRepaint)
2162 ME_RewrapRepaint(editor);
2163 return 1;
2164 }
2165 case EM_GETCHARFORMAT:
2166 {
2167 CHARFORMAT2W tmp, *dst = (CHARFORMAT2W *)lParam;
2168 if (dst->cbSize != sizeof(CHARFORMATA) &&
2169 dst->cbSize != sizeof(CHARFORMATW) &&
2170 dst->cbSize != sizeof(CHARFORMAT2A) &&
2171 dst->cbSize != sizeof(CHARFORMAT2W))
2172 return 0;
2173 tmp.cbSize = sizeof(tmp);
2174 if (!wParam)
2175 ME_GetDefaultCharFormat(editor, &tmp);
2176 else
2177 ME_GetSelectionCharFormat(editor, &tmp);
2178 ME_CopyToCFAny(dst, &tmp);
2179 return tmp.dwMask;
2180 }
2181 case EM_SETPARAFORMAT:
2182 ME_SetSelectionParaFormat(editor, (PARAFORMAT2 *)lParam);
2183 ME_RewrapRepaint(editor);
2184 ME_CommitUndo(editor);
2185 return 0;
2186 case EM_GETPARAFORMAT:
2187 ME_GetSelectionParaFormat(editor, (PARAFORMAT2 *)lParam);
2188 return 0;
2189 case EM_GETFIRSTVISIBLELINE:
2190 {
2191 ME_DisplayItem *p = editor->pBuffer->pFirst;
2192 int y = ME_GetYScrollPos(editor);
2193 int ypara = 0;
2194 int count = 0;
2195 int ystart, yend;
2196 while(p) {
2197 p = ME_FindItemFwd(p, diStartRowOrParagraphOrEnd);
2198 if (p->type == diTextEnd)
2199 break;
2200 if (p->type == diParagraph) {
2201 ypara = p->member.para.nYPos;
2202 continue;
2203 }
2204 ystart = ypara + p->member.row.nYPos;
2205 yend = ystart + p->member.row.nHeight;
2206 if (y < yend) {
2207 break;
2208 }
2209 count++;
2210 }
2211 return count;
2212 }
2213 case EM_HIDESELECTION:
2214 {
2215 editor->bHideSelection = (wParam != 0);
2216 ME_InvalidateSelection(editor);
2217 return 0;
2218 }
2219 case EM_LINESCROLL:
2220 {
2221 ME_ScrollDown(editor, lParam * 8); /* FIXME follow the original */
2222 return TRUE; /* Should return false if a single line richedit control */
2223 }
2224 case WM_CLEAR:
2225 {
2226 int from, to;
2227 ME_GetSelection(editor, &from, &to);
2228 ME_InternalDeleteText(editor, from, to-from);
2229 ME_CommitUndo(editor);
2230 ME_UpdateRepaint(editor);
2231 return 0;
2232 }
2233 case EM_REPLACESEL:
2234 {
2235 int from, to;
2236 ME_Style *style;
2237 LPWSTR wszText = lParam ? ME_ToUnicode(unicode, (void *)lParam) : NULL;
2238 size_t len = wszText ? lstrlenW(wszText) : 0;
2239 TRACE("EM_REPLACESEL - %s\n", debugstr_w(wszText));
2240
2241 ME_GetSelection(editor, &from, &to);
2242 style = ME_GetSelectionInsertStyle(editor);
2243 ME_InternalDeleteText(editor, from, to-from);
2244 ME_InsertTextFromCursor(editor, 0, wszText, len, style);
2245 ME_ReleaseStyle(style);
2246 /* drop temporary style if line end */
2247 /*
2248 * FIXME question: does abc\n mean: put abc,
2249 * clear temp style, put \n? (would require a change)
2250 */
2251 if (len>0 && wszText[len-1] == '\n')
2252 ME_ClearTempStyle(editor);
2253 ME_EndToUnicode(unicode, wszText);
2254 ME_CommitUndo(editor);
2255 if (!wParam)
2256 ME_EmptyUndoStack(editor);
2257 ME_UpdateRepaint(editor);
2258 return len;
2259 }
2260 case EM_SCROLLCARET:
2261 {
2262 int top, bottom; /* row's edges relative to document top */
2263 int nPos;
2264 ME_DisplayItem *para, *row;
2265
2266 nPos = ME_GetYScrollPos(editor);
2267 row = ME_RowStart(editor->pCursors[0].pRun);
2268 para = ME_GetParagraph(row);
2269 top = para->member.para.nYPos + row->member.row.nYPos;
2270 bottom = top + row->member.row.nHeight;
2271
2272 if (top < nPos) /* caret above window */
2273 ME_ScrollAbs(editor, top);
2274 else if (nPos + editor->sizeWindow.cy < bottom) /*below*/
2275 ME_ScrollAbs(editor, bottom - editor->sizeWindow.cy);
2276 return 0;
2277 }
2278 case WM_SETFONT:
2279 {
2280 LOGFONTW lf;
2281 CHARFORMAT2W fmt;
2282 HDC hDC;
2283 BOOL bRepaint = LOWORD(lParam);
2284
2285 if (!wParam)
2286 wParam = (WPARAM)GetStockObject(SYSTEM_FONT);
2287 GetObjectW((HGDIOBJ)wParam, sizeof(LOGFONTW), &lf);
2288 hDC = GetDC(hWnd);
2289 ME_CharFormatFromLogFont(hDC, &lf, &fmt);
2290 ReleaseDC(hWnd, hDC);
2291 ME_SetCharFormat(editor, 0, ME_GetTextLength(editor), &fmt);
2292 ME_SetDefaultCharFormat(editor, &fmt);
2293
2294 ME_CommitUndo(editor);
2295 if (bRepaint)
2296 ME_RewrapRepaint(editor);
2297 return 0;
2298 }
2299 case WM_SETTEXT:
2300 {
2301 ME_InternalDeleteText(editor, 0, ME_GetTextLength(editor));
2302 if (lParam)
2303 {
2304 TRACE("WM_SETTEXT lParam==%lx\n",lParam);
2305 if (!unicode && !strncmp((char *)lParam, "{\\rtf", 5))
2306 {
2307 /* Undocumented: WM_SETTEXT supports RTF text */
2308 ME_StreamInRTFString(editor, 0, (char *)lParam);
2309 }
2310 else
2311 {
2312 LPWSTR wszText = ME_ToUnicode(unicode, (void *)lParam);
2313 TRACE("WM_SETTEXT - %s\n", debugstr_w(wszText)); /* debugstr_w() */
2314 if (lstrlenW(wszText) > 0)
2315 {
2316 int len = -1;
2317
2318 /* uses default style! */
2319 if (!(GetWindowLongW(hWnd, GWL_STYLE) & ES_MULTILINE))
2320 {
2321 WCHAR * p;
2322
2323 p = wszText;
2324 while (*p != '\0' && *p != '\r' && *p != '\n') p++;
2325 len = p - wszText;
2326 }
2327 ME_InsertTextFromCursor(editor, 0, wszText, len, editor->pBuffer->pDefaultStyle);
2328 }
2329 ME_EndToUnicode(unicode, wszText);
2330 }
2331 }
2332 else
2333 TRACE("WM_SETTEXT - NULL\n");
2334 ME_CommitUndo(editor);
2335 ME_EmptyUndoStack(editor);
2336 ME_SetSelection(editor, 0, 0);
2337 editor->nModifyStep = 0;
2338 ME_UpdateRepaint(editor);
2339 return 1;
2340 }
2341 case EM_CANPASTE:
2342 {
2343 UINT nRTFFormat = RegisterClipboardFormatA("Rich Text Format");
2344 if (IsClipboardFormatAvailable(nRTFFormat))
2345 return TRUE;
2346 if (IsClipboardFormatAvailable(CF_UNICODETEXT))
2347 return TRUE;
2348 return FALSE;
2349 }
2350 case WM_PASTE:
2351 {
2352 DWORD dwFormat = 0;
2353 EDITSTREAM es;
2354 ME_GlobalDestStruct gds;
2355 UINT nRTFFormat = RegisterClipboardFormatA("Rich Text Format");
2356 UINT cf = 0;
2357
2358 if (IsClipboardFormatAvailable(nRTFFormat))
2359 cf = nRTFFormat, dwFormat = SF_RTF;
2360 else if (IsClipboardFormatAvailable(CF_UNICODETEXT))
2361 cf = CF_UNICODETEXT, dwFormat = SF_TEXT|SF_UNICODE;
2362 else
2363 return 0;
2364
2365 if (!OpenClipboard(hWnd))
2366 return 0;
2367 gds.hData = GetClipboardData(cf);
2368 gds.nLength = 0;
2369 es.dwCookie = (DWORD)&gds;
2370 es.pfnCallback = dwFormat == SF_RTF ? ME_ReadFromHGLOBALRTF : ME_ReadFromHGLOBALUnicode;
2371 ME_StreamIn(editor, dwFormat|SFF_SELECTION, &es);
2372
2373 CloseClipboard();
2374 return 0;
2375 }
2376 case WM_CUT:
2377 case WM_COPY:
2378 {
2379 LPDATAOBJECT dataObj = NULL;
2380 CHARRANGE range;
2381 HRESULT hr = S_OK;
2382
2383 if (editor->cPasswordMask)
2384 return 0; /* Copying or Cutting masked text isn't allowed */
2385
2386 ME_GetSelection(editor, &range.cpMin, &range.cpMax);
2387 if(editor->lpOleCallback)
2388 hr = IRichEditOleCallback_GetClipboardData(editor->lpOleCallback, &range, RECO_COPY, &dataObj);
2389 if(FAILED(hr) || !dataObj)
2390 hr = ME_GetDataObject(editor, &range, &dataObj);
2391 if(SUCCEEDED(hr)) {
2392 hr = OleSetClipboard(dataObj);
2393 IDataObject_Release(dataObj);
2394 }
2395 if (SUCCEEDED(hr) && msg == WM_CUT)
2396 {
2397 ME_InternalDeleteText(editor, range.cpMin, range.cpMax-range.cpMin);
2398 ME_CommitUndo(editor);
2399 ME_UpdateRepaint(editor);
2400 }
2401 return 0;
2402 }
2403 case WM_GETTEXTLENGTH:
2404 {
2405 GETTEXTLENGTHEX how;
2406
2407 how.flags = GTL_CLOSE | (editor->bEmulateVersion10 ? 0 : GTL_USECRLF) | GTL_NUMCHARS;
2408 how.codepage = unicode ? 1200 : CP_ACP;
2409 return ME_GetTextLengthEx(editor, &how);
2410 }
2411 case EM_GETTEXTLENGTHEX:
2412 return ME_GetTextLengthEx(editor, (GETTEXTLENGTHEX *)wParam);
2413 case WM_GETTEXT:
2414 {
2415 GETTEXTEX ex;
2416 LRESULT rc;
2417 LPSTR bufferA = NULL;
2418 LPWSTR bufferW = NULL;
2419
2420 if (unicode)
2421 bufferW = heap_alloc((wParam + 2) * sizeof(WCHAR));
2422 else
2423 bufferA = heap_alloc(wParam + 2);
2424
2425 ex.cb = (wParam + 2) * (unicode ? sizeof(WCHAR) : sizeof(CHAR));
2426 ex.flags = GT_USECRLF;
2427 ex.codepage = unicode ? 1200 : CP_ACP;
2428 ex.lpDefaultChar = NULL;
2429 ex.lpUsedDefChar = NULL;
2430 rc = RichEditWndProc_common(hWnd, EM_GETTEXTEX, (WPARAM)&ex, unicode ? (LPARAM)bufferW : (LPARAM)bufferA, unicode);
2431
2432 if (unicode)
2433 {
2434 memcpy((LPWSTR)lParam, bufferW, wParam * sizeof(WCHAR));
2435 if (lstrlenW(bufferW) >= wParam) rc = 0;
2436 }
2437 else
2438 {
2439 memcpy((LPSTR)lParam, bufferA, wParam);
2440 if (strlen(bufferA) >= wParam) rc = 0;
2441 }
2442 heap_free(bufferA);
2443 heap_free(bufferW);
2444 return rc;
2445 }
2446 case EM_GETTEXTEX:
2447 {
2448 GETTEXTEX *ex = (GETTEXTEX*)wParam;
2449 int nStart, nCount; /* in chars */
2450
2451 if (ex->flags & ~(GT_SELECTION | GT_USECRLF))
2452 FIXME("GETTEXTEX flags 0x%08x not supported\n", ex->flags & ~(GT_SELECTION | GT_USECRLF));
2453
2454 if (ex->flags & GT_SELECTION)
2455 {
2456 ME_GetSelection(editor, &nStart, &nCount);
2457 nCount -= nStart;
2458 }
2459 else
2460 {
2461 nStart = 0;
2462 nCount = 0x7fffffff;
2463 }
2464 if (ex->codepage == 1200)
2465 {
2466 nCount = min(nCount, ex->cb / sizeof(WCHAR) - 1);
2467 return ME_GetTextW(editor, (LPWSTR)lParam, nStart, nCount, ex->flags & GT_USECRLF);
2468 }
2469 else
2470 {
2471 /* potentially each char may be a CR, why calculate the exact value with O(N) when
2472 we can just take a bigger buffer? :) */
2473 int crlfmul = (ex->flags & GT_USECRLF) ? 2 : 1;
2474 LPWSTR buffer;
2475 DWORD buflen = ex->cb;
2476 LRESULT rc;
2477 DWORD flags = 0;
2478
2479 nCount = min(nCount, ex->cb - 1);
2480 buffer = heap_alloc((crlfmul*nCount + 1) * sizeof(WCHAR));
2481
2482 buflen = ME_GetTextW(editor, buffer, nStart, nCount, ex->flags & GT_USECRLF);
2483 rc = WideCharToMultiByte(ex->codepage, flags, buffer, -1, (LPSTR)lParam, ex->cb, ex->lpDefaultChar, ex->lpUsedDefChar);
2484 if (rc) rc--; /* do not count 0 terminator */
2485
2486 heap_free(buffer);
2487 return rc;
2488 }
2489 }
2490 case EM_GETSELTEXT:
2491 {
2492 int from, to;
2493 TEXTRANGEW tr; /* W and A differ only by rng->lpstrText */
2494 ME_GetSelection(editor, &from, &to);
2495 tr.chrg.cpMin = from;
2496 tr.chrg.cpMax = to;
2497 tr.lpstrText = (WCHAR *)lParam;
2498 return RichEditWndProc_common(hWnd, EM_GETTEXTRANGE, 0, (LPARAM)&tr, unicode);
2499 }
2500 case EM_GETSCROLLPOS:
2501 {
2502 POINT *point = (POINT *)lParam;
2503 point->x = 0; /* FIXME side scrolling not implemented */
2504 point->y = ME_GetYScrollPos(editor);
2505 return 1;
2506 }
2507 case EM_GETTEXTRANGE:
2508 {
2509 TEXTRANGEW *rng = (TEXTRANGEW *)lParam;
2510 TRACE("EM_GETTEXTRANGE min=%d max=%d unicode=%d emul1.0=%d length=%d\n",
2511 rng->chrg.cpMin, rng->chrg.cpMax, unicode,
2512 editor->bEmulateVersion10, ME_GetTextLength(editor));
2513 if (unicode)
2514 return ME_GetTextW(editor, rng->lpstrText, rng->chrg.cpMin, rng->chrg.cpMax-rng->chrg.cpMin, editor->bEmulateVersion10);
2515 else
2516 {
2517 int nLen = rng->chrg.cpMax-rng->chrg.cpMin;
2518 WCHAR *p = ALLOC_N_OBJ(WCHAR, nLen+1);
2519 int nChars = ME_GetTextW(editor, p, rng->chrg.cpMin, nLen, editor->bEmulateVersion10);
2520 /* FIXME this is a potential security hole (buffer overrun)
2521 if you know more about wchar->mbyte conversion please explain
2522 */
2523 WideCharToMultiByte(CP_ACP, 0, p, nChars+1, (char *)rng->lpstrText, nLen+1, NULL, NULL);
2524 FREE_OBJ(p);
2525 return nChars;
2526 }
2527 }
2528 case EM_GETLINE:
2529 {
2530 ME_DisplayItem *run;
2531 const unsigned int nMaxChars = *(WORD *) lParam;
2532 unsigned int nEndChars, nCharsLeft = nMaxChars;
2533 char *dest = (char *) lParam;
2534 /* rich text editor 1.0 uses \r\n for line end, 2.0 uses just \r;
2535 we need to know how if we have the extra \n or not */
2536 int nLF = editor->bEmulateVersion10;
2537
2538 TRACE("EM_GETLINE: row=%d, nMaxChars=%d (%s)\n", (int) wParam, nMaxChars,
2539 unicode ? "Unicode" : "Ansi");
2540
2541 run = ME_FindRowWithNumber(editor, wParam);
2542 if (run == NULL)
2543 return 0;
2544
2545 while (nCharsLeft && (run = ME_FindItemFwd(run, diRunOrStartRow))
2546 && !(run->member.run.nFlags & MERF_ENDPARA))
2547 {
2548 unsigned int nCopy;
2549 ME_String *strText;
2550 if (run->type != diRun)
2551 break;
2552 strText = run->member.run.strText;
2553 nCopy = min(nCharsLeft, strText->nLen);
2554
2555 if (unicode)
2556 lstrcpynW((LPWSTR) dest, strText->szData, nCopy);
2557 else
2558 nCopy = WideCharToMultiByte(CP_ACP, 0, strText->szData, nCopy, dest,
2559 nCharsLeft, NULL, NULL);
2560 dest += nCopy * (unicode ? sizeof(WCHAR) : 1);
2561 nCharsLeft -= nCopy;
2562 }
2563
2564 /* append \r\0 (or \r\n\0 in 1.0), space allowing */
2565 nEndChars = min(nCharsLeft, 2 + nLF);
2566 nCharsLeft -= nEndChars;
2567 if (unicode)
2568 {
2569 const WCHAR src[] = {'\r', '\0'};
2570 const WCHAR src10[] = {'\r', '\n', '\0'};
2571 lstrcpynW((LPWSTR) dest, nLF ? src10 : src, nEndChars);
2572 }
2573 else
2574 lstrcpynA(dest, nLF ? "\r\n" : "\r", nEndChars);
2575
2576 TRACE("EM_GETLINE: got %u bytes\n", nMaxChars - nCharsLeft);
2577
2578 if (nEndChars == 2 + nLF)
2579 return nMaxChars - nCharsLeft - 1; /* don't count \0 */
2580 else
2581 return nMaxChars - nCharsLeft;
2582 }
2583 case EM_GETLINECOUNT:
2584 {
2585 ME_DisplayItem *item = editor->pBuffer->pFirst->next;
2586 int nRows = 0;
2587
2588 while (item != editor->pBuffer->pLast)
2589 {
2590 assert(item->type == diParagraph);
2591 nRows += item->member.para.nRows;
2592 item = item->member.para.next_para;
2593 }
2594 TRACE("EM_GETLINECOUNT: nRows==%d\n", nRows);
2595 return max(1, nRows);
2596 }
2597 case EM_LINEFROMCHAR:
2598 {
2599 if (wParam == -1)
2600 return ME_RowNumberFromCharOfs(editor, ME_GetCursorOfs(editor, 1));
2601 else
2602 return ME_RowNumberFromCharOfs(editor, wParam);
2603 }
2604 case EM_EXLINEFROMCHAR:
2605 {
2606 if (lParam == -1)
2607 return ME_RowNumberFromCharOfs(editor, ME_GetCursorOfs(editor,1));
2608 else
2609 return ME_RowNumberFromCharOfs(editor, lParam);
2610 }
2611 case EM_LINEINDEX:
2612 {
2613 ME_DisplayItem *item, *para;
2614 int nCharOfs;
2615
2616 if (wParam == -1)
2617 item = ME_FindItemBack(editor->pCursors[0].pRun, diStartRow);
2618 else
2619 item = ME_FindRowWithNumber(editor, wParam);
2620 if (!item)
2621 return -1;
2622 para = ME_GetParagraph(item);
2623 item = ME_FindItemFwd(item, diRun);
2624 nCharOfs = para->member.para.nCharOfs + item->member.run.nCharOfs;
2625 TRACE("EM_LINEINDEX: nCharOfs==%d\n", nCharOfs);
2626 return nCharOfs;
2627 }
2628 case EM_LINELENGTH:
2629 {
2630 ME_DisplayItem *item, *item_end;
2631 int nChars = 0, nThisLineOfs = 0, nNextLineOfs = 0;
2632
2633 if (wParam > ME_GetTextLength(editor))
2634 return 0;
2635 if (wParam == -1)
2636 {
2637 FIXME("EM_LINELENGTH: returning number of unselected characters on lines with selection unsupported.\n");
2638 return 0;
2639 }
2640 item = ME_FindItemAtOffset(editor, diRun, wParam, NULL);
2641 item = ME_RowStart(item);
2642 nThisLineOfs = ME_CharOfsFromRunOfs(editor, ME_FindItemFwd(item, diRun), 0);
2643 item_end = ME_FindItemFwd(item, diStartRowOrParagraphOrEnd);
2644 if (item_end->type == diStartRow)
2645 nNextLineOfs = ME_CharOfsFromRunOfs(editor, ME_FindItemFwd(item_end, diRun), 0);
2646 else
2647 nNextLineOfs = ME_FindItemFwd(item, diParagraphOrEnd)->member.para.nCharOfs
2648 - (editor->bEmulateVersion10?2:1);
2649 nChars = nNextLineOfs - nThisLineOfs;
2650 TRACE("EM_LINELENGTH(%ld)==%d\n",wParam, nChars);
2651 return nChars;
2652 }
2653 case EM_EXLIMITTEXT:
2654 {
2655 if ((int)lParam < 0)
2656 return 0;
2657 if (lParam == 0)
2658 editor->nTextLimit = 65536;
2659 else
2660 editor->nTextLimit = (int) lParam;
2661 return 0;
2662 }
2663 case EM_LIMITTEXT:
2664 {
2665 if (wParam == 0)
2666 editor->nTextLimit = 65536;
2667 else
2668 editor->nTextLimit = (int) wParam;
2669 return 0;
2670 }
2671 case EM_GETLIMITTEXT:
2672 {
2673 return editor->nTextLimit;
2674 }
2675 case EM_FINDTEXT:
2676 {
2677 FINDTEXTA *ft = (FINDTEXTA *)lParam;
2678 int nChars = MultiByteToWideChar(CP_ACP, 0, ft->lpstrText, -1, NULL, 0);
2679 WCHAR *tmp;
2680 LRESULT r;
2681
2682 if ((tmp = ALLOC_N_OBJ(WCHAR, nChars)) != NULL)
2683 MultiByteToWideChar(CP_ACP, 0, ft->lpstrText, -1, tmp, nChars);
2684 r = ME_FindText(editor, wParam, &ft->chrg, tmp, NULL);
2685 FREE_OBJ( tmp );
2686 return r;
2687 }
2688 case EM_FINDTEXTEX:
2689 {
2690 FINDTEXTEXA *ex = (FINDTEXTEXA *)lParam;
2691 int nChars = MultiByteToWideChar(CP_ACP, 0, ex->lpstrText, -1, NULL, 0);
2692 WCHAR *tmp;
2693 LRESULT r;
2694
2695 if ((tmp = ALLOC_N_OBJ(WCHAR, nChars)) != NULL)
2696 MultiByteToWideChar(CP_ACP, 0, ex->lpstrText, -1, tmp, nChars);
2697 r = ME_FindText(editor, wParam, &ex->chrg, tmp, &ex->chrgText);
2698 FREE_OBJ( tmp );
2699 return r;
2700 }
2701 case EM_FINDTEXTW:
2702 {
2703 FINDTEXTW *ft = (FINDTEXTW *)lParam;
2704 return ME_FindText(editor, wParam, &ft->chrg, ft->lpstrText, NULL);
2705 }
2706 case EM_FINDTEXTEXW:
2707 {
2708 FINDTEXTEXW *ex = (FINDTEXTEXW *)lParam;
2709 return ME_FindText(editor, wParam, &ex->chrg, ex->lpstrText, &ex->chrgText);
2710 }
2711 case EM_GETZOOM:
2712 if (!wParam || !lParam)
2713 return FALSE;
2714 *(int *)wParam = editor->nZoomNumerator;
2715 *(int *)lParam = editor->nZoomDenominator;
2716 return TRUE;
2717 case EM_SETZOOM:
2718 return ME_SetZoom(editor, wParam, lParam);
2719 case EM_CHARFROMPOS:
2720 return ME_CharFromPos(editor, ((POINTL *)lParam)->x, ((POINTL *)lParam)->y);
2721 case EM_POSFROMCHAR:
2722 {
2723 ME_DisplayItem *pRun;
2724 int nCharOfs, nOffset, nLength;
2725 POINTL pt = {0,0};
2726
2727 nCharOfs = wParam;
2728 /* detect which API version we're dealing with */
2729 if (wParam >= 0x40000)
2730 nCharOfs = lParam;
2731 nLength = ME_GetTextLength(editor);
2732
2733 if (nCharOfs < nLength) {
2734 ME_RunOfsFromCharOfs(editor, nCharOfs, &pRun, &nOffset);
2735 assert(pRun->type == diRun);
2736 pt.y = pRun->member.run.pt.y;
2737 pt.x = pRun->member.run.pt.x + ME_PointFromChar(editor, &pRun->member.run, nOffset);
2738 pt.y += ME_GetParagraph(pRun)->member.para.nYPos;
2739 } else {
2740 pt.x = 0;
2741 pt.y = editor->pBuffer->pLast->member.para.nYPos;
2742 }
2743 pt.x += editor->selofs;
2744 if (wParam >= 0x40000) {
2745 *(POINTL *)wParam = pt;
2746 }
2747 return MAKELONG( pt.x, pt.y );
2748 }
2749 case WM_CREATE:
2750 if (GetWindowLongW(hWnd, GWL_STYLE) & WS_HSCROLL)
2751 { /* Squelch the default horizontal scrollbar it would make */
2752 ShowScrollBar(editor->hWnd, SB_HORZ, FALSE);
2753 }
2754 ME_CommitUndo(editor);
2755 ME_WrapMarkedParagraphs(editor);
2756 ME_MoveCaret(editor);
2757 return 0;
2758 case WM_DESTROY:
2759 ME_DestroyEditor(editor);
2760 SetWindowLongPtrW(hWnd, 0, 0);
2761 return 0;
2762 case WM_LBUTTONDOWN:
2763 if ((editor->nEventMask & ENM_MOUSEEVENTS) &&
2764 !ME_FilterEvent(editor, msg, &wParam, &lParam))
2765 return 0;
2766 SetFocus(hWnd);
2767 ME_LButtonDown(editor, (short)LOWORD(lParam), (short)HIWORD(lParam));
2768 SetCapture(hWnd);
2769 ME_LinkNotify(editor,msg,wParam,lParam);
2770 ME_SetCursor(editor, LOWORD(lParam));
2771 break;
2772 case WM_MOUSEMOVE:
2773 if ((editor->nEventMask & ENM_MOUSEEVENTS) &&
2774 !ME_FilterEvent(editor, msg, &wParam, &lParam))
2775 return 0;
2776 if (GetCapture() == hWnd)
2777 ME_MouseMove(editor, (short)LOWORD(lParam), (short)HIWORD(lParam));
2778 ME_LinkNotify(editor,msg,wParam,lParam);
2779 ME_SetCursor(editor, LOWORD(lParam));
2780 break;
2781 case WM_LBUTTONUP:
2782 if (GetCapture() == hWnd)
2783 ReleaseCapture();
2784 if ((editor->nEventMask & ENM_MOUSEEVENTS) &&
2785 !ME_FilterEvent(editor, msg, &wParam, &lParam))
2786 return 0;
2787 editor->linesel = 0;
2788 ME_SetCursor(editor, LOWORD(lParam));
2789 ME_LinkNotify(editor,msg,wParam,lParam);
2790 break;
2791 case WM_LBUTTONDBLCLK:
2792 if ((editor->nEventMask & ENM_MOUSEEVENTS) &&
2793 !ME_FilterEvent(editor, msg, &wParam, &lParam))
2794 return 0;
2795 ME_LinkNotify(editor,msg,wParam,lParam);
2796 ME_SelectWord(editor);
2797 break;
2798 case WM_RBUTTONUP:
2799 case WM_RBUTTONDOWN:
2800 if ((editor->nEventMask & ENM_MOUSEEVENTS) &&
2801 !ME_FilterEvent(editor, msg, &wParam, &lParam))
2802 return 0;
2803 goto do_default;
2804 case WM_CONTEXTMENU:
2805 if (!ME_ShowContextMenu(editor, (short)LOWORD(lParam), (short)HIWORD(lParam)))
2806 goto do_default;
2807 break;
2808 case WM_PAINT:
2809 if (editor->bRedraw)
2810 {
2811 HDC hDC;
2812 PAINTSTRUCT ps;
2813
2814 hDC = BeginPaint(hWnd, &ps);
2815 ME_PaintContent(editor, hDC, FALSE, &ps.rcPaint);
2816 EndPaint(hWnd, &ps);
2817 }
2818 break;
2819 case WM_SETFOCUS:
2820 editor->bHaveFocus = TRUE;
2821 ME_ShowCaret(editor);
2822 ME_SendOldNotify(editor, EN_SETFOCUS);
2823 return 0;
2824 case WM_KILLFOCUS:
2825 ME_HideCaret(editor);
2826 editor->bHaveFocus = FALSE;
2827 ME_SendOldNotify(editor, EN_KILLFOCUS);
2828 return 0;
2829 case WM_ERASEBKGND:
2830 {
2831 if (editor->bRedraw)
2832 {
2833 HDC hDC = (HDC)wParam;
2834 RECT rc;
2835 if (GetUpdateRect(hWnd,&rc,TRUE))
2836 {
2837 FillRect(hDC, &rc, editor->hbrBackground);
2838 }
2839 }
2840 return 1;
2841 }
2842 case WM_COMMAND:
2843 TRACE("editor wnd command = %d\n", LOWORD(wParam));
2844 return 0;
2845 case WM_KEYUP:
2846 if ((editor->nEventMask & ENM_KEYEVENTS) &&
2847 !ME_FilterEvent(editor, msg, &wParam, &lParam))
2848 return 0;
2849 goto do_default;
2850 case WM_KEYDOWN:
2851 if ((editor->nEventMask & ENM_KEYEVENTS) &&
2852 !ME_FilterEvent(editor, msg, &wParam, &lParam))
2853 return 0;
2854 if (ME_KeyDown(editor, LOWORD(wParam)))
2855 return 0;
2856 goto do_default;
2857 case WM_CHAR:
2858 {
2859 WCHAR wstr;
2860
2861 if (unicode)
2862 wstr = (WCHAR)wParam;
2863 else
2864 {
2865 CHAR charA = wParam;
2866 MultiByteToWideChar(CP_ACP, 0, &charA, 1, &wstr, 1);
2867 }
2868 if (editor->AutoURLDetect_bEnable)
2869 ME_AutoURLDetect(editor, wstr);
2870
2871 switch (wstr)
2872 {
2873 case 1: /* Ctrl-A */
2874 ME_SetSelection(editor, 0, -1);
2875 return 0;
2876 case 3: /* Ctrl-C */
2877 SendMessageW(editor->hWnd, WM_COPY, 0, 0);
2878 return 0;
2879 }
2880
2881 if (GetWindowLongW(editor->hWnd, GWL_STYLE) & ES_READONLY) {
2882 MessageBeep(MB_ICONERROR);
2883 return 0; /* FIXME really 0 ? */
2884 }
2885
2886 switch (wstr)
2887 {
2888 case 22: /* Ctrl-V */
2889 SendMessageW(editor->hWnd, WM_PASTE, 0, 0);
2890 return 0;
2891 case 24: /* Ctrl-X */
2892 SendMessageW(editor->hWnd, WM_CUT, 0, 0);
2893 return 0;
2894 case 25: /* Ctrl-Y */
2895 SendMessageW(editor->hWnd, EM_REDO, 0, 0);
2896 return 0;
2897 case 26: /* Ctrl-Z */
2898 SendMessageW(editor->hWnd, EM_UNDO, 0, 0);
2899 return 0;
2900 }
2901 if (((unsigned)wstr)>=' '
2902 || (wstr=='\r' && (GetWindowLongW(hWnd, GWL_STYLE) & ES_MULTILINE))
2903 || wstr=='\t') {
2904 /* FIXME maybe it would make sense to call EM_REPLACESEL instead ? */
2905 /* WM_CHAR is restricted to nTextLimit */
2906 int from, to;
2907 ME_GetSelection(editor, &from, &to);
2908 if(editor->nTextLimit > ME_GetTextLength(editor) - (to-from))
2909 {
2910 ME_Style *style = ME_GetInsertStyle(editor, 0);
2911 ME_SaveTempStyle(editor);
2912 ME_InsertTextFromCursor(editor, 0, &wstr, 1, style);
2913 ME_ReleaseStyle(style);
2914 ME_CommitUndo(editor);
2915 }
2916 ME_UpdateRepaint(editor);
2917 }
2918 return 0;
2919 }
2920 case EM_SCROLL: /* fall through */
2921 case WM_VSCROLL:
2922 {
2923 int origNPos;
2924 int lineHeight;
2925
2926 origNPos = ME_GetYScrollPos(editor);
2927 lineHeight = 24;
2928
2929 if (editor && editor->pBuffer && editor->pBuffer->pDefaultStyle)
2930 lineHeight = editor->pBuffer->pDefaultStyle->tm.tmHeight;
2931 if (lineHeight <= 0) lineHeight = 24;
2932
2933 switch(LOWORD(wParam))
2934 {
2935 case SB_LINEUP:
2936 ME_ScrollUp(editor,lineHeight);
2937 break;
2938 case SB_LINEDOWN:
2939 ME_ScrollDown(editor,lineHeight);
2940 break;
2941 case SB_PAGEUP:
2942 ME_ScrollUp(editor,editor->sizeWindow.cy);
2943 break;
2944 case SB_PAGEDOWN:
2945 ME_ScrollDown(editor,editor->sizeWindow.cy);
2946 break;
2947 case SB_THUMBTRACK:
2948 case SB_THUMBPOSITION:
2949 ME_ScrollAbs(editor,HIWORD(wParam));
2950 break;
2951 }
2952 if (msg == EM_SCROLL)
2953 return 0x00010000 | (((ME_GetYScrollPos(editor) - origNPos)/lineHeight) & 0xffff);
2954 break;
2955 }
2956 case WM_MOUSEWHEEL:
2957 {
2958 int gcWheelDelta;
2959 UINT pulScrollLines;
2960
2961 if ((editor->nEventMask & ENM_MOUSEEVENTS) &&
2962 !ME_FilterEvent(editor, msg, &wParam, &lParam))
2963 return 0;
2964
2965 SystemParametersInfoW(SPI_GETWHEELSCROLLLINES,0, &pulScrollLines, 0);
2966 gcWheelDelta = -GET_WHEEL_DELTA_WPARAM(wParam);
2967
2968 if (abs(gcWheelDelta) >= WHEEL_DELTA && pulScrollLines)
2969 {
2970 /* FIXME follow the original */
2971 ME_ScrollDown(editor,pulScrollLines * (gcWheelDelta / WHEEL_DELTA) * 8);
2972 }
2973 break;
2974 }
2975 case EM_GETRECT:
2976 {
2977 *((RECT *)lParam) = editor->rcFormat;
2978 return 0;
2979 }
2980 case EM_SETRECT:
2981 case EM_SETRECTNP:
2982 {
2983 if (lParam)
2984 {
2985 RECT *rc = (RECT *)lParam;
2986
2987 if (wParam)
2988 {
2989 editor->rcFormat.left += rc->left;
2990 editor->rcFormat.top += rc->top;
2991 editor->rcFormat.right += rc->right;
2992 editor->rcFormat.bottom += rc->bottom;
2993 }
2994 else
2995 {
2996 editor->rcFormat = *rc;
2997 }
2998 }
2999 else
3000 {
3001 GetClientRect(hWnd, &editor->rcFormat);
3002 }
3003 if (msg != EM_SETRECTNP)
3004 ME_RewrapRepaint(editor);
3005 return 0;
3006 }
3007 case EM_REQUESTRESIZE:
3008 ME_SendRequestResize(editor, TRUE);
3009 return 0;
3010 case WM_SETREDRAW:
3011 if ((editor->bRedraw = wParam))
3012 ME_RewrapRepaint(editor);
3013 return 0;
3014 case WM_SIZE:
3015 {
3016 GetClientRect(hWnd, &editor->rcFormat);
3017 ME_RewrapRepaint(editor);
3018 return DefWindowProcW(hWnd, msg, wParam, lParam);
3019 }
3020 /* IME messages to make richedit controls IME aware */
3021 case WM_IME_SETCONTEXT:
3022 case WM_IME_CONTROL:
3023 case WM_IME_SELECT:
3024 case WM_IME_COMPOSITIONFULL:
3025 return 0;
3026 case WM_IME_STARTCOMPOSITION:
3027 {
3028 editor->imeStartIndex=ME_GetCursorOfs(editor,0);
3029 ME_DeleteSelection(editor);
3030 ME_CommitUndo(editor);
3031 ME_UpdateRepaint(editor);
3032 return 0;
3033 }
3034 case WM_IME_COMPOSITION:
3035 {
3036 HIMC hIMC;
3037
3038 ME_Style *style = ME_GetInsertStyle(editor, 0);
3039 hIMC = ImmGetContext(hWnd);
3040 ME_DeleteSelection(editor);
3041 ME_CommitUndo(editor);
3042 ME_SaveTempStyle(editor);
3043 if (lParam & GCS_RESULTSTR)
3044 {
3045 LPWSTR lpCompStr = NULL;
3046 DWORD dwBufLen;
3047
3048 dwBufLen = ImmGetCompositionStringW(hIMC, GCS_RESULTSTR, NULL, 0);
3049 lpCompStr = HeapAlloc(GetProcessHeap(),0,dwBufLen + sizeof(WCHAR));
3050 ImmGetCompositionStringW(hIMC, GCS_RESULTSTR, lpCompStr, dwBufLen);
3051 lpCompStr[dwBufLen/sizeof(WCHAR)] = 0;
3052 ME_InsertTextFromCursor(editor,0,lpCompStr,dwBufLen/sizeof(WCHAR),style);
3053 }
3054 else if (lParam & GCS_COMPSTR)
3055 {
3056 LPWSTR lpCompStr = NULL;
3057 DWORD dwBufLen;
3058
3059 dwBufLen = ImmGetCompositionStringW(hIMC, GCS_COMPSTR, NULL, 0);
3060 lpCompStr = HeapAlloc(GetProcessHeap(),0,dwBufLen + sizeof(WCHAR));
3061 ImmGetCompositionStringW(hIMC, GCS_COMPSTR, lpCompStr, dwBufLen);
3062 lpCompStr[dwBufLen/sizeof(WCHAR)] = 0;
3063
3064 ME_InsertTextFromCursor(editor,0,lpCompStr,dwBufLen/sizeof(WCHAR),style);
3065 ME_SetSelection(editor,editor->imeStartIndex,
3066 editor->imeStartIndex + dwBufLen/sizeof(WCHAR));
3067 }
3068 ME_ReleaseStyle(style);
3069 ME_UpdateRepaint(editor);
3070 return 0;
3071 }
3072 case WM_IME_ENDCOMPOSITION:
3073 {
3074 ME_DeleteSelection(editor);
3075 editor->imeStartIndex=-1;
3076 return 0;
3077 }
3078 case EM_GETOLEINTERFACE:
3079 {
3080 LPVOID *ppvObj = (LPVOID*) lParam;
3081 return CreateIRichEditOle(editor, ppvObj);
3082 }
3083 case EM_GETPASSWORDCHAR:
3084 {
3085 return editor->cPasswordMask;
3086 }
3087 case EM_SETOLECALLBACK:
3088 if(editor->lpOleCallback)
3089 IUnknown_Release(editor->lpOleCallback);
3090 editor->lpOleCallback = (LPRICHEDITOLECALLBACK)lParam;
3091 if(editor->lpOleCallback)
3092 IUnknown_AddRef(editor->lpOleCallback);
3093 return TRUE;
3094 case EM_GETWORDBREAKPROC:
3095 return (LRESULT)editor->pfnWordBreak;
3096 case EM_SETWORDBREAKPROC:
3097 {
3098 EDITWORDBREAKPROCW pfnOld = editor->pfnWordBreak;
3099
3100 editor->pfnWordBreak = (EDITWORDBREAKPROCW)lParam;
3101 return (LRESULT)pfnOld;
3102 }
3103 case EM_SETTEXTMODE:
3104 {
3105 LRESULT ret;
3106 int mask = 0;
3107 int changes = 0;
3108 ret = RichEditWndProc_common(hWnd, WM_GETTEXTLENGTH, 0, 0, unicode);
3109 if (!ret)
3110 {
3111 /*Check for valid wParam*/
3112 if ((((wParam & TM_RICHTEXT) && ((wParam & TM_PLAINTEXT) << 1))) ||
3113 (((wParam & TM_MULTILEVELUNDO) && ((wParam & TM_SINGLELEVELUNDO) << 1))) ||
3114 (((wParam & TM_MULTICODEPAGE) && ((wParam & TM_SINGLECODEPAGE) << 1))))
3115 return 1;
3116 else
3117 {
3118 if (wParam & (TM_RICHTEXT | TM_PLAINTEXT))
3119 {
3120 mask |= (TM_RICHTEXT | TM_PLAINTEXT);
3121 changes |= (wParam & (TM_RICHTEXT | TM_PLAINTEXT));
3122 }
3123 /*FIXME: Currently no support for undo level and code page options*/
3124 editor->mode = (editor->mode & (~mask)) | changes;
3125 return 0;
3126 }
3127 }
3128 return ret;
3129 }
3130 case EM_SETPASSWORDCHAR:
3131 {
3132 editor->cPasswordMask = wParam;
3133 ME_RewrapRepaint(editor);
3134 return 0;
3135 }
3136 default:
3137 do_default:
3138 return DefWindowProcW(hWnd, msg, wParam, lParam);
3139 }
3140 return 0L;
3141 }
3142
3143 static LRESULT WINAPI RichEditWndProcW(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
3144 {
3145 BOOL unicode = TRUE;
3146
3147 /* Under Win9x RichEdit20W returns ANSI strings, see the tests. */
3148 if (msg == WM_GETTEXT && (GetVersion() & 0x80000000))
3149 unicode = FALSE;
3150
3151 return RichEditWndProc_common(hWnd, msg, wParam, lParam, unicode);
3152 }
3153
3154 static LRESULT WINAPI RichEditWndProcA(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
3155 {
3156 return RichEditWndProc_common(hWnd, msg, wParam, lParam, FALSE);
3157 }
3158
3159 /******************************************************************
3160 * RichEditANSIWndProc (RICHED20.10)
3161 */
3162 LRESULT WINAPI RichEditANSIWndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
3163 {
3164 return RichEditWndProcA(hWnd, msg, wParam, lParam);
3165 }
3166
3167 /******************************************************************
3168 * RichEdit10ANSIWndProc (RICHED20.9)
3169 */
3170 LRESULT WINAPI RichEdit10ANSIWndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
3171 {
3172 LRESULT result;
3173
3174 /* FIXME: this is NOT the same as 2.0 version */
3175 result = RichEditANSIWndProc(hWnd, msg, wParam, lParam);
3176 if (msg == WM_NCCREATE)
3177 {
3178 ME_TextEditor *editor = (ME_TextEditor *)GetWindowLongPtrW(hWnd, 0);
3179
3180 editor->bEmulateVersion10 = TRUE;
3181 editor->pBuffer->pLast->member.para.nCharOfs = 2;
3182 }
3183 return result;
3184 }
3185
3186 void ME_SendOldNotify(ME_TextEditor *editor, int nCode)
3187 {
3188 HWND hWnd = editor->hWnd;
3189 SendMessageA(GetParent(hWnd), WM_COMMAND, (nCode<<16)|GetWindowLongW(hWnd, GWLP_ID), (LPARAM)hWnd);
3190 }
3191
3192 void ME_LinkNotify(ME_TextEditor *editor, UINT msg, WPARAM wParam, LPARAM lParam)
3193 {
3194 int x,y;
3195 ME_Cursor tmpCursor;
3196 int nCharOfs; /* The start of the clicked text. Absolute character offset */
3197
3198 ME_Run *tmpRun;
3199
3200 ENLINK info;
3201 x = (short)LOWORD(lParam);
3202 y = (short)HIWORD(lParam);
3203 nCharOfs = ME_CharFromPos(editor, x, y);
3204 if (nCharOfs < 0) return;
3205
3206 ME_CursorFromCharOfs(editor, nCharOfs, &tmpCursor);
3207 tmpRun = &tmpCursor.pRun->member.run;
3208
3209 if ((tmpRun->style->fmt.dwMask & CFM_LINK)
3210 && (tmpRun->style->fmt.dwEffects & CFE_LINK))
3211 { /* The clicked run has CFE_LINK set */
3212 info.nmhdr.hwndFrom = editor->hWnd;
3213 info.nmhdr.idFrom = GetWindowLongW(editor->hWnd, GWLP_ID);
3214 info.nmhdr.code = EN_LINK;
3215 info.msg = msg;
3216 info.wParam = wParam;
3217 info.lParam = lParam;
3218 info.chrg.cpMin = ME_CharOfsFromRunOfs(editor,tmpCursor.pRun,0);
3219 info.chrg.cpMax = info.chrg.cpMin + ME_StrVLen(tmpRun->strText);
3220 SendMessageW(GetParent(editor->hWnd), WM_NOTIFY,info.nmhdr.idFrom, (LPARAM)&info);
3221 }
3222 }
3223
3224 int ME_CountParagraphsBetween(ME_TextEditor *editor, int from, int to)
3225 {
3226 ME_DisplayItem *item = ME_FindItemFwd(editor->pBuffer->pFirst, diParagraph);
3227 int i = 0;
3228
3229 while(item && item->member.para.next_para->member.para.nCharOfs <= from)
3230 item = item->member.para.next_para;
3231 if (!item)
3232 return 0;
3233 while(item && item->member.para.next_para->member.para.nCharOfs <= to) {
3234 item = item->member.para.next_para;
3235 i++;
3236 }
3237 return i;
3238 }
3239
3240
3241 int ME_GetTextW(ME_TextEditor *editor, WCHAR *buffer, int nStart, int nChars, int bCRLF)
3242 {
3243 ME_DisplayItem *item = ME_FindItemAtOffset(editor, diRun, nStart, &nStart);
3244 int nWritten = 0;
3245 WCHAR *pStart = buffer;
3246
3247 if (!item) {
3248 *buffer = 0;
3249 return 0;
3250 }
3251
3252 if (nStart)
3253 {
3254 int nLen = ME_StrLen(item->member.run.strText) - nStart;
3255 if (nLen > nChars)
3256 nLen = nChars;
3257 CopyMemory(buffer, item->member.run.strText->szData + nStart, sizeof(WCHAR)*nLen);
3258 nChars -= nLen;
3259 nWritten += nLen;
3260 if (!nChars)
3261 return nWritten;
3262 buffer += nLen;
3263 nStart = 0;
3264 item = ME_FindItemFwd(item, diRun);
3265 }
3266
3267 while(nChars && item)
3268 {
3269 int nLen = ME_StrLen(item->member.run.strText);
3270 if (nLen > nChars)
3271 nLen = nChars;
3272
3273 if (item->member.run.nFlags & MERF_ENDPARA)
3274 {
3275 if (!ME_FindItemFwd(item, diRun))
3276 /* No '\r' is appended to the last paragraph. */
3277 nLen = 0;
3278 else if (bCRLF && nChars == 1) {
3279 nLen = 0;
3280 nChars = 0;
3281 } else {
3282 *buffer = '\r';
3283 if (bCRLF)
3284 {
3285 *(++buffer) = '\n';
3286 nWritten++;
3287 }
3288 assert(nLen == 1);
3289 /* our end paragraph consists of 2 characters now */
3290 if (editor->bEmulateVersion10)
3291 nChars--;
3292 }
3293 }
3294 else
3295 CopyMemory(buffer, item->member.run.strText->szData, sizeof(WCHAR)*nLen);
3296 nChars -= nLen;
3297 nWritten += nLen;
3298 buffer += nLen;
3299
3300 if (!nChars)
3301 {
3302 TRACE("nWritten=%d, actual=%d\n", nWritten, buffer-pStart);
3303 *buffer = 0;
3304 return nWritten;
3305 }
3306 item = ME_FindItemFwd(item, diRun);
3307 }
3308 *buffer = 0;
3309 TRACE("nWritten=%d, actual=%d\n", nWritten, buffer-pStart);
3310 return nWritten;
3311 }
3312
3313 static BOOL ME_RegisterEditorClass(HINSTANCE hInstance)
3314 {
3315 WNDCLASSW wcW;
3316 WNDCLASSA wcA;
3317
3318 wcW.style = CS_DBLCLKS | CS_HREDRAW | CS_VREDRAW | CS_GLOBALCLASS;
3319 wcW.lpfnWndProc = RichEditWndProcW;
3320 wcW.cbClsExtra = 0;
3321 wcW.cbWndExtra = sizeof(ME_TextEditor *);
3322 wcW.hInstance = NULL; /* hInstance would register DLL-local class */
3323 wcW.hIcon = NULL;
3324 wcW.hCursor = hBeam;
3325 wcW.hbrBackground = (HBRUSH)GetStockObject(NULL_BRUSH);
3326 wcW.lpszMenuName = NULL;
3327
3328 if (is_version_nt())
3329 {
3330 wcW.lpszClassName = RichEdit20W;
3331 if (!RegisterClassW(&wcW)) return FALSE;
3332 wcW.lpszClassName = RichEdit50W;
3333 if (!RegisterClassW(&wcW)) return FALSE;
3334 }
3335 else
3336 {
3337 /* WNDCLASSA/W have the same layout */
3338 wcW.lpszClassName = (LPCWSTR)"RichEdit20W";
3339 if (!RegisterClassA((WNDCLASSA *)&wcW)) return FALSE;
3340 wcW.lpszClassName = (LPCWSTR)"RichEdit50W";
3341 if (!RegisterClassA((WNDCLASSA *)&wcW)) return FALSE;
3342 }
3343
3344 wcA.style = CS_DBLCLKS | CS_HREDRAW | CS_VREDRAW | CS_GLOBALCLASS;
3345 wcA.lpfnWndProc = RichEditWndProcA;
3346 wcA.cbClsExtra = 0;
3347 wcA.cbWndExtra = sizeof(ME_TextEditor *);
3348 wcA.hInstance = NULL; /* hInstance would register DLL-local class */
3349 wcA.hIcon = NULL;
3350 wcA.hCursor = LoadCursorW(NULL, MAKEINTRESOURCEW(IDC_IBEAM));
3351 wcA.hbrBackground = (HBRUSH)GetStockObject(NULL_BRUSH);
3352 wcA.lpszMenuName = NULL;
3353 wcA.lpszClassName = "RichEdit20A";
3354 if (!RegisterClassA(&wcA)) return FALSE;
3355 wcA.lpszClassName = "RichEdit50A";
3356 if (!RegisterClassA(&wcA)) return FALSE;
3357
3358 return TRUE;
3359 }
3360
3361 LRESULT WINAPI REComboWndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam) {
3362 /* FIXME: Not implemented */
3363 TRACE("hWnd %p msg %04x (%s) %08lx %08lx\n",
3364 hWnd, msg, get_msg_name(msg), wParam, lParam);
3365 return DefWindowProcW(hWnd, msg, wParam, lParam);
3366 }
3367
3368 LRESULT WINAPI REListWndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam) {
3369 /* FIXME: Not implemented */
3370 TRACE("hWnd %p msg %04x (%s) %08lx %08lx\n",
3371 hWnd, msg, get_msg_name(msg), wParam, lParam);
3372 return DefWindowProcW(hWnd, msg, wParam, lParam);
3373 }
3374
3375 /******************************************************************
3376 * REExtendedRegisterClass (RICHED20.8)
3377 *
3378 * FIXME undocumented
3379 * Need to check for errors and implement controls and callbacks
3380 */
3381 LRESULT WINAPI REExtendedRegisterClass(void)
3382 {
3383 WNDCLASSW wcW;
3384 UINT result;
3385
3386 FIXME("semi stub\n");
3387
3388 wcW.cbClsExtra = 0;
3389 wcW.cbWndExtra = 4;
3390 wcW.hInstance = NULL;
3391 wcW.hIcon = NULL;
3392 wcW.hCursor = NULL;
3393 wcW.hbrBackground = (HBRUSH)(COLOR_WINDOW+1);
3394 wcW.lpszMenuName = NULL;
3395
3396 if (!ME_ListBoxRegistered)
3397 {
3398 wcW.style = CS_PARENTDC | CS_DBLCLKS | CS_GLOBALCLASS;
3399 wcW.lpfnWndProc = REListWndProc;
3400 wcW.lpszClassName = REListBox20W;
3401 if (RegisterClassW(&wcW)) ME_ListBoxRegistered = TRUE;
3402 }
3403
3404 if (!ME_ComboBoxRegistered)
3405 {
3406 wcW.style = CS_PARENTDC | CS_DBLCLKS | CS_GLOBALCLASS | CS_VREDRAW | CS_HREDRAW;
3407 wcW.lpfnWndProc = REComboWndProc;
3408 wcW.lpszClassName = REComboBox20W;
3409 if (RegisterClassW(&wcW)) ME_ComboBoxRegistered = TRUE;
3410 }
3411
3412 result = 0;
3413 if (ME_ListBoxRegistered)
3414 result += 1;
3415 if (ME_ComboBoxRegistered)
3416 result += 2;
3417
3418 return result;
3419 }
3420
3421 int ME_AutoURLDetect(ME_TextEditor *editor, WCHAR curChar)
3422 {
3423 struct prefix_s {
3424 const char *text;
3425 int length;
3426 } prefixes[12] = {
3427 {"http:", 5},
3428 {"file:", 6},
3429 {"mailto:", 8},
3430 {"ftp:", 5},
3431 {"https:", 7},
3432 {"gopher:", 8},
3433 {"nntp:", 6},
3434 {"prospero:", 10},
3435 {"telnet:", 8},
3436 {"news:", 6},
3437 {"wais:", 6},
3438 {"www.", 5}
3439 };
3440 CHARRANGE ins_pt;
3441 int curf_ef, link_ef, def_ef;
3442 int cur_prefx, prefx_cnt;
3443 int sel_min, sel_max;
3444 int car_pos = 0;
3445 int text_pos=-1;
3446 int URLmin, URLmax = 0;
3447 CHARRANGE url;
3448 FINDTEXTA ft;
3449 CHARFORMAT2W cur_format;
3450 CHARFORMAT2W default_format;
3451 CHARFORMAT2W link;
3452 RichEditANSIWndProc(editor->hWnd, EM_EXGETSEL, (WPARAM) 0, (LPARAM) &ins_pt);
3453 sel_min = ins_pt.cpMin;
3454 sel_max = ins_pt.cpMax;
3455 if (sel_min==sel_max)
3456 car_pos = sel_min;
3457 if (sel_min!=sel_max)
3458 car_pos = ME_GetTextLength(editor)+1;
3459 cur_format.cbSize = sizeof(cur_format);
3460 default_format.cbSize = sizeof(default_format);
3461 RichEditANSIWndProc(editor->hWnd, EM_GETCHARFORMAT, SCF_SELECTION, (LPARAM) &cur_format);
3462 RichEditANSIWndProc(editor->hWnd, EM_GETCHARFORMAT, SCF_DEFAULT, (LPARAM) &default_format);
3463 link.cbSize = sizeof(link);
3464 link.dwMask = CFM_LINK;
3465 link.dwEffects = CFE_LINK;
3466 curf_ef = cur_format.dwEffects & link.dwEffects;
3467 def_ef = default_format.dwEffects & link.dwEffects;
3468 link_ef = link.dwEffects & link.dwEffects;
3469 if (curf_ef == link_ef)
3470 {
3471 if( curChar == '\n' || curChar=='\r' || curChar==' ')
3472 {
3473 ME_SetSelection(editor, car_pos, car_pos);
3474 RichEditANSIWndProc(editor->hWnd, EM_SETCHARFORMAT, SCF_SELECTION, (LPARAM) &default_format);
3475 text_pos=-1;
3476 return 0;
3477 }
3478 }
3479 if (curf_ef == def_ef)
3480 {
3481 cur_prefx = 0;
3482 prefx_cnt = (sizeof(prefixes)/sizeof(struct prefix_s))-1;
3483 while (cur_prefx<=prefx_cnt)
3484 {
3485 if (text_pos == -1)
3486 {
3487 ft.lpstrText = prefixes[cur_prefx].text;
3488 URLmin=max(0,(car_pos-prefixes[cur_prefx].length));
3489 URLmax=max(0, car_pos);
3490 if ((car_pos == 0) && (ME_GetTextLength(editor) != 0))
3491 {
3492 URLmax = ME_GetTextLength(editor)+1;
3493 }
3494 ft.chrg.cpMin = URLmin;
3495 ft.chrg.cpMax = URLmax;
3496 text_pos=RichEditANSIWndProc(editor->hWnd, EM_FINDTEXT, FR_DOWN, (LPARAM)&ft);
3497 cur_prefx++;
3498 }
3499 if (text_pos != -1)
3500 {
3501 url.cpMin=text_pos;
3502 url.cpMax=car_pos-1;
3503 ME_SetCharFormat(editor, text_pos, (URLmax-text_pos), &link);
3504 ME_RewrapRepaint(editor);
3505 break;
3506 }
3507 }
3508 }
3509 return 0;
3510 }
Windows API implementation