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