2 * RichEdit - functions dealing with editor object
4 * Copyright 2004 by Krzysztof Foltman
5 * Copyright 2005 by Cihan Altinay
6 * Copyright 2005 by Phil Krylov
7 * Copyright 2008 Eric Pouech
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.
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.
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
25 API implementation status:
27 Messages (ANSI versions not done yet)
28 + EM_AUTOURLDETECT 2.0
39 + EM_FINDTEXT (only FR_DOWN flag implemented)
40 + EM_FINDTEXTEX (only FR_DOWN flag implemented)
44 + EM_GETAUTOURLDETECT 2.0
45 - EM_GETBIDIOPTIONS 3.0
46 - EM_GETCHARFORMAT (partly done)
49 + EM_GETFIRSTVISIBLELINE (can be optimized if needed)
50 - EM_GETIMECOLOR 1.0asian
51 - EM_GETIMECOMPMODE 2.0
52 - EM_GETIMEOPTIONS 1.0asian
54 - EM_GETLANGOPTIONS 2.0
57 + EM_GETLINECOUNT returns number of rows, not of paragraphs
62 + EM_GETPASSWORDCHAR 2.0
63 - EM_GETPUNCTUATION 1.0asian
67 + EM_GETSELTEXT (ANSI&Unicode)
68 + EM_GETSCROLLPOS 3.0 (only Y value valid)
71 + EM_GETTEXTLENGTHEX (GTL_PRECISE unimplemented)
73 ? + EM_GETTEXTRANGE (ANSI&Unicode)
74 - EM_GETTYPOGRAPHYOPTIONS 3.0
77 - EM_GETWORDBREAKPROCEX
78 - EM_GETWORDWRAPMODE 1.0asian
81 + EM_LIMITTEXT (Also called EM_SETLIMITTEXT)
90 + EM_REPLACESEL (proper style?) ANSI&Unicode
94 - EM_SETBIDIOPTIONS 3.0
96 + EM_SETCHARFORMAT (partly done, no ANSI)
98 + EM_SETEVENTMASK (few notifications supported)
100 - EM_SETIMECOLOR 1.0asian
101 - EM_SETIMEOPTIONS 1.0asian
102 - EM_SETLANGOPTIONS 2.0
104 + EM_SETMODIFY (not sure if implementation is correct)
106 + EM_SETOPTIONS (partially implemented)
109 + EM_SETPASSWORDCHAR 2.0
110 - EM_SETPUNCTUATION 1.0asian
111 + EM_SETREADONLY no beep on modification attempt
113 + EM_SETRECTNP (EM_SETRECT without repainting)
115 + EM_SETSCROLLPOS 3.0
117 - EM_SETTARGETDEVICE (partial)
118 + EM_SETTEXTEX 3.0 (proper style?)
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
126 + EM_SHOWSCROLLBAR 2.0
127 + EM_STOPGROUPTYPING 2.0
135 + WM_GETDLGCODE (the current implementation is incomplete)
136 + WM_GETTEXT (ANSI&Unicode)
137 + WM_GETTEXTLENGTH (ANSI version sucks)
140 + WM_SETTEXT (resets undo stack !) (proper style?) ANSI&Unicode
142 - WM_STYLECHANGED (things like read-only flag)
147 * EN_CHANGE (sent from the wrong place)
164 * EN_UPDATE (sent from the wrong place)
172 + ES_DISABLENOSCROLL (scrollbar is always visible)
173 - ES_EX_NOCALLOLEINIT
175 - ES_MULTILINE (currently single line controls aren't supported)
177 - ES_READONLY (I'm not sure if beeping is the proper behaviour)
183 - ES_WANTRETURN (don't know how to do WM_GETDLGCODE part)
190 * RICHED20 TODO (incomplete):
192 * - messages/styles/notifications listed above
193 * - add remaining CHARFORMAT/PARAFORMAT fields
194 * - right/center align should strip spaces from the beginning
195 * - pictures/OLE objects (not just smiling faces that lack API support ;-) )
196 * - COM interface (looks like a major pain in the TODO list)
197 * - calculate heights of pictures (half-done)
198 * - horizontal scrolling (not even started)
199 * - hysteresis during wrapping (related to scrollbars appearing/disappearing)
201 * - how to implement EM_FORMATRANGE and EM_DISPLAYBAND ? (Mission Impossible)
202 * - italic caret with italic fonts
204 * - most notifications aren't sent at all (the most important ones are)
205 * - when should EN_SELCHANGE be sent after text change ? (before/after EN_UPDATE?)
206 * - WM_SETTEXT may use wrong style (but I'm 80% sure it's OK)
207 * - EM_GETCHARFORMAT with SCF_SELECTION may not behave 100% like in original (but very close)
208 * - full justification
211 * - ListBox & ComboBox not implemented
213 * Bugs that are probably fixed, but not so easy to verify:
214 * - EN_UPDATE/EN_CHANGE are handled very incorrectly (should be OK now)
215 * - undo for ME_JoinParagraphs doesn't store paragraph format ? (it does)
216 * - check/fix artificial EOL logic (bCursorAtEnd, hardly logical)
217 * - caret shouldn't be displayed when selection isn't empty
218 * - check refcounting in style management functions (looks perfect now, but no bugs is suspicious)
219 * - undo for setting default format (done, might be buggy)
220 * - styles might be not released properly (looks like they work like charm, but who knows?
227 #define NO_SHLWAPI_STREAM
233 #define STACK_SIZE_DEFAULT 100
234 #define STACK_SIZE_MAX 1000
236 #define TEXT_LIMIT_DEFAULT 32767
238 WINE_DEFAULT_DEBUG_CHANNEL(richedit
);
240 static BOOL
ME_RegisterEditorClass(HINSTANCE
);
242 static const WCHAR RichEdit20W
[] = {'R', 'i', 'c', 'h', 'E', 'd', 'i', 't', '2', '0', 'W', 0};
243 static const WCHAR RichEdit50W
[] = {'R', 'i', 'c', 'h', 'E', 'd', 'i', 't', '5', '0', 'W', 0};
244 static const WCHAR REListBox20W
[] = {'R','E','L','i','s','t','B','o','x','2','0','W', 0};
245 static const WCHAR REComboBox20W
[] = {'R','E','C','o','m','b','o','B','o','x','2','0','W', 0};
246 static HCURSOR hLeft
;
249 HANDLE me_heap
= NULL
;
251 static BOOL ME_ListBoxRegistered
= FALSE
;
252 static BOOL ME_ComboBoxRegistered
= FALSE
;
254 static inline int is_version_nt(void)
256 return !(GetVersion() & 0x80000000);
259 static ME_TextBuffer
*ME_MakeText(void) {
261 ME_TextBuffer
*buf
= ALLOC_OBJ(ME_TextBuffer
);
263 ME_DisplayItem
*p1
= ME_MakeDI(diTextStart
);
264 ME_DisplayItem
*p2
= ME_MakeDI(diTextEnd
);
270 p1
->member
.para
.next_para
= p2
;
271 p2
->member
.para
.prev_para
= p1
;
272 p2
->member
.para
.nCharOfs
= 0;
276 buf
->pCharStyle
= NULL
;
282 static LRESULT
ME_StreamInText(ME_TextEditor
*editor
, DWORD dwFormat
, ME_InStream
*stream
, ME_Style
*style
)
284 WCHAR wszText
[STREAMIN_BUFFER_SIZE
+1];
287 TRACE("%08x %p\n", dwFormat
, stream
);
294 ME_StreamInFill(stream
);
295 if (stream
->editstream
->dwError
)
301 if (!(dwFormat
& SF_UNICODE
))
303 /* FIXME? this is doomed to fail on true MBCS like UTF-8, luckily they're unlikely to be used as CP_ACP */
304 nWideChars
= MultiByteToWideChar(CP_ACP
, 0, stream
->buffer
, stream
->dwSize
, wszText
, STREAMIN_BUFFER_SIZE
);
309 nWideChars
= stream
->dwSize
>> 1;
310 pText
= (WCHAR
*)stream
->buffer
;
313 ME_InsertTextFromCursor(editor
, 0, pText
, nWideChars
, style
);
314 if (stream
->dwSize
== 0)
318 ME_CommitUndo(editor
);
319 ME_UpdateRepaint(editor
);
323 static void ME_RTFCharAttrHook(RTF_Info
*info
)
326 fmt
.cbSize
= sizeof(fmt
);
330 switch(info
->rtfMinor
)
333 /* FIXME add more flags once they're implemented */
334 fmt
.dwMask
= CFM_BOLD
| CFM_ITALIC
| CFM_UNDERLINETYPE
| CFM_STRIKEOUT
| CFM_COLOR
| CFM_BACKCOLOR
| CFM_SIZE
| CFM_WEIGHT
;
335 fmt
.dwEffects
= CFE_AUTOCOLOR
| CFE_AUTOBACKCOLOR
;
336 fmt
.yHeight
= 12*20; /* 12pt */
337 fmt
.wWeight
= FW_NORMAL
;
338 fmt
.bUnderlineType
= CFU_UNDERLINENONE
;
341 fmt
.dwMask
= CFM_BOLD
| CFM_WEIGHT
;
342 fmt
.dwEffects
= info
->rtfParam
? CFE_BOLD
: 0;
343 fmt
.wWeight
= info
->rtfParam
? FW_BOLD
: FW_NORMAL
;
346 fmt
.dwMask
= CFM_ITALIC
;
347 fmt
.dwEffects
= info
->rtfParam
? fmt
.dwMask
: 0;
350 fmt
.dwMask
= CFM_UNDERLINETYPE
;
351 fmt
.bUnderlineType
= info
->rtfParam
? CFU_CF1UNDERLINE
: CFU_UNDERLINENONE
;
353 case rtfDotUnderline
:
354 fmt
.dwMask
= CFM_UNDERLINETYPE
;
355 fmt
.bUnderlineType
= info
->rtfParam
? CFU_UNDERLINEDOTTED
: CFU_UNDERLINENONE
;
358 fmt
.dwMask
= CFM_UNDERLINETYPE
;
359 fmt
.bUnderlineType
= info
->rtfParam
? CFU_UNDERLINEDOUBLE
: CFU_UNDERLINENONE
;
361 case rtfWordUnderline
:
362 fmt
.dwMask
= CFM_UNDERLINETYPE
;
363 fmt
.bUnderlineType
= info
->rtfParam
? CFU_UNDERLINEWORD
: CFU_UNDERLINENONE
;
366 fmt
.dwMask
= CFM_UNDERLINETYPE
;
367 fmt
.bUnderlineType
= CFU_UNDERLINENONE
;
370 fmt
.dwMask
= CFM_STRIKEOUT
;
371 fmt
.dwEffects
= info
->rtfParam
? fmt
.dwMask
: 0;
375 case rtfSubScrShrink
:
376 case rtfSuperScrShrink
:
378 fmt
.dwMask
= CFM_SUBSCRIPT
|CFM_SUPERSCRIPT
;
379 if (info
->rtfMinor
== rtfSubScrShrink
) fmt
.dwEffects
= CFE_SUBSCRIPT
;
380 if (info
->rtfMinor
== rtfSuperScrShrink
) fmt
.dwEffects
= CFE_SUPERSCRIPT
;
381 if (info
->rtfMinor
== rtfNoSuperSub
) fmt
.dwEffects
= 0;
384 fmt
.dwMask
= CFM_HIDDEN
;
385 fmt
.dwEffects
= info
->rtfParam
? fmt
.dwMask
: 0;
388 fmt
.dwMask
= CFM_BACKCOLOR
;
390 if (info
->rtfParam
== 0)
391 fmt
.dwEffects
= CFE_AUTOBACKCOLOR
;
392 else if (info
->rtfParam
!= rtfNoParam
)
394 RTFColor
*c
= RTFGetColor(info
, info
->rtfParam
);
395 fmt
.crTextColor
= (c
->rtfCBlue
<<16)|(c
->rtfCGreen
<<8)|(c
->rtfCRed
);
399 fmt
.dwMask
= CFM_COLOR
;
401 if (info
->rtfParam
== 0)
402 fmt
.dwEffects
= CFE_AUTOCOLOR
;
403 else if (info
->rtfParam
!= rtfNoParam
)
405 RTFColor
*c
= RTFGetColor(info
, info
->rtfParam
);
407 fmt
.crTextColor
= (c
->rtfCBlue
<<16)|(c
->rtfCGreen
<<8)|(c
->rtfCRed
);
413 if (info
->rtfParam
!= rtfNoParam
)
415 RTFFont
*f
= RTFGetFont(info
, info
->rtfParam
);
418 MultiByteToWideChar(CP_ACP
, 0, f
->rtfFName
, -1, fmt
.szFaceName
, sizeof(fmt
.szFaceName
)/sizeof(WCHAR
));
419 fmt
.szFaceName
[sizeof(fmt
.szFaceName
)/sizeof(WCHAR
)-1] = '\0';
420 fmt
.bCharSet
= f
->rtfFCharSet
;
421 fmt
.dwMask
= CFM_FACE
| CFM_CHARSET
;
422 fmt
.bPitchAndFamily
= f
->rtfFPitch
| (f
->rtfFFamily
<< 4);
427 fmt
.dwMask
= CFM_SIZE
;
428 if (info
->rtfParam
!= rtfNoParam
)
429 fmt
.yHeight
= info
->rtfParam
*10;
434 RTFFlushOutputBuffer(info
);
435 /* FIXME too slow ? how come ? */
436 style2
= ME_ApplyStyle(info
->style
, &fmt
);
437 ME_ReleaseStyle(info
->style
);
438 info
->style
= style2
;
439 info
->styleChanged
= TRUE
;
443 /* FIXME this function doesn't get any information about context of the RTF tag, which is very bad,
444 the same tags mean different things in different contexts */
445 static void ME_RTFParAttrHook(RTF_Info
*info
)
448 fmt
.cbSize
= sizeof(fmt
);
451 switch(info
->rtfMinor
)
453 case rtfParDef
: /* restores default paragraph attributes */
454 fmt
.dwMask
= PFM_ALIGNMENT
| PFM_BORDER
| PFM_LINESPACING
| PFM_TABSTOPS
| PFM_OFFSET
|
455 PFM_RIGHTINDENT
| PFM_SPACEAFTER
| PFM_SPACEBEFORE
| PFM_STARTINDENT
;
456 /* TODO: numbering, shading */
457 fmt
.wAlignment
= PFA_LEFT
;
459 fmt
.dxOffset
= fmt
.dxStartIndent
= fmt
.dxRightIndent
= 0;
460 fmt
.wBorderWidth
= fmt
.wBorders
= 0;
461 fmt
.wBorderSpace
= 0;
462 fmt
.bLineSpacingRule
= 0;
463 fmt
.dySpaceBefore
= fmt
.dySpaceAfter
= 0;
464 fmt
.dyLineSpacing
= 0;
465 RTFFlushOutputBuffer(info
);
466 ME_GetParagraph(info
->editor
->pCursors
[0].pRun
)->member
.para
.bTable
= FALSE
;
470 ME_DisplayItem
*para
;
472 RTFFlushOutputBuffer(info
);
473 para
= ME_GetParagraph(info
->editor
->pCursors
[0].pRun
);
474 assert(para
->member
.para
.pCells
);
475 para
->member
.para
.bTable
= TRUE
;
479 ME_GetSelectionParaFormat(info
->editor
, &fmt
);
480 fmt
.dwMask
|= PFM_STARTINDENT
| PFM_OFFSET
;
481 fmt
.dxStartIndent
+= info
->rtfParam
;
482 fmt
.dxOffset
= -info
->rtfParam
;
485 /* we assume rtfLeftIndent is always specified before rtfFirstIndent */
486 ME_GetSelectionParaFormat(info
->editor
, &fmt
);
487 fmt
.dwMask
|= PFM_STARTINDENT
;
488 fmt
.dxStartIndent
= info
->rtfParam
;
492 fmt
.dwMask
= PFM_RIGHTINDENT
;
493 fmt
.dxRightIndent
= info
->rtfParam
;
497 fmt
.dwMask
= PFM_ALIGNMENT
;
498 fmt
.wAlignment
= PFA_LEFT
;
501 fmt
.dwMask
= PFM_ALIGNMENT
;
502 fmt
.wAlignment
= PFA_RIGHT
;
505 fmt
.dwMask
= PFM_ALIGNMENT
;
506 fmt
.wAlignment
= PFA_CENTER
;
509 ME_GetSelectionParaFormat(info
->editor
, &fmt
);
510 if (!(fmt
.dwMask
& PFM_TABSTOPS
))
512 fmt
.dwMask
|= PFM_TABSTOPS
;
515 if (fmt
.cTabCount
< MAX_TAB_STOPS
)
516 fmt
.rgxTabs
[fmt
.cTabCount
++] = info
->rtfParam
;
519 fmt
.dwMask
= PFM_KEEP
;
520 fmt
.wEffects
= PFE_KEEP
;
522 case rtfNoWidowControl
:
523 fmt
.dwMask
= PFM_NOWIDOWCONTROL
;
524 fmt
.wEffects
= PFE_NOWIDOWCONTROL
;
527 fmt
.dwMask
= PFM_KEEPNEXT
;
528 fmt
.wEffects
= PFE_KEEPNEXT
;
531 fmt
.dwMask
= PFM_SPACEAFTER
;
532 fmt
.dySpaceAfter
= info
->rtfParam
;
535 fmt
.dwMask
= PFM_SPACEBEFORE
;
536 fmt
.dySpaceBefore
= info
->rtfParam
;
538 case rtfSpaceBetween
:
539 fmt
.dwMask
= PFM_LINESPACING
;
540 if ((int)info
->rtfParam
> 0)
542 fmt
.dyLineSpacing
= info
->rtfParam
;
543 fmt
.bLineSpacingRule
= 3;
547 fmt
.dyLineSpacing
= info
->rtfParam
;
548 fmt
.bLineSpacingRule
= 4;
550 case rtfSpaceMultiply
:
551 fmt
.dwMask
= PFM_LINESPACING
;
552 fmt
.dyLineSpacing
= info
->rtfParam
* 20;
553 fmt
.bLineSpacingRule
= 5;
556 fmt
.dwMask
= PFM_NUMBERING
;
557 fmt
.wNumbering
= PFN_BULLET
;
560 fmt
.dwMask
= PFM_NUMBERING
;
561 fmt
.wNumbering
= 2; /* FIXME: MSDN says it's not used ?? */
563 case rtfParNumDecimal
:
564 fmt
.dwMask
= PFM_NUMBERING
;
565 fmt
.wNumbering
= 2; /* FIXME: MSDN says it's not used ?? */
567 case rtfParNumIndent
:
568 fmt
.dwMask
= PFM_NUMBERINGTAB
;
569 fmt
.wNumberingTab
= info
->rtfParam
;
571 case rtfParNumStartAt
:
572 fmt
.dwMask
= PFM_NUMBERINGSTART
;
573 fmt
.wNumberingStart
= info
->rtfParam
;
576 ME_GetSelectionParaFormat(info
->editor
, &fmt
);
577 if (!(fmt
.dwMask
& PFM_BORDER
))
579 fmt
.dwMask
|= PFM_BORDER
;
580 fmt
.wBorderSpace
= 0;
581 fmt
.wBorderWidth
= 1;
587 ME_GetSelectionParaFormat(info
->editor
, &fmt
);
588 if (!(fmt
.dwMask
& PFM_BORDER
))
590 fmt
.dwMask
|= PFM_BORDER
;
591 fmt
.wBorderSpace
= 0;
592 fmt
.wBorderWidth
= 1;
598 ME_GetSelectionParaFormat(info
->editor
, &fmt
);
599 if (!(fmt
.dwMask
& PFM_BORDER
))
601 fmt
.dwMask
|= PFM_BORDER
;
602 fmt
.wBorderSpace
= 0;
603 fmt
.wBorderWidth
= 1;
608 case rtfBorderBottom
:
609 ME_GetSelectionParaFormat(info
->editor
, &fmt
);
610 if (!(fmt
.dwMask
& PFM_BORDER
))
612 fmt
.dwMask
|= PFM_BORDER
;
613 fmt
.wBorderSpace
= 0;
614 fmt
.wBorderWidth
= 1;
619 case rtfBorderSingle
:
620 ME_GetSelectionParaFormat(info
->editor
, &fmt
);
621 /* we assume that borders have been created before (RTF spec) */
622 fmt
.wBorders
&= ~0x700;
623 fmt
.wBorders
|= 1 << 8;
626 ME_GetSelectionParaFormat(info
->editor
, &fmt
);
627 /* we assume that borders have been created before (RTF spec) */
628 fmt
.wBorders
&= ~0x700;
629 fmt
.wBorders
|= 2 << 8;
631 case rtfBorderShadow
:
632 ME_GetSelectionParaFormat(info
->editor
, &fmt
);
633 /* we assume that borders have been created before (RTF spec) */
634 fmt
.wBorders
&= ~0x700;
635 fmt
.wBorders
|= 10 << 8;
637 case rtfBorderDouble
:
638 ME_GetSelectionParaFormat(info
->editor
, &fmt
);
639 /* we assume that borders have been created before (RTF spec) */
640 fmt
.wBorders
&= ~0x700;
641 fmt
.wBorders
|= 7 << 8;
644 ME_GetSelectionParaFormat(info
->editor
, &fmt
);
645 /* we assume that borders have been created before (RTF spec) */
646 fmt
.wBorders
&= ~0x700;
647 fmt
.wBorders
|= 11 << 8;
650 ME_GetSelectionParaFormat(info
->editor
, &fmt
);
651 /* we assume that borders have been created before (RTF spec) */
652 fmt
.wBorderWidth
|= ((info
->rtfParam
/ 15) & 7) << 8;
655 ME_GetSelectionParaFormat(info
->editor
, &fmt
);
656 /* we assume that borders have been created before (RTF spec) */
657 fmt
.wBorderSpace
= info
->rtfParam
;
661 RTFFlushOutputBuffer(info
);
662 /* FIXME too slow ? how come ?*/
663 ME_SetSelectionParaFormat(info
->editor
, &fmt
);
667 static void ME_RTFTblAttrHook(RTF_Info
*info
)
669 ME_DisplayItem
*para
;
671 switch (info
->rtfMinor
)
674 RTFFlushOutputBuffer(info
);
675 para
= ME_GetParagraph(info
->editor
->pCursors
[0].pRun
);
677 /* Release possibly inherited cell definitions */
678 ME_DestroyTableCellList(para
);
680 para
->member
.para
.pCells
= ALLOC_OBJ(ME_TableCell
);
681 para
->member
.para
.pCells
->nRightBoundary
= 0;
682 para
->member
.para
.pCells
->next
= NULL
;
683 para
->member
.para
.pLastCell
= para
->member
.para
.pCells
;
686 RTFFlushOutputBuffer(info
);
687 para
= ME_GetParagraph(info
->editor
->pCursors
[0].pRun
);
689 if (para
->member
.para
.pLastCell
->nRightBoundary
)
691 ME_TableCell
*pCell
= ALLOC_OBJ(ME_TableCell
);
694 para
->member
.para
.pLastCell
->next
= pCell
;
695 para
->member
.para
.pLastCell
= pCell
;
697 para
->member
.para
.pLastCell
->nRightBoundary
= info
->rtfParam
;
702 static BOOL
ME_RTFInsertOleObject(RTF_Info
*info
, HENHMETAFILE hemf
, HBITMAP hbmp
,
705 LPOLEOBJECT lpObject
= NULL
;
706 LPSTORAGE lpStorage
= NULL
;
707 LPOLECLIENTSITE lpClientSite
= NULL
;
708 LPDATAOBJECT lpDataObject
= NULL
;
709 LPOLECACHE lpOleCache
= NULL
;
718 stgm
.tymed
= TYMED_ENHMF
;
719 stgm
.u
.hEnhMetaFile
= hemf
;
720 fm
.cfFormat
= CF_ENHMETAFILE
;
724 stgm
.tymed
= TYMED_GDI
;
725 stgm
.u
.hBitmap
= hbmp
;
726 fm
.cfFormat
= CF_BITMAP
;
728 stgm
.pUnkForRelease
= NULL
;
731 fm
.dwAspect
= DVASPECT_CONTENT
;
733 fm
.tymed
= stgm
.tymed
;
735 if (!info
->lpRichEditOle
)
737 CreateIRichEditOle(info
->editor
, (VOID
**)&info
->lpRichEditOle
);
740 if (OleCreateDefaultHandler(&CLSID_NULL
, NULL
, &IID_IOleObject
, (void**)&lpObject
) == S_OK
&&
742 /* FIXME: enable it when rich-edit properly implements this method */
743 IRichEditOle_GetClientSite(info
->lpRichEditOle
, &lpClientSite
) == S_OK
&&
744 IOleObject_SetClientSite(lpObject
, lpClientSite
) == S_OK
&&
746 IOleObject_GetUserClassID(lpObject
, &clsid
) == S_OK
&&
747 IOleObject_QueryInterface(lpObject
, &IID_IOleCache
, (void**)&lpOleCache
) == S_OK
&&
748 IOleCache_Cache(lpOleCache
, &fm
, 0, &conn
) == S_OK
&&
749 IOleObject_QueryInterface(lpObject
, &IID_IDataObject
, (void**)&lpDataObject
) == S_OK
&&
750 IDataObject_SetData(lpDataObject
, &fm
, &stgm
, TRUE
) == S_OK
)
754 reobject
.cbStruct
= sizeof(reobject
);
755 reobject
.cp
= REO_CP_SELECTION
;
756 reobject
.clsid
= clsid
;
757 reobject
.poleobj
= lpObject
;
758 reobject
.pstg
= lpStorage
;
759 reobject
.polesite
= lpClientSite
;
760 /* convert from twips to .01 mm */
761 reobject
.sizel
.cx
= MulDiv(sz
->cx
, 254, 144);
762 reobject
.sizel
.cy
= MulDiv(sz
->cy
, 254, 144);
763 reobject
.dvaspect
= DVASPECT_CONTENT
;
764 reobject
.dwFlags
= 0; /* FIXME */
767 /* FIXME: could be simpler */
768 ret
= IRichEditOle_InsertObject(info
->lpRichEditOle
, &reobject
) == S_OK
;
771 if (lpObject
) IOleObject_Release(lpObject
);
772 if (lpClientSite
) IOleClientSite_Release(lpClientSite
);
773 if (lpStorage
) IStorage_Release(lpStorage
);
774 if (lpDataObject
) IDataObject_Release(lpDataObject
);
775 if (lpOleCache
) IOleCache_Release(lpOleCache
);
780 static void ME_RTFReadPictGroup(RTF_Info
*info
)
784 unsigned bufsz
, bufidx
;
790 enum gfxkind
{gfx_unknown
= 0, gfx_enhmetafile
, gfx_metafile
, gfx_dib
} gfx
= gfx_unknown
;
793 if (info
->rtfClass
== rtfEOF
)
796 /* fetch picture type */
797 if (RTFCheckMM (info
, rtfPictAttr
, rtfWinMetafile
))
799 mfp
.mm
= info
->rtfParam
;
802 else if (RTFCheckMM (info
, rtfPictAttr
, rtfDevIndBitmap
))
804 if (info
->rtfParam
!= 0) FIXME("dibitmap should be 0 (%d)\n", info
->rtfParam
);
807 else if (RTFCheckMM (info
, rtfPictAttr
, rtfEmfBlip
))
809 gfx
= gfx_enhmetafile
;
813 FIXME("%d %d\n", info
->rtfMajor
, info
->rtfMinor
);
817 /* fetch picture attributes */
821 if (info
->rtfClass
== rtfEOF
)
823 if (info
->rtfClass
== rtfText
)
825 if (!RTFCheckCM (info
, rtfControl
, rtfPictAttr
))
827 ERR("Expected picture attribute (%d %d)\n",
828 info
->rtfClass
, info
->rtfMajor
);
831 else if (RTFCheckMM (info
, rtfPictAttr
, rtfPicWid
))
833 if (gfx
== gfx_metafile
) mfp
.xExt
= info
->rtfParam
;
835 else if (RTFCheckMM (info
, rtfPictAttr
, rtfPicHt
))
837 if (gfx
== gfx_metafile
) mfp
.yExt
= info
->rtfParam
;
839 else if (RTFCheckMM (info
, rtfPictAttr
, rtfPicGoalWid
))
840 sz
.cx
= info
->rtfParam
;
841 else if (RTFCheckMM (info
, rtfPictAttr
, rtfPicGoalHt
))
842 sz
.cy
= info
->rtfParam
;
844 FIXME("Non supported attribute: %d %d %d\n", info
->rtfClass
, info
->rtfMajor
, info
->rtfMinor
);
846 /* fetch picture data */
849 buffer
= HeapAlloc(GetProcessHeap(), 0, bufsz
);
850 val
= info
->rtfMajor
;
851 for (flip
= TRUE
;; flip
= !flip
)
854 if (info
->rtfClass
== rtfEOF
)
856 HeapFree(GetProcessHeap(), 0, buffer
);
857 return; /* Warn ?? */
859 if (RTFCheckCM(info
, rtfGroup
, rtfEndGroup
))
861 if (info
->rtfClass
!= rtfText
) goto skip_group
;
864 if (bufidx
>= bufsz
&&
865 !(buffer
= HeapReAlloc(GetProcessHeap(), 0, buffer
, bufsz
+= 1024)))
867 buffer
[bufidx
++] = RTFCharToHex(val
) * 16 + RTFCharToHex(info
->rtfMajor
);
870 val
= info
->rtfMajor
;
872 if (flip
) FIXME("wrong hex string\n");
876 case gfx_enhmetafile
:
877 if ((hemf
= SetEnhMetaFileBits(bufidx
, buffer
)))
878 ME_RTFInsertOleObject(info
, hemf
, NULL
, &sz
);
881 if ((hemf
= SetWinMetaFileBits(bufidx
, buffer
, NULL
, &mfp
)))
882 ME_RTFInsertOleObject(info
, hemf
, NULL
, &sz
);
886 BITMAPINFO
* bi
= (BITMAPINFO
*)buffer
;
888 unsigned nc
= bi
->bmiHeader
.biClrUsed
;
890 /* not quite right, especially for bitfields type of compression */
891 if (!nc
&& bi
->bmiHeader
.biBitCount
<= 8)
892 nc
= 1 << bi
->bmiHeader
.biBitCount
;
893 if ((hbmp
= CreateDIBitmap(hdc
, &bi
->bmiHeader
,
894 CBM_INIT
, (char*)(bi
+ 1) + nc
* sizeof(RGBQUAD
),
895 bi
, DIB_RGB_COLORS
)))
896 ME_RTFInsertOleObject(info
, NULL
, hbmp
, &sz
);
903 HeapFree(GetProcessHeap(), 0, buffer
);
904 RTFRouteToken (info
); /* feed "}" back to router */
907 HeapFree(GetProcessHeap(), 0, buffer
);
909 RTFRouteToken(info
); /* feed "}" back to router */
912 /* for now, lookup the \result part and use it, whatever the object */
913 static void ME_RTFReadObjectGroup(RTF_Info
*info
)
918 if (info
->rtfClass
== rtfEOF
)
920 if (RTFCheckCM(info
, rtfGroup
, rtfEndGroup
))
922 if (RTFCheckCM(info
, rtfGroup
, rtfBeginGroup
))
925 if (info
->rtfClass
== rtfEOF
)
927 if (RTFCheckCMM(info
, rtfControl
, rtfDestination
, rtfObjResult
))
931 while (RTFGetToken (info
) != rtfEOF
)
933 if (info
->rtfClass
== rtfGroup
)
935 if (info
->rtfMajor
== rtfBeginGroup
) level
++;
936 else if (info
->rtfMajor
== rtfEndGroup
&& --level
< 0) break;
941 else RTFSkipGroup(info
);
944 if (!RTFCheckCM (info
, rtfControl
, rtfObjAttr
))
946 FIXME("Non supported attribute: %d %d %d\n", info
->rtfClass
, info
->rtfMajor
, info
->rtfMinor
);
950 RTFRouteToken(info
); /* feed "}" back to router */
953 static void ME_RTFReadHook(RTF_Info
*info
) {
954 switch(info
->rtfClass
)
957 switch(info
->rtfMajor
)
960 if (info
->stackTop
< maxStack
) {
961 info
->stack
[info
->stackTop
].fmt
= info
->style
->fmt
;
962 info
->stack
[info
->stackTop
].codePage
= info
->codePage
;
963 info
->stack
[info
->stackTop
].unicodeLength
= info
->unicodeLength
;
966 info
->styleChanged
= FALSE
;
971 RTFFlushOutputBuffer(info
);
973 if (info
->stackTop
<=0) {
974 info
->rtfClass
= rtfEOF
;
977 assert(info
->stackTop
>= 0);
978 if (info
->styleChanged
)
980 /* FIXME too slow ? how come ? */
981 s
= ME_ApplyStyle(info
->style
, &info
->stack
[info
->stackTop
].fmt
);
982 ME_ReleaseStyle(info
->style
);
984 info
->codePage
= info
->stack
[info
->stackTop
].codePage
;
985 info
->unicodeLength
= info
->stack
[info
->stackTop
].unicodeLength
;
992 switch(info
->rtfMajor
)
995 ME_RTFCharAttrHook(info
);
998 ME_RTFParAttrHook(info
);
1001 ME_RTFTblAttrHook(info
);
1003 case rtfSpecialChar
:
1004 if (info
->rtfMinor
== rtfCell
)
1006 RTFFlushOutputBuffer(info
);
1007 ME_InsertTableCellFromCursor(info
->editor
, 0);
1015 ME_StreamInFill(ME_InStream
*stream
)
1017 stream
->editstream
->dwError
= stream
->editstream
->pfnCallback(stream
->editstream
->dwCookie
,
1018 (BYTE
*)stream
->buffer
,
1019 sizeof(stream
->buffer
),
1020 (LONG
*)&stream
->dwSize
);
1024 static LRESULT
ME_StreamIn(ME_TextEditor
*editor
, DWORD format
, EDITSTREAM
*stream
, BOOL stripLastCR
)
1028 int from
, to
, to2
, nUndoMode
;
1029 int nEventMask
= editor
->nEventMask
;
1030 ME_InStream inStream
;
1031 BOOL invalidRTF
= FALSE
;
1033 TRACE("stream==%p hWnd==%p format==0x%X\n", stream
, editor
->hWnd
, format
);
1034 editor
->nEventMask
= 0;
1036 ME_GetSelection(editor
, &from
, &to
);
1037 if ((format
& SFF_SELECTION
) && (editor
->mode
& TM_RICHTEXT
)) {
1038 style
= ME_GetSelectionInsertStyle(editor
);
1040 ME_InternalDeleteText(editor
, from
, to
-from
);
1043 style
= editor
->pBuffer
->pDefaultStyle
;
1044 ME_AddRefStyle(style
);
1045 SendMessageA(editor
->hWnd
, EM_SETSEL
, 0, 0);
1046 ME_InternalDeleteText(editor
, 0, ME_GetTextLength(editor
));
1048 ME_ClearTempStyle(editor
);
1049 /* FIXME restore default paragraph formatting ! */
1053 /* Back up undo mode to a local variable */
1054 nUndoMode
= editor
->nUndoMode
;
1056 /* Only create an undo if SFF_SELECTION is set */
1057 if (!(format
& SFF_SELECTION
))
1058 editor
->nUndoMode
= umIgnore
;
1060 inStream
.editstream
= stream
;
1061 inStream
.editstream
->dwError
= 0;
1062 inStream
.dwSize
= 0;
1063 inStream
.dwUsed
= 0;
1065 if (format
& SF_RTF
)
1067 /* Check if it's really RTF, and if it is not, use plain text */
1068 ME_StreamInFill(&inStream
);
1069 if (!inStream
.editstream
->dwError
)
1071 if ((!editor
->bEmulateVersion10
&& strncmp(inStream
.buffer
, "{\\rtf", 5) && strncmp(inStream
.buffer
, "{\\urtf", 6))
1072 || (editor
->bEmulateVersion10
&& *inStream
.buffer
!= '{'))
1075 inStream
.editstream
->dwError
= -16;
1080 if (!invalidRTF
&& !inStream
.editstream
->dwError
)
1082 if (format
& SF_RTF
) {
1083 /* setup the RTF parser */
1084 memset(&parser
, 0, sizeof parser
);
1085 RTFSetEditStream(&parser
, &inStream
);
1086 parser
.rtfFormat
= format
&(SF_TEXT
|SF_RTF
);
1087 parser
.hwndEdit
= editor
->hWnd
;
1088 parser
.editor
= editor
;
1089 parser
.style
= style
;
1090 WriterInit(&parser
);
1092 RTFSetReadHook(&parser
, ME_RTFReadHook
);
1093 RTFSetDestinationCallback(&parser
, rtfPict
, ME_RTFReadPictGroup
);
1094 RTFSetDestinationCallback(&parser
, rtfObject
, ME_RTFReadObjectGroup
);
1097 /* do the parsing */
1099 RTFFlushOutputBuffer(&parser
);
1100 RTFDestroy(&parser
);
1101 if (parser
.lpRichEditOle
)
1102 IRichEditOle_Release(parser
.lpRichEditOle
);
1104 if (!inStream
.editstream
->dwError
&& parser
.stackTop
> 0)
1105 inStream
.editstream
->dwError
= HRESULT_FROM_WIN32(ERROR_HANDLE_EOF
);
1107 /* Remove last line break, as mandated by tests. This is not affected by
1108 CR/LF counters, since RTF streaming presents only \para tokens, which
1109 are converted according to the standard rules: \r for 2.0, \r\n for 1.0
1113 ME_GetSelection(editor
, &newfrom
, &newto
);
1114 if (newto
> to
+ (editor
->bEmulateVersion10
? 1 : 0)) {
1115 WCHAR lastchar
[3] = {'\0', '\0'};
1116 int linebreakSize
= editor
->bEmulateVersion10
? 2 : 1;
1118 ME_GetTextW(editor
, lastchar
, newto
- linebreakSize
, linebreakSize
, 0);
1119 if (lastchar
[0] == '\r' && (lastchar
[1] == '\n' || lastchar
[1] == '\0')) {
1120 ME_InternalDeleteText(editor
, newto
- linebreakSize
, linebreakSize
);
1125 style
= parser
.style
;
1127 else if (format
& SF_TEXT
)
1128 ME_StreamInText(editor
, format
, &inStream
, style
);
1130 ERR("EM_STREAMIN without SF_TEXT or SF_RTF\n");
1131 ME_GetSelection(editor
, &to
, &to2
);
1132 /* put the cursor at the top */
1133 if (!(format
& SFF_SELECTION
))
1134 SendMessageA(editor
->hWnd
, EM_SETSEL
, 0, 0);
1137 /* Restore saved undo mode */
1138 editor
->nUndoMode
= nUndoMode
;
1140 /* even if we didn't add an undo, we need to commit anything on the stack */
1141 ME_CommitUndo(editor
);
1143 /* If SFF_SELECTION isn't set, delete any undos from before we started too */
1144 if (!(format
& SFF_SELECTION
))
1145 ME_EmptyUndoStack(editor
);
1147 ME_ReleaseStyle(style
);
1148 editor
->nEventMask
= nEventMask
;
1149 ME_UpdateRepaint(editor
);
1150 if (!(format
& SFF_SELECTION
)) {
1151 ME_ClearTempStyle(editor
);
1153 HideCaret(editor
->hWnd
);
1154 ME_MoveCaret(editor
);
1155 ShowCaret(editor
->hWnd
);
1156 ME_SendSelChange(editor
);
1157 ME_SendRequestResize(editor
, FALSE
);
1163 typedef struct tagME_RTFStringStreamStruct
1168 } ME_RTFStringStreamStruct
;
1170 static DWORD CALLBACK
ME_ReadFromRTFString(DWORD_PTR dwCookie
, LPBYTE lpBuff
, LONG cb
, LONG
*pcb
)
1172 ME_RTFStringStreamStruct
*pStruct
= (ME_RTFStringStreamStruct
*)dwCookie
;
1175 count
= min(cb
, pStruct
->length
- pStruct
->pos
);
1176 memmove(lpBuff
, pStruct
->string
+ pStruct
->pos
, count
);
1177 pStruct
->pos
+= count
;
1183 ME_StreamInRTFString(ME_TextEditor
*editor
, BOOL selection
, char *string
)
1186 ME_RTFStringStreamStruct data
;
1188 data
.string
= string
;
1189 data
.length
= strlen(string
);
1191 es
.dwCookie
= (DWORD
)&data
;
1192 es
.pfnCallback
= ME_ReadFromRTFString
;
1193 ME_StreamIn(editor
, SF_RTF
| (selection
? SFF_SELECTION
: 0), &es
, FALSE
);
1198 ME_FindItemAtOffset(ME_TextEditor
*editor
, ME_DIType nItemType
, int nOffset
, int *nItemOffset
)
1200 ME_DisplayItem
*item
= ME_FindItemFwd(editor
->pBuffer
->pFirst
, diParagraph
);
1203 while (item
&& item
->member
.para
.next_para
->member
.para
.nCharOfs
<= nOffset
)
1204 item
= ME_FindItemFwd(item
, diParagraph
);
1209 nOffset
-= item
->member
.para
.nCharOfs
;
1210 if (nItemType
== diParagraph
) {
1212 *nItemOffset
= nOffset
;
1217 item
= ME_FindItemFwd(item
, diRun
);
1218 runLength
= ME_StrLen(item
->member
.run
.strText
);
1219 if (item
->member
.run
.nFlags
& MERF_ENDPARA
)
1220 runLength
= item
->member
.run
.nCR
+ item
->member
.run
.nLF
;
1221 } while (item
&& (item
->member
.run
.nCharOfs
+ runLength
<= nOffset
));
1223 nOffset
-= item
->member
.run
.nCharOfs
;
1225 /* Special case: nOffset may not point exactly at the division between the
1226 \r and the \n in 1.0 emulation. If such a case happens, it is sent
1227 into the next run, if one exists
1229 if ( item
->member
.run
.nFlags
& MERF_ENDPARA
1230 && nOffset
== item
->member
.run
.nCR
1231 && item
->member
.run
.nLF
> 0) {
1232 ME_DisplayItem
*nextItem
;
1233 nextItem
= ME_FindItemFwd(item
, diRun
);
1240 *nItemOffset
= nOffset
;
1247 ME_FindText(ME_TextEditor
*editor
, DWORD flags
, const CHARRANGE
*chrg
, const WCHAR
*text
, CHARRANGE
*chrgText
)
1249 const int nLen
= lstrlenW(text
);
1250 const int nTextLen
= ME_GetTextLength(editor
);
1253 ME_DisplayItem
*item
;
1254 ME_DisplayItem
*para
;
1255 WCHAR wLastChar
= ' ';
1257 TRACE("flags==0x%08x, chrg->cpMin==%d, chrg->cpMax==%d text==%s\n",
1258 flags
, chrg
->cpMin
, chrg
->cpMax
, debugstr_w(text
));
1260 if (flags
& ~(FR_DOWN
| FR_MATCHCASE
| FR_WHOLEWORD
))
1261 FIXME("Flags 0x%08x not implemented\n",
1262 flags
& ~(FR_DOWN
| FR_MATCHCASE
| FR_WHOLEWORD
));
1265 if (chrg
->cpMax
== -1)
1268 nMax
= chrg
->cpMax
> nTextLen
? nTextLen
: chrg
->cpMax
;
1270 /* In 1.0 emulation, if cpMax reaches end of text, add the FR_DOWN flag */
1271 if (editor
->bEmulateVersion10
&& nMax
== nTextLen
)
1276 /* In 1.0 emulation, cpMin must always be no greater than cpMax */
1277 if (editor
->bEmulateVersion10
&& nMax
< nMin
)
1281 chrgText
->cpMin
= -1;
1282 chrgText
->cpMax
= -1;
1287 /* when searching up, if cpMin < cpMax, then instead of searching
1288 * on [cpMin,cpMax], we search on [0,cpMin], otherwise, search on
1289 * [cpMax, cpMin]. The exception is when cpMax is -1, in which
1290 * case, it is always bigger than cpMin.
1292 if (!editor
->bEmulateVersion10
&& !(flags
& FR_DOWN
))
1296 nMax
= nMin
> nTextLen
? nTextLen
: nMin
;
1297 if (nMin
< nSwap
|| chrg
->cpMax
== -1)
1303 if (!nLen
|| nMin
< 0 || nMax
< 0 || nMax
< nMin
)
1306 chrgText
->cpMin
= chrgText
->cpMax
= -1;
1310 if (flags
& FR_DOWN
) /* Forward search */
1312 /* If possible, find the character before where the search starts */
1313 if ((flags
& FR_WHOLEWORD
) && nMin
)
1316 item
= ME_FindItemAtOffset(editor
, diRun
, nStart
, &nStart
);
1320 chrgText
->cpMin
= chrgText
->cpMax
= -1;
1323 wLastChar
= item
->member
.run
.strText
->szData
[nStart
];
1327 item
= ME_FindItemAtOffset(editor
, diRun
, nStart
, &nStart
);
1331 chrgText
->cpMin
= chrgText
->cpMax
= -1;
1335 para
= ME_GetParagraph(item
);
1337 && para
->member
.para
.nCharOfs
+ item
->member
.run
.nCharOfs
+ nStart
+ nLen
<= nMax
)
1339 ME_DisplayItem
*pCurItem
= item
;
1340 int nCurStart
= nStart
;
1343 while (pCurItem
&& ME_CharCompare(pCurItem
->member
.run
.strText
->szData
[nCurStart
+ nMatched
], text
[nMatched
], (flags
& FR_MATCHCASE
)))
1345 if ((flags
& FR_WHOLEWORD
) && isalnumW(wLastChar
))
1349 if (nMatched
== nLen
)
1351 ME_DisplayItem
*pNextItem
= pCurItem
;
1352 int nNextStart
= nCurStart
;
1355 /* Check to see if next character is a whitespace */
1356 if (flags
& FR_WHOLEWORD
)
1358 if (nCurStart
+ nMatched
== ME_StrLen(pCurItem
->member
.run
.strText
))
1360 pNextItem
= ME_FindItemFwd(pCurItem
, diRun
);
1361 nNextStart
= -nMatched
;
1365 wNextChar
= pNextItem
->member
.run
.strText
->szData
[nNextStart
+ nMatched
];
1369 if (isalnumW(wNextChar
))
1373 nStart
+= para
->member
.para
.nCharOfs
+ item
->member
.run
.nCharOfs
;
1376 chrgText
->cpMin
= nStart
;
1377 chrgText
->cpMax
= nStart
+ nLen
;
1379 TRACE("found at %d-%d\n", nStart
, nStart
+ nLen
);
1382 if (nCurStart
+ nMatched
== ME_StrLen(pCurItem
->member
.run
.strText
))
1384 pCurItem
= ME_FindItemFwd(pCurItem
, diRun
);
1385 para
= ME_GetParagraph(pCurItem
);
1386 nCurStart
= -nMatched
;
1390 wLastChar
= pCurItem
->member
.run
.strText
->szData
[nCurStart
+ nMatched
];
1395 if (nStart
== ME_StrLen(item
->member
.run
.strText
))
1397 item
= ME_FindItemFwd(item
, diRun
);
1398 para
= ME_GetParagraph(item
);
1403 else /* Backward search */
1405 /* If possible, find the character after where the search ends */
1406 if ((flags
& FR_WHOLEWORD
) && nMax
< nTextLen
- 1)
1409 item
= ME_FindItemAtOffset(editor
, diRun
, nEnd
, &nEnd
);
1413 chrgText
->cpMin
= chrgText
->cpMax
= -1;
1416 wLastChar
= item
->member
.run
.strText
->szData
[nEnd
];
1420 item
= ME_FindItemAtOffset(editor
, diRun
, nEnd
, &nEnd
);
1424 chrgText
->cpMin
= chrgText
->cpMax
= -1;
1428 para
= ME_GetParagraph(item
);
1431 && para
->member
.para
.nCharOfs
+ item
->member
.run
.nCharOfs
+ nEnd
- nLen
>= nMin
)
1433 ME_DisplayItem
*pCurItem
= item
;
1437 if (nCurEnd
- nMatched
== 0)
1439 pCurItem
= ME_FindItemBack(pCurItem
, diRun
);
1440 para
= ME_GetParagraph(pCurItem
);
1441 nCurEnd
= ME_StrLen(pCurItem
->member
.run
.strText
) + nMatched
;
1444 while (pCurItem
&& ME_CharCompare(pCurItem
->member
.run
.strText
->szData
[nCurEnd
- nMatched
- 1], text
[nLen
- nMatched
- 1], (flags
& FR_MATCHCASE
)))
1446 if ((flags
& FR_WHOLEWORD
) && isalnumW(wLastChar
))
1450 if (nMatched
== nLen
)
1452 ME_DisplayItem
*pPrevItem
= pCurItem
;
1453 int nPrevEnd
= nCurEnd
;
1456 /* Check to see if previous character is a whitespace */
1457 if (flags
& FR_WHOLEWORD
)
1459 if (nPrevEnd
- nMatched
== 0)
1461 pPrevItem
= ME_FindItemBack(pCurItem
, diRun
);
1463 nPrevEnd
= ME_StrLen(pPrevItem
->member
.run
.strText
) + nMatched
;
1467 wPrevChar
= pPrevItem
->member
.run
.strText
->szData
[nPrevEnd
- nMatched
- 1];
1471 if (isalnumW(wPrevChar
))
1475 nStart
= para
->member
.para
.nCharOfs
+ pCurItem
->member
.run
.nCharOfs
+ nCurEnd
- nMatched
;
1478 chrgText
->cpMin
= nStart
;
1479 chrgText
->cpMax
= nStart
+ nLen
;
1481 TRACE("found at %d-%d\n", nStart
, nStart
+ nLen
);
1484 if (nCurEnd
- nMatched
== 0)
1486 pCurItem
= ME_FindItemBack(pCurItem
, diRun
);
1487 /* Don't care about pCurItem becoming NULL here; it's already taken
1488 * care of in the exterior loop condition */
1489 para
= ME_GetParagraph(pCurItem
);
1490 nCurEnd
= ME_StrLen(pCurItem
->member
.run
.strText
) + nMatched
;
1494 wLastChar
= pCurItem
->member
.run
.strText
->szData
[nCurEnd
- nMatched
- 1];
1501 item
= ME_FindItemBack(item
, diRun
);
1502 para
= ME_GetParagraph(item
);
1503 nEnd
= ME_StrLen(item
->member
.run
.strText
);
1507 TRACE("not found\n");
1509 chrgText
->cpMin
= chrgText
->cpMax
= -1;
1513 /* helper to send a msg filter notification */
1515 ME_FilterEvent(ME_TextEditor
*editor
, UINT msg
, WPARAM
* wParam
, LPARAM
* lParam
)
1519 msgf
.nmhdr
.hwndFrom
= editor
->hWnd
;
1520 msgf
.nmhdr
.idFrom
= GetWindowLongW(editor
->hWnd
, GWLP_ID
);
1521 msgf
.nmhdr
.code
= EN_MSGFILTER
;
1524 msgf
.wParam
= *wParam
;
1525 msgf
.lParam
= *lParam
;
1526 if (SendMessageW(GetParent(editor
->hWnd
), WM_NOTIFY
, msgf
.nmhdr
.idFrom
, (LPARAM
)&msgf
))
1528 *wParam
= msgf
.wParam
;
1529 *lParam
= msgf
.lParam
;
1530 msgf
.wParam
= *wParam
;
1536 ME_KeyDown(ME_TextEditor
*editor
, WORD nKey
)
1538 BOOL ctrl_is_down
= GetKeyState(VK_CONTROL
) & 0x8000;
1539 BOOL shift_is_down
= GetKeyState(VK_SHIFT
) & 0x8000;
1541 if (nKey
!= VK_SHIFT
&& nKey
!= VK_CONTROL
&& nKey
!= VK_MENU
)
1542 editor
->nSelectionType
= stPosition
;
1550 editor
->nUDArrowX
= -1;
1556 ME_CommitUndo(editor
); /* End coalesced undos for typed characters */
1557 ME_ArrowKey(editor
, nKey
, shift_is_down
, ctrl_is_down
);
1561 editor
->nUDArrowX
= -1;
1562 /* FIXME backspace and delete aren't the same, they act different wrt paragraph style of the merged paragraph */
1563 if (GetWindowLongW(editor
->hWnd
, GWL_STYLE
) & ES_READONLY
)
1565 if (ME_IsSelection(editor
))
1567 ME_DeleteSelection(editor
);
1568 ME_CommitUndo(editor
);
1570 else if (nKey
== VK_DELETE
)
1572 /* Delete stops group typing.
1573 * (See MSDN remarks on EM_STOPGROUPTYPING message) */
1574 ME_DeleteTextAtCursor(editor
, 1, 1);
1575 ME_CommitUndo(editor
);
1577 else if (ME_ArrowKey(editor
, VK_LEFT
, FALSE
, FALSE
))
1579 /* Backspace can be grouped for a single undo */
1580 ME_ContinueCoalescingTransaction(editor
);
1581 ME_DeleteTextAtCursor(editor
, 1, 1);
1582 ME_CommitCoalescingUndo(editor
);
1586 ME_UpdateSelectionLinkAttribute(editor
);
1587 ME_UpdateRepaint(editor
);
1588 ME_SendRequestResize(editor
, FALSE
);
1592 if (nKey
!= VK_SHIFT
&& nKey
!= VK_CONTROL
&& nKey
&& nKey
!= VK_MENU
)
1593 editor
->nUDArrowX
= -1;
1600 chf
.cbSize
= sizeof(chf
);
1602 ME_GetSelectionCharFormat(editor
, &chf
);
1603 ME_DumpStyleToBuf(&chf
, buf
);
1604 MessageBoxA(NULL
, buf
, "Style dump", MB_OK
);
1608 ME_CheckCharOffsets(editor
);
1615 static BOOL
ME_SetCursor(ME_TextEditor
*editor
, int x
)
1617 if ((GetWindowLongW(editor
->hWnd
, GWL_STYLE
) & ES_SELECTIONBAR
) &&
1618 (x
< editor
->selofs
||
1619 (editor
->nSelectionType
== stLine
&& GetCapture() == editor
->hWnd
)))
1627 static BOOL
ME_ShowContextMenu(ME_TextEditor
*editor
, int x
, int y
)
1632 if(!editor
->lpOleCallback
)
1634 ME_GetSelection(editor
, &selrange
.cpMin
, &selrange
.cpMax
);
1635 if(selrange
.cpMin
== selrange
.cpMax
)
1636 seltype
|= SEL_EMPTY
;
1639 /* FIXME: Handle objects */
1640 seltype
|= SEL_TEXT
;
1641 if(selrange
.cpMax
-selrange
.cpMin
> 1)
1642 seltype
|= SEL_MULTICHAR
;
1644 if(SUCCEEDED(IRichEditOleCallback_GetContextMenu(editor
->lpOleCallback
, seltype
, NULL
, &selrange
, &menu
)))
1646 TrackPopupMenu(menu
, TPM_LEFTALIGN
| TPM_RIGHTBUTTON
, x
, y
, 0, GetParent(editor
->hWnd
), NULL
);
1652 ME_TextEditor
*ME_MakeEditor(HWND hWnd
) {
1653 ME_TextEditor
*ed
= ALLOC_OBJ(ME_TextEditor
);
1656 ed
->bEmulateVersion10
= FALSE
;
1657 ed
->pBuffer
= ME_MakeText();
1658 ed
->nZoomNumerator
= ed
->nZoomDenominator
= 0;
1659 ME_MakeFirstParagraph(ed
);
1660 ed
->bCaretShown
= FALSE
;
1661 /* The four cursors are for:
1662 * 0 - The position where the caret is shown
1663 * 1 - The anchored end of the selection (for normal selection)
1664 * 2 & 3 - The anchored start and end respectively for word, line,
1665 * or paragraph selection.
1668 ed
->pCursors
= ALLOC_N_OBJ(ME_Cursor
, ed
->nCursors
);
1669 ed
->pCursors
[0].pRun
= ME_FindItemFwd(ed
->pBuffer
->pFirst
, diRun
);
1670 ed
->pCursors
[0].nOffset
= 0;
1671 ed
->pCursors
[1].pRun
= ME_FindItemFwd(ed
->pBuffer
->pFirst
, diRun
);
1672 ed
->pCursors
[1].nOffset
= 0;
1673 ed
->pCursors
[2] = ed
->pCursors
[0];
1674 ed
->pCursors
[3] = ed
->pCursors
[1];
1675 ed
->nLastTotalLength
= ed
->nTotalLength
= 0;
1679 ed
->rgbBackColor
= -1;
1680 ed
->hbrBackground
= GetSysColorBrush(COLOR_WINDOW
);
1681 ed
->bCaretAtEnd
= FALSE
;
1683 ed
->nModifyStep
= 0;
1684 ed
->nTextLimit
= TEXT_LIMIT_DEFAULT
;
1685 ed
->pUndoStack
= ed
->pRedoStack
= ed
->pUndoStackBottom
= NULL
;
1686 ed
->nUndoStackSize
= 0;
1687 ed
->nUndoLimit
= STACK_SIZE_DEFAULT
;
1688 ed
->nUndoMode
= umAddToUndo
;
1689 ed
->nParagraphs
= 1;
1690 ed
->nLastSelStart
= ed
->nLastSelEnd
= 0;
1691 ed
->pLastSelStartPara
= ed
->pLastSelEndPara
= ME_FindItemFwd(ed
->pBuffer
->pFirst
, diParagraph
);
1693 ed
->bWordWrap
= (GetWindowLongW(hWnd
, GWL_STYLE
) & WS_HSCROLL
) ? FALSE
: TRUE
;
1694 ed
->bHideSelection
= FALSE
;
1695 ed
->nInvalidOfs
= -1;
1696 ed
->pfnWordBreak
= NULL
;
1697 ed
->lpOleCallback
= NULL
;
1698 ed
->mode
= TM_RICHTEXT
| TM_MULTILEVELUNDO
| TM_MULTICODEPAGE
;
1699 ed
->AutoURLDetect_bEnable
= FALSE
;
1700 ed
->bHaveFocus
= FALSE
;
1701 for (i
=0; i
<HFONT_CACHE_SIZE
; i
++)
1703 ed
->pFontCache
[i
].nRefs
= 0;
1704 ed
->pFontCache
[i
].nAge
= 0;
1705 ed
->pFontCache
[i
].hFont
= NULL
;
1708 ME_CheckCharOffsets(ed
);
1709 if (GetWindowLongW(hWnd
, GWL_STYLE
) & ES_SELECTIONBAR
)
1710 ed
->selofs
= SELECTIONBAR_WIDTH
;
1713 ed
->nSelectionType
= stPosition
;
1715 if (GetWindowLongW(hWnd
, GWL_STYLE
) & ES_PASSWORD
)
1716 ed
->cPasswordMask
= '*';
1718 ed
->cPasswordMask
= 0;
1720 ed
->notified_cr
.cpMin
= ed
->notified_cr
.cpMax
= 0;
1725 typedef struct tagME_GlobalDestStruct
1729 } ME_GlobalDestStruct
;
1731 static DWORD CALLBACK
ME_ReadFromHGLOBALUnicode(DWORD_PTR dwCookie
, LPBYTE lpBuff
, LONG cb
, LONG
*pcb
)
1733 ME_GlobalDestStruct
*pData
= (ME_GlobalDestStruct
*)dwCookie
;
1738 pDest
= (WORD
*)lpBuff
;
1739 pSrc
= (WORD
*)GlobalLock(pData
->hData
);
1740 for (i
= 0; i
<cb
&& pSrc
[pData
->nLength
+i
]; i
++) {
1741 pDest
[i
] = pSrc
[pData
->nLength
+i
];
1743 pData
->nLength
+= i
;
1745 GlobalUnlock(pData
->hData
);
1749 static DWORD CALLBACK
ME_ReadFromHGLOBALRTF(DWORD_PTR dwCookie
, LPBYTE lpBuff
, LONG cb
, LONG
*pcb
)
1751 ME_GlobalDestStruct
*pData
= (ME_GlobalDestStruct
*)dwCookie
;
1756 pSrc
= (BYTE
*)GlobalLock(pData
->hData
);
1757 for (i
= 0; i
<cb
&& pSrc
[pData
->nLength
+i
]; i
++) {
1758 pDest
[i
] = pSrc
[pData
->nLength
+i
];
1760 pData
->nLength
+= i
;
1762 GlobalUnlock(pData
->hData
);
1767 void ME_DestroyEditor(ME_TextEditor
*editor
)
1769 ME_DisplayItem
*pFirst
= editor
->pBuffer
->pFirst
;
1770 ME_DisplayItem
*p
= pFirst
, *pNext
= NULL
;
1773 ME_ClearTempStyle(editor
);
1774 ME_EmptyUndoStack(editor
);
1777 ME_DestroyDisplayItem(p
);
1780 ME_ReleaseStyle(editor
->pBuffer
->pDefaultStyle
);
1781 for (i
=0; i
<HFONT_CACHE_SIZE
; i
++)
1783 if (editor
->pFontCache
[i
].hFont
)
1784 DeleteObject(editor
->pFontCache
[i
].hFont
);
1786 if (editor
->rgbBackColor
!= -1)
1787 DeleteObject(editor
->hbrBackground
);
1788 if(editor
->lpOleCallback
)
1789 IUnknown_Release(editor
->lpOleCallback
);
1791 FREE_OBJ(editor
->pBuffer
);
1792 FREE_OBJ(editor
->pCursors
);
1797 BOOL WINAPI
DllMain(HINSTANCE hinstDLL
, DWORD fdwReason
, LPVOID lpvReserved
)
1802 case DLL_PROCESS_ATTACH
:
1803 DisableThreadLibraryCalls(hinstDLL
);
1804 me_heap
= HeapCreate (0, 0x10000, 0);
1805 if (!ME_RegisterEditorClass(hinstDLL
)) return FALSE
;
1806 hLeft
= LoadCursorW(hinstDLL
, MAKEINTRESOURCEW(OCR_REVERSE
));
1810 case DLL_PROCESS_DETACH
:
1811 UnregisterClassW(RichEdit20W
, 0);
1812 UnregisterClassW(RichEdit50W
, 0);
1813 UnregisterClassA("RichEdit20A", 0);
1814 UnregisterClassA("RichEdit50A", 0);
1815 if (ME_ListBoxRegistered
)
1816 UnregisterClassW(REListBox20W
, 0);
1817 if (ME_ComboBoxRegistered
)
1818 UnregisterClassW(REComboBox20W
, 0);
1820 HeapDestroy (me_heap
);
1828 #define UNSUPPORTED_MSG(e) \
1830 FIXME(#e ": stub\n"); \
1831 return DefWindowProcW(hWnd, msg, wParam, lParam);
1833 static const char * const edit_messages
[] = {
1862 "EM_SETPASSWORDCHAR",
1863 "EM_EMPTYUNDOBUFFER",
1864 "EM_GETFIRSTVISIBLELINE",
1866 "EM_SETWORDBREAKPROC",
1867 "EM_GETWORDBREAKPROC",
1868 "EM_GETPASSWORDCHAR",
1876 static const char * const richedit_messages
[] = {
1881 "EM_EXLINEFROMCHAR",
1887 "EM_GETOLEINTERFACE",
1897 "EM_SETOLECALLBACK",
1899 "EM_SETTARGETDEVICE",
1907 "EM_GETWORDBREAKPROCEX",
1908 "EM_SETWORDBREAKPROCEX",
1910 "EM_UNKNOWN_USER_83",
1915 "EM_STOPGROUPTYPING",
1919 "EM_GETAUTOURLDETECT",
1922 "EM_GETTEXTLENGTHEX",
1925 "EM_UNKNOWN_USER_98",
1926 "EM_UNKNOWN_USER_99",
1927 "EM_SETPUNCTUATION",
1928 "EM_GETPUNCTUATION",
1929 "EM_SETWORDWRAPMODE",
1930 "EM_GETWORDWRAPMODE",
1936 "EM_UNKNOWN_USER_109",
1937 "EM_UNKNOWN_USER_110",
1938 "EM_UNKNOWN_USER_111",
1939 "EM_UNKNOWN_USER_112",
1940 "EM_UNKNOWN_USER_113",
1941 "EM_UNKNOWN_USER_114",
1942 "EM_UNKNOWN_USER_115",
1943 "EM_UNKNOWN_USER_116",
1944 "EM_UNKNOWN_USER_117",
1945 "EM_UNKNOWN_USER_118",
1946 "EM_UNKNOWN_USER_119",
1947 "EM_SETLANGOPTIONS",
1948 "EM_GETLANGOPTIONS",
1949 "EM_GETIMECOMPMODE",
1953 "EM_SETIMEMODEBIAS",
1958 get_msg_name(UINT msg
)
1960 if (msg
>= EM_GETSEL
&& msg
<= EM_CHARFROMPOS
)
1961 return edit_messages
[msg
- EM_GETSEL
];
1962 if (msg
>= EM_CANPASTE
&& msg
<= EM_GETIMEMODEBIAS
)
1963 return richedit_messages
[msg
- EM_CANPASTE
];
1967 static LRESULT
RichEditWndProc_common(HWND hWnd
, UINT msg
, WPARAM wParam
,
1968 LPARAM lParam
, BOOL unicode
)
1970 ME_TextEditor
*editor
= (ME_TextEditor
*)GetWindowLongPtrW(hWnd
, 0);
1972 TRACE("hwnd %p msg %04x (%s) %lx %lx, unicode %d\n",
1973 hWnd
, msg
, get_msg_name(msg
), wParam
, lParam
, unicode
);
1975 if (!editor
&& msg
!= WM_NCCREATE
&& msg
!= WM_NCDESTROY
) {
1976 ERR("called with invalid hWnd %p - application bug?\n", hWnd
);
1982 UNSUPPORTED_MSG(EM_DISPLAYBAND
)
1983 UNSUPPORTED_MSG(EM_FINDWORDBREAK
)
1984 UNSUPPORTED_MSG(EM_FMTLINES
)
1985 UNSUPPORTED_MSG(EM_FORMATRANGE
)
1986 UNSUPPORTED_MSG(EM_GETBIDIOPTIONS
)
1987 UNSUPPORTED_MSG(EM_GETEDITSTYLE
)
1988 UNSUPPORTED_MSG(EM_GETIMECOMPMODE
)
1989 /* UNSUPPORTED_MSG(EM_GETIMESTATUS) missing in Wine headers */
1990 UNSUPPORTED_MSG(EM_GETLANGOPTIONS
)
1991 /* UNSUPPORTED_MSG(EM_GETOLEINTERFACE) separate stub */
1992 UNSUPPORTED_MSG(EM_GETREDONAME
)
1993 UNSUPPORTED_MSG(EM_GETTEXTMODE
)
1994 UNSUPPORTED_MSG(EM_GETTYPOGRAPHYOPTIONS
)
1995 UNSUPPORTED_MSG(EM_GETUNDONAME
)
1996 UNSUPPORTED_MSG(EM_GETWORDBREAKPROCEX
)
1997 UNSUPPORTED_MSG(EM_PASTESPECIAL
)
1998 UNSUPPORTED_MSG(EM_SELECTIONTYPE
)
1999 UNSUPPORTED_MSG(EM_SETBIDIOPTIONS
)
2000 UNSUPPORTED_MSG(EM_SETEDITSTYLE
)
2001 UNSUPPORTED_MSG(EM_SETFONTSIZE
)
2002 UNSUPPORTED_MSG(EM_SETLANGOPTIONS
)
2003 UNSUPPORTED_MSG(EM_SETPALETTE
)
2004 UNSUPPORTED_MSG(EM_SETTABSTOPS
)
2005 UNSUPPORTED_MSG(EM_SETTYPOGRAPHYOPTIONS
)
2006 UNSUPPORTED_MSG(EM_SETWORDBREAKPROCEX
)
2007 UNSUPPORTED_MSG(WM_STYLECHANGING
)
2008 UNSUPPORTED_MSG(WM_STYLECHANGED
)
2009 /* UNSUPPORTED_MSG(WM_UNICHAR) FIXME missing in Wine headers */
2011 /* Messages specific to Richedit controls */
2014 return ME_StreamIn(editor
, wParam
, (EDITSTREAM
*)lParam
, TRUE
);
2016 return ME_StreamOut(editor
, wParam
, (EDITSTREAM
*)lParam
);
2019 UINT code
= DLGC_WANTCHARS
|DLGC_WANTARROWS
;
2020 if(lParam
&& (((LPMSG
)lParam
)->message
== WM_KEYDOWN
))
2022 int vk
= (int)((LPMSG
)lParam
)->wParam
;
2023 /* if style says we want return key */
2024 if((vk
== VK_RETURN
) && (GetWindowLongW(hWnd
, GWL_STYLE
) & ES_WANTRETURN
))
2026 code
|= DLGC_WANTMESSAGE
;
2028 /* we always handle ctrl-tab */
2029 if((vk
== VK_TAB
) && (GetKeyState(VK_CONTROL
) & 0x8000))
2031 code
|= DLGC_WANTMESSAGE
;
2038 CREATESTRUCTW
*pcs
= (CREATESTRUCTW
*)lParam
;
2039 TRACE("WM_NCCREATE: style 0x%08x\n", pcs
->style
);
2040 editor
= ME_MakeEditor(hWnd
);
2041 SetWindowLongPtrW(hWnd
, 0, (LONG_PTR
)editor
);
2044 case EM_EMPTYUNDOBUFFER
:
2045 ME_EmptyUndoStack(editor
);
2049 /* Note: wParam/lParam can be NULL */
2051 PUINT pfrom
= wParam
? (PUINT
)wParam
: &from
;
2052 PUINT pto
= lParam
? (PUINT
)lParam
: &to
;
2053 ME_GetSelection(editor
, (int *)pfrom
, (int *)pto
);
2054 if ((*pfrom
|*pto
) & 0xFFFF0000)
2056 return MAKELONG(*pfrom
,*pto
);
2060 CHARRANGE
*pRange
= (CHARRANGE
*)lParam
;
2061 ME_GetSelection(editor
, &pRange
->cpMin
, &pRange
->cpMax
);
2062 TRACE("EM_EXGETSEL = (%d,%d)\n", pRange
->cpMin
, pRange
->cpMax
);
2065 case EM_SETUNDOLIMIT
:
2067 if ((int)wParam
< 0)
2068 editor
->nUndoLimit
= STACK_SIZE_DEFAULT
;
2070 editor
->nUndoLimit
= min(wParam
, STACK_SIZE_MAX
);
2071 /* Setting a max stack size keeps wine from getting killed
2072 for hogging memory. Windows allocates all this memory at once, so
2073 no program would realistically set a value above our maximum. */
2074 return editor
->nUndoLimit
;
2077 return editor
->pUndoStack
!= NULL
;
2079 return editor
->pRedoStack
!= NULL
;
2080 case WM_UNDO
: /* FIXME: actually not the same */
2082 return ME_Undo(editor
);
2084 return ME_Redo(editor
);
2087 /* these flags are equivalent to the ES_* counterparts */
2088 DWORD mask
= ECO_VERTICAL
| ECO_AUTOHSCROLL
| ECO_AUTOVSCROLL
|
2089 ECO_NOHIDESEL
| ECO_READONLY
| ECO_WANTRETURN
;
2090 DWORD settings
= GetWindowLongW(hWnd
, GWL_STYLE
) & mask
;
2096 /* these flags are equivalent to ES_* counterparts
2097 * ECO_READONLY is already implemented in the code, only requires
2098 * setting the bit to work
2100 DWORD mask
= ECO_VERTICAL
| ECO_AUTOHSCROLL
| ECO_AUTOVSCROLL
|
2101 ECO_NOHIDESEL
| ECO_READONLY
| ECO_WANTRETURN
| ECO_SELECTIONBAR
;
2102 DWORD raw
= GetWindowLongW(hWnd
, GWL_STYLE
);
2103 DWORD settings
= mask
& raw
;
2119 SetWindowLongW(hWnd
, GWL_STYLE
, (raw
& ~mask
) | (settings
& mask
));
2121 if (settings
& ECO_AUTOWORDSELECTION
)
2122 FIXME("ECO_AUTOWORDSELECTION not implemented yet!\n");
2123 if (settings
& ECO_SELECTIONBAR
)
2124 editor
->selofs
= SELECTIONBAR_WIDTH
;
2127 ME_WrapMarkedParagraphs(editor
);
2129 if (settings
& ECO_VERTICAL
)
2130 FIXME("ECO_VERTICAL not implemented yet!\n");
2131 if (settings
& ECO_AUTOHSCROLL
)
2132 FIXME("ECO_AUTOHSCROLL not implemented yet!\n");
2133 if (settings
& ECO_AUTOVSCROLL
)
2134 FIXME("ECO_AUTOVSCROLL not implemented yet!\n");
2135 if (settings
& ECO_NOHIDESEL
)
2136 FIXME("ECO_NOHIDESEL not implemented yet!\n");
2137 if (settings
& ECO_WANTRETURN
)
2138 FIXME("ECO_WANTRETURN not implemented yet!\n");
2144 ME_InvalidateSelection(editor
);
2145 ME_SetSelection(editor
, wParam
, lParam
);
2146 ME_InvalidateSelection(editor
);
2147 ME_SendSelChange(editor
);
2150 case EM_SETSCROLLPOS
:
2152 POINT
*point
= (POINT
*)lParam
;
2153 ME_ScrollAbs(editor
, point
->y
);
2156 case EM_AUTOURLDETECT
:
2158 if (wParam
==1 || wParam
==0)
2160 editor
->AutoURLDetect_bEnable
= (BOOL
)wParam
;
2163 return E_INVALIDARG
;
2165 case EM_GETAUTOURLDETECT
:
2167 return editor
->AutoURLDetect_bEnable
;
2172 CHARRANGE range
= *(CHARRANGE
*)lParam
;
2174 TRACE("EM_EXSETSEL (%d,%d)\n", range
.cpMin
, range
.cpMax
);
2176 ME_InvalidateSelection(editor
);
2177 end
= ME_SetSelection(editor
, range
.cpMin
, range
.cpMax
);
2178 ME_InvalidateSelection(editor
);
2179 ME_SendSelChange(editor
);
2183 case EM_SHOWSCROLLBAR
:
2185 ShowScrollBar(editor
->hWnd
, wParam
, lParam
);
2191 SETTEXTEX
*pStruct
= (SETTEXTEX
*)wParam
;
2195 int oldModify
= editor
->nModifyStep
;
2197 if (!pStruct
) return 0;
2199 TRACE("EM_SETTEXTEX - %s, flags %d, cp %d\n",
2200 pStruct
->codepage
== 1200 ? debugstr_w((LPCWSTR
)lParam
) : debugstr_a((LPCSTR
)lParam
),
2201 pStruct
->flags
, pStruct
->codepage
);
2203 /* FIXME: make use of pStruct->codepage in the to unicode translation */
2204 wszText
= lParam
? ME_ToUnicode(pStruct
->codepage
== 1200, (void *)lParam
) : NULL
;
2205 len
= wszText
? lstrlenW(wszText
) : 0;
2207 if (pStruct
->flags
& ST_SELECTION
) {
2208 ME_GetSelection(editor
, &from
, &to
);
2209 style
= ME_GetSelectionInsertStyle(editor
);
2210 ME_InternalDeleteText(editor
, from
, to
- from
);
2211 if (pStruct
->codepage
!= 1200 && lParam
&& !strncmp((char *)lParam
, "{\\rtf", 5))
2212 ME_StreamInRTFString(editor
, 0, (char *)lParam
);
2213 else ME_InsertTextFromCursor(editor
, 0, wszText
, len
, style
);
2214 ME_ReleaseStyle(style
);
2216 if (editor
->AutoURLDetect_bEnable
) ME_UpdateSelectionLinkAttribute(editor
);
2219 ME_InternalDeleteText(editor
, 0, ME_GetTextLength(editor
));
2220 if (pStruct
->codepage
!= 1200 && lParam
&& !strncmp((char *)lParam
, "{\\rtf", 5))
2221 ME_StreamInRTFString(editor
, 0, (char *)lParam
);
2222 else ME_InsertTextFromCursor(editor
, 0, wszText
, len
, editor
->pBuffer
->pDefaultStyle
);
2225 if (editor
->AutoURLDetect_bEnable
) ME_UpdateLinkAttribute(editor
, 0, -1);
2227 ME_CommitUndo(editor
);
2228 if (!(pStruct
->flags
& ST_KEEPUNDO
))
2230 editor
->nModifyStep
= oldModify
;
2231 ME_EmptyUndoStack(editor
);
2233 ME_UpdateRepaint(editor
);
2236 case EM_SETBKGNDCOLOR
:
2239 if (editor
->rgbBackColor
!= -1) {
2240 DeleteObject(editor
->hbrBackground
);
2241 lColor
= editor
->rgbBackColor
;
2243 else lColor
= GetSysColor(COLOR_WINDOW
);
2247 editor
->rgbBackColor
= -1;
2248 editor
->hbrBackground
= GetSysColorBrush(COLOR_WINDOW
);
2252 editor
->rgbBackColor
= lParam
;
2253 editor
->hbrBackground
= CreateSolidBrush(editor
->rgbBackColor
);
2255 if (editor
->bRedraw
)
2257 InvalidateRect(hWnd
, NULL
, TRUE
);
2263 return editor
->nModifyStep
== 0 ? 0 : -1;
2267 editor
->nModifyStep
= 1;
2269 editor
->nModifyStep
= 0;
2273 case EM_SETREADONLY
:
2275 long nStyle
= GetWindowLongW(hWnd
, GWL_STYLE
);
2277 nStyle
|= ES_READONLY
;
2279 nStyle
&= ~ES_READONLY
;
2280 SetWindowLongW(hWnd
, GWL_STYLE
, nStyle
);
2283 case EM_SETEVENTMASK
:
2285 DWORD nOldMask
= editor
->nEventMask
;
2287 editor
->nEventMask
= lParam
;
2290 case EM_GETEVENTMASK
:
2291 return editor
->nEventMask
;
2292 case EM_SETCHARFORMAT
:
2294 CHARFORMAT2W buf
, *p
;
2295 BOOL bRepaint
= TRUE
;
2296 p
= ME_ToCF2W(&buf
, (CHARFORMAT2W
*)lParam
);
2297 if (p
== NULL
) return 0;
2299 ME_SetDefaultCharFormat(editor
, p
);
2300 else if (wParam
== (SCF_WORD
| SCF_SELECTION
)) {
2301 FIXME("EM_SETCHARFORMAT: word selection not supported\n");
2303 } else if (wParam
== SCF_ALL
) {
2304 if (editor
->mode
& TM_PLAINTEXT
)
2305 ME_SetDefaultCharFormat(editor
, p
);
2307 ME_SetCharFormat(editor
, 0, ME_GetTextLength(editor
), p
);
2308 editor
->nModifyStep
= 1;
2310 } else if (editor
->mode
& TM_PLAINTEXT
) {
2314 ME_GetSelection(editor
, &from
, &to
);
2315 bRepaint
= (from
!= to
);
2316 ME_SetSelectionCharFormat(editor
, p
);
2317 if (from
!= to
) editor
->nModifyStep
= 1;
2319 ME_CommitUndo(editor
);
2321 ME_RewrapRepaint(editor
);
2324 case EM_GETCHARFORMAT
:
2326 CHARFORMAT2W tmp
, *dst
= (CHARFORMAT2W
*)lParam
;
2327 if (dst
->cbSize
!= sizeof(CHARFORMATA
) &&
2328 dst
->cbSize
!= sizeof(CHARFORMATW
) &&
2329 dst
->cbSize
!= sizeof(CHARFORMAT2A
) &&
2330 dst
->cbSize
!= sizeof(CHARFORMAT2W
))
2332 tmp
.cbSize
= sizeof(tmp
);
2334 ME_GetDefaultCharFormat(editor
, &tmp
);
2336 ME_GetSelectionCharFormat(editor
, &tmp
);
2337 ME_CopyToCFAny(dst
, &tmp
);
2340 case EM_SETPARAFORMAT
:
2341 ME_SetSelectionParaFormat(editor
, (PARAFORMAT2
*)lParam
);
2342 ME_RewrapRepaint(editor
);
2343 ME_CommitUndo(editor
);
2345 case EM_GETPARAFORMAT
:
2346 ME_GetSelectionParaFormat(editor
, (PARAFORMAT2
*)lParam
);
2348 case EM_GETFIRSTVISIBLELINE
:
2350 ME_DisplayItem
*p
= editor
->pBuffer
->pFirst
;
2351 int y
= ME_GetYScrollPos(editor
);
2356 p
= ME_FindItemFwd(p
, diStartRowOrParagraphOrEnd
);
2357 if (p
->type
== diTextEnd
)
2359 if (p
->type
== diParagraph
) {
2360 ypara
= p
->member
.para
.nYPos
;
2363 ystart
= ypara
+ p
->member
.row
.nYPos
;
2364 yend
= ystart
+ p
->member
.row
.nHeight
;
2372 case EM_HIDESELECTION
:
2374 editor
->bHideSelection
= (wParam
!= 0);
2375 ME_InvalidateSelection(editor
);
2380 ME_ScrollDown(editor
, lParam
* 8); /* FIXME follow the original */
2381 return TRUE
; /* Should return false if a single line richedit control */
2386 ME_GetSelection(editor
, &from
, &to
);
2387 ME_InternalDeleteText(editor
, from
, to
-from
);
2388 ME_CommitUndo(editor
);
2389 ME_UpdateRepaint(editor
);
2396 LPWSTR wszText
= lParam
? ME_ToUnicode(unicode
, (void *)lParam
) : NULL
;
2397 size_t len
= wszText
? lstrlenW(wszText
) : 0;
2398 TRACE("EM_REPLACESEL - %s\n", debugstr_w(wszText
));
2400 ME_GetSelection(editor
, &from
, &to
);
2401 style
= ME_GetSelectionInsertStyle(editor
);
2402 ME_InternalDeleteText(editor
, from
, to
-from
);
2403 ME_InsertTextFromCursor(editor
, 0, wszText
, len
, style
);
2404 ME_ReleaseStyle(style
);
2405 /* drop temporary style if line end */
2407 * FIXME question: does abc\n mean: put abc,
2408 * clear temp style, put \n? (would require a change)
2410 if (len
>0 && wszText
[len
-1] == '\n')
2411 ME_ClearTempStyle(editor
);
2412 ME_EndToUnicode(unicode
, wszText
);
2413 ME_CommitUndo(editor
);
2414 if (editor
->AutoURLDetect_bEnable
) ME_UpdateSelectionLinkAttribute(editor
);
2416 ME_EmptyUndoStack(editor
);
2417 ME_UpdateRepaint(editor
);
2420 case EM_SCROLLCARET
:
2422 int top
, bottom
; /* row's edges relative to document top */
2424 ME_DisplayItem
*para
, *row
;
2426 nPos
= ME_GetYScrollPos(editor
);
2427 row
= ME_RowStart(editor
->pCursors
[0].pRun
);
2428 para
= ME_GetParagraph(row
);
2429 top
= para
->member
.para
.nYPos
+ row
->member
.row
.nYPos
;
2430 bottom
= top
+ row
->member
.row
.nHeight
;
2432 if (top
< nPos
) /* caret above window */
2433 ME_ScrollAbs(editor
, top
);
2434 else if (nPos
+ editor
->sizeWindow
.cy
< bottom
) /*below*/
2435 ME_ScrollAbs(editor
, bottom
- editor
->sizeWindow
.cy
);
2443 BOOL bRepaint
= LOWORD(lParam
);
2446 wParam
= (WPARAM
)GetStockObject(SYSTEM_FONT
);
2447 GetObjectW((HGDIOBJ
)wParam
, sizeof(LOGFONTW
), &lf
);
2449 ME_CharFormatFromLogFont(hDC
, &lf
, &fmt
);
2450 ReleaseDC(hWnd
, hDC
);
2451 ME_SetCharFormat(editor
, 0, ME_GetTextLength(editor
), &fmt
);
2452 ME_SetDefaultCharFormat(editor
, &fmt
);
2454 ME_CommitUndo(editor
);
2456 ME_RewrapRepaint(editor
);
2461 ME_InternalDeleteText(editor
, 0, ME_GetTextLength(editor
));
2464 TRACE("WM_SETTEXT lParam==%lx\n",lParam
);
2465 if (!unicode
&& !strncmp((char *)lParam
, "{\\rtf", 5))
2467 /* Undocumented: WM_SETTEXT supports RTF text */
2468 ME_StreamInRTFString(editor
, 0, (char *)lParam
);
2472 LPWSTR wszText
= ME_ToUnicode(unicode
, (void *)lParam
);
2473 TRACE("WM_SETTEXT - %s\n", debugstr_w(wszText
)); /* debugstr_w() */
2474 if (lstrlenW(wszText
) > 0)
2478 /* uses default style! */
2479 if (!(GetWindowLongW(hWnd
, GWL_STYLE
) & ES_MULTILINE
))
2484 while (*p
!= '\0' && *p
!= '\r' && *p
!= '\n') p
++;
2487 ME_InsertTextFromCursor(editor
, 0, wszText
, len
, editor
->pBuffer
->pDefaultStyle
);
2489 ME_EndToUnicode(unicode
, wszText
);
2493 TRACE("WM_SETTEXT - NULL\n");
2494 if (editor
->AutoURLDetect_bEnable
)
2496 ME_UpdateLinkAttribute(editor
, 0, -1);
2498 ME_SetSelection(editor
, 0, 0);
2499 editor
->nModifyStep
= 0;
2500 ME_CommitUndo(editor
);
2501 ME_EmptyUndoStack(editor
);
2502 ME_UpdateRepaint(editor
);
2507 UINT nRTFFormat
= RegisterClipboardFormatA("Rich Text Format");
2508 if (IsClipboardFormatAvailable(nRTFFormat
))
2510 if (IsClipboardFormatAvailable(CF_UNICODETEXT
))
2518 ME_GlobalDestStruct gds
;
2519 UINT nRTFFormat
= RegisterClipboardFormatA("Rich Text Format");
2522 if (IsClipboardFormatAvailable(nRTFFormat
))
2523 cf
= nRTFFormat
, dwFormat
= SF_RTF
;
2524 else if (IsClipboardFormatAvailable(CF_UNICODETEXT
))
2525 cf
= CF_UNICODETEXT
, dwFormat
= SF_TEXT
|SF_UNICODE
;
2529 if (!OpenClipboard(hWnd
))
2531 gds
.hData
= GetClipboardData(cf
);
2533 es
.dwCookie
= (DWORD
)&gds
;
2534 es
.pfnCallback
= dwFormat
== SF_RTF
? ME_ReadFromHGLOBALRTF
: ME_ReadFromHGLOBALUnicode
;
2535 ME_StreamIn(editor
, dwFormat
|SFF_SELECTION
, &es
, FALSE
);
2543 LPDATAOBJECT dataObj
= NULL
;
2547 if (editor
->cPasswordMask
)
2548 return 0; /* Copying or Cutting masked text isn't allowed */
2550 ME_GetSelection(editor
, &range
.cpMin
, &range
.cpMax
);
2551 if(editor
->lpOleCallback
)
2552 hr
= IRichEditOleCallback_GetClipboardData(editor
->lpOleCallback
, &range
, RECO_COPY
, &dataObj
);
2553 if(FAILED(hr
) || !dataObj
)
2554 hr
= ME_GetDataObject(editor
, &range
, &dataObj
);
2556 hr
= OleSetClipboard(dataObj
);
2557 IDataObject_Release(dataObj
);
2559 if (SUCCEEDED(hr
) && msg
== WM_CUT
)
2561 ME_InternalDeleteText(editor
, range
.cpMin
, range
.cpMax
-range
.cpMin
);
2562 ME_CommitUndo(editor
);
2563 ME_UpdateRepaint(editor
);
2567 case WM_GETTEXTLENGTH
:
2569 GETTEXTLENGTHEX how
;
2571 /* CR/LF conversion required in 2.0 mode, verbatim in 1.0 mode */
2572 how
.flags
= GTL_CLOSE
| (editor
->bEmulateVersion10
? 0 : GTL_USECRLF
) | GTL_NUMCHARS
;
2573 how
.codepage
= unicode
? 1200 : CP_ACP
;
2574 return ME_GetTextLengthEx(editor
, &how
);
2576 case EM_GETTEXTLENGTHEX
:
2577 return ME_GetTextLengthEx(editor
, (GETTEXTLENGTHEX
*)wParam
);
2582 LPSTR bufferA
= NULL
;
2583 LPWSTR bufferW
= NULL
;
2586 bufferW
= heap_alloc((wParam
+ 2) * sizeof(WCHAR
));
2588 bufferA
= heap_alloc(wParam
+ 2);
2590 ex
.cb
= (wParam
+ 2) * (unicode
? sizeof(WCHAR
) : sizeof(CHAR
));
2591 ex
.flags
= GT_USECRLF
;
2592 ex
.codepage
= unicode
? 1200 : CP_ACP
;
2593 ex
.lpDefaultChar
= NULL
;
2594 ex
.lpUsedDefChar
= NULL
;
2595 rc
= RichEditWndProc_common(hWnd
, EM_GETTEXTEX
, (WPARAM
)&ex
, unicode
? (LPARAM
)bufferW
: (LPARAM
)bufferA
, unicode
);
2599 memcpy((LPWSTR
)lParam
, bufferW
, wParam
* sizeof(WCHAR
));
2600 if (lstrlenW(bufferW
) >= wParam
) rc
= 0;
2604 memcpy((LPSTR
)lParam
, bufferA
, wParam
);
2605 if (strlen(bufferA
) >= wParam
) rc
= 0;
2613 GETTEXTEX
*ex
= (GETTEXTEX
*)wParam
;
2614 int nStart
, nCount
; /* in chars */
2616 if (ex
->flags
& ~(GT_SELECTION
| GT_USECRLF
))
2617 FIXME("GETTEXTEX flags 0x%08x not supported\n", ex
->flags
& ~(GT_SELECTION
| GT_USECRLF
));
2619 if (ex
->flags
& GT_SELECTION
)
2621 ME_GetSelection(editor
, &nStart
, &nCount
);
2627 nCount
= 0x7fffffff;
2629 if (ex
->codepage
== 1200)
2631 nCount
= min(nCount
, ex
->cb
/ sizeof(WCHAR
) - 1);
2632 return ME_GetTextW(editor
, (LPWSTR
)lParam
, nStart
, nCount
, ex
->flags
& GT_USECRLF
);
2636 /* potentially each char may be a CR, why calculate the exact value with O(N) when
2637 we can just take a bigger buffer? :)
2638 The above assumption still holds with CR/LF counters, since CR->CRLF expansion
2639 occurs only in richedit 2.0 mode, in which line breaks have only one CR
2641 int crlfmul
= (ex
->flags
& GT_USECRLF
) ? 2 : 1;
2643 DWORD buflen
= ex
->cb
;
2647 nCount
= min(nCount
, ex
->cb
- 1);
2648 buffer
= heap_alloc((crlfmul
*nCount
+ 1) * sizeof(WCHAR
));
2650 buflen
= ME_GetTextW(editor
, buffer
, nStart
, nCount
, ex
->flags
& GT_USECRLF
);
2651 rc
= WideCharToMultiByte(ex
->codepage
, flags
, buffer
, buflen
+1, (LPSTR
)lParam
, ex
->cb
, ex
->lpDefaultChar
, ex
->lpUsedDefChar
);
2652 if (rc
) rc
--; /* do not count 0 terminator */
2661 TEXTRANGEW tr
; /* W and A differ only by rng->lpstrText */
2662 ME_GetSelection(editor
, &from
, &to
);
2663 tr
.chrg
.cpMin
= from
;
2665 tr
.lpstrText
= (WCHAR
*)lParam
;
2666 return RichEditWndProc_common(hWnd
, EM_GETTEXTRANGE
, 0, (LPARAM
)&tr
, unicode
);
2668 case EM_GETSCROLLPOS
:
2670 POINT
*point
= (POINT
*)lParam
;
2671 point
->x
= 0; /* FIXME side scrolling not implemented */
2672 point
->y
= ME_GetYScrollPos(editor
);
2675 case EM_GETTEXTRANGE
:
2677 TEXTRANGEW
*rng
= (TEXTRANGEW
*)lParam
;
2678 TRACE("EM_GETTEXTRANGE min=%d max=%d unicode=%d emul1.0=%d length=%d\n",
2679 rng
->chrg
.cpMin
, rng
->chrg
.cpMax
, unicode
,
2680 editor
->bEmulateVersion10
, ME_GetTextLength(editor
));
2682 return ME_GetTextW(editor
, rng
->lpstrText
, rng
->chrg
.cpMin
, rng
->chrg
.cpMax
-rng
->chrg
.cpMin
, 0);
2685 int nLen
= rng
->chrg
.cpMax
-rng
->chrg
.cpMin
;
2686 WCHAR
*p
= ALLOC_N_OBJ(WCHAR
, nLen
+1);
2687 int nChars
= ME_GetTextW(editor
, p
, rng
->chrg
.cpMin
, nLen
, 0);
2688 /* FIXME this is a potential security hole (buffer overrun)
2689 if you know more about wchar->mbyte conversion please explain
2691 WideCharToMultiByte(CP_ACP
, 0, p
, nChars
+1, (char *)rng
->lpstrText
, nLen
+1, NULL
, NULL
);
2698 ME_DisplayItem
*run
;
2699 const unsigned int nMaxChars
= *(WORD
*) lParam
;
2700 unsigned int nCharsLeft
= nMaxChars
;
2701 char *dest
= (char *) lParam
;
2702 BOOL wroteNull
= FALSE
;
2704 TRACE("EM_GETLINE: row=%d, nMaxChars=%d (%s)\n", (int) wParam
, nMaxChars
,
2705 unicode
? "Unicode" : "Ansi");
2707 run
= ME_FindRowWithNumber(editor
, wParam
);
2711 while (nCharsLeft
&& (run
= ME_FindItemFwd(run
, diRunOrStartRow
))
2712 && !(run
->member
.run
.nFlags
& MERF_ENDPARA
))
2716 if (run
->type
!= diRun
)
2718 strText
= run
->member
.run
.strText
;
2719 nCopy
= min(nCharsLeft
, strText
->nLen
);
2722 lstrcpynW((LPWSTR
) dest
, strText
->szData
, nCopy
);
2724 nCopy
= WideCharToMultiByte(CP_ACP
, 0, strText
->szData
, nCopy
, dest
,
2725 nCharsLeft
, NULL
, NULL
);
2726 dest
+= nCopy
* (unicode
? sizeof(WCHAR
) : 1);
2727 nCharsLeft
-= nCopy
;
2730 /* append line termination, space allowing */
2733 if (run
&& (run
->member
.run
.nFlags
& MERF_ENDPARA
))
2736 /* Write as many \r as encoded in end-of-paragraph, space allowing */
2737 for (i
= 0; i
< run
->member
.run
.nCR
&& nCharsLeft
> 0; i
++, nCharsLeft
--)
2739 *((WCHAR
*)dest
) = '\r';
2740 dest
+= unicode
? sizeof(WCHAR
) : 1;
2742 /* Write as many \n as encoded in end-of-paragraph, space allowing */
2743 for (i
= 0; i
< run
->member
.run
.nLF
&& nCharsLeft
> 0; i
++, nCharsLeft
--)
2745 *((WCHAR
*)dest
) = '\n';
2746 dest
+= unicode
? sizeof(WCHAR
) : 1;
2752 *((WCHAR
*)dest
) = '\0';
2760 TRACE("EM_GETLINE: got %u characters\n", nMaxChars
- nCharsLeft
);
2761 return nMaxChars
- nCharsLeft
- (wroteNull
? 1 : 0);
2763 case EM_GETLINECOUNT
:
2765 ME_DisplayItem
*item
= editor
->pBuffer
->pFirst
->next
;
2768 ME_DisplayItem
*prev_para
= NULL
, *last_para
= NULL
;
2770 while (item
!= editor
->pBuffer
->pLast
)
2772 assert(item
->type
== diParagraph
);
2773 prev_para
= ME_FindItemBack(item
, diRun
);
2775 assert(prev_para
->member
.run
.nFlags
& MERF_ENDPARA
);
2777 nRows
+= item
->member
.para
.nRows
;
2778 item
= item
->member
.para
.next_para
;
2780 last_para
= ME_FindItemBack(item
, diRun
);
2782 assert(last_para
->member
.run
.nFlags
& MERF_ENDPARA
);
2783 if (editor
->bEmulateVersion10
&& prev_para
&& last_para
->member
.run
.nCharOfs
== 0
2784 && prev_para
->member
.run
.nCR
== 1 && prev_para
->member
.run
.nLF
== 0)
2786 /* In 1.0 emulation, the last solitary \r at the very end of the text
2787 (if one exists) is NOT a line break.
2788 FIXME: this is an ugly hack. This should have a more regular model. */
2792 TRACE("EM_GETLINECOUNT: nRows==%d\n", nRows
);
2793 return max(1, nRows
);
2795 case EM_LINEFROMCHAR
:
2798 return ME_RowNumberFromCharOfs(editor
, ME_GetCursorOfs(editor
, 1));
2800 return ME_RowNumberFromCharOfs(editor
, wParam
);
2802 case EM_EXLINEFROMCHAR
:
2805 return ME_RowNumberFromCharOfs(editor
, ME_GetCursorOfs(editor
,1));
2807 return ME_RowNumberFromCharOfs(editor
, lParam
);
2811 ME_DisplayItem
*item
, *para
;
2815 item
= ME_FindItemBack(editor
->pCursors
[0].pRun
, diStartRow
);
2817 item
= ME_FindRowWithNumber(editor
, wParam
);
2820 para
= ME_GetParagraph(item
);
2821 item
= ME_FindItemFwd(item
, diRun
);
2822 nCharOfs
= para
->member
.para
.nCharOfs
+ item
->member
.run
.nCharOfs
;
2823 TRACE("EM_LINEINDEX: nCharOfs==%d\n", nCharOfs
);
2828 ME_DisplayItem
*item
, *item_end
;
2829 int nChars
= 0, nThisLineOfs
= 0, nNextLineOfs
= 0;
2831 if (wParam
> ME_GetTextLength(editor
))
2835 FIXME("EM_LINELENGTH: returning number of unselected characters on lines with selection unsupported.\n");
2838 item
= ME_FindItemAtOffset(editor
, diRun
, wParam
, NULL
);
2839 item
= ME_RowStart(item
);
2840 nThisLineOfs
= ME_CharOfsFromRunOfs(editor
, ME_FindItemFwd(item
, diRun
), 0);
2841 item_end
= ME_FindItemFwd(item
, diStartRowOrParagraphOrEnd
);
2842 if (item_end
->type
== diStartRow
)
2843 nNextLineOfs
= ME_CharOfsFromRunOfs(editor
, ME_FindItemFwd(item_end
, diRun
), 0);
2846 ME_DisplayItem
*endPara
;
2848 nNextLineOfs
= ME_FindItemFwd(item
, diParagraphOrEnd
)->member
.para
.nCharOfs
;
2849 endPara
= ME_FindItemFwd(item
, diParagraphOrEnd
);
2850 endPara
= ME_FindItemBack(endPara
, diRun
);
2852 assert(endPara
->type
== diRun
);
2853 assert(endPara
->member
.run
.nFlags
& MERF_ENDPARA
);
2854 nNextLineOfs
-= endPara
->member
.run
.nCR
+ endPara
->member
.run
.nLF
;
2856 nChars
= nNextLineOfs
- nThisLineOfs
;
2857 TRACE("EM_LINELENGTH(%ld)==%d\n",wParam
, nChars
);
2860 case EM_EXLIMITTEXT
:
2862 if ((int)lParam
< 0)
2865 editor
->nTextLimit
= 65536;
2867 editor
->nTextLimit
= (int) lParam
;
2873 editor
->nTextLimit
= 65536;
2875 editor
->nTextLimit
= (int) wParam
;
2878 case EM_GETLIMITTEXT
:
2880 return editor
->nTextLimit
;
2884 FINDTEXTA
*ft
= (FINDTEXTA
*)lParam
;
2885 int nChars
= MultiByteToWideChar(CP_ACP
, 0, ft
->lpstrText
, -1, NULL
, 0);
2889 if ((tmp
= ALLOC_N_OBJ(WCHAR
, nChars
)) != NULL
)
2890 MultiByteToWideChar(CP_ACP
, 0, ft
->lpstrText
, -1, tmp
, nChars
);
2891 r
= ME_FindText(editor
, wParam
, &ft
->chrg
, tmp
, NULL
);
2897 FINDTEXTEXA
*ex
= (FINDTEXTEXA
*)lParam
;
2898 int nChars
= MultiByteToWideChar(CP_ACP
, 0, ex
->lpstrText
, -1, NULL
, 0);
2902 if ((tmp
= ALLOC_N_OBJ(WCHAR
, nChars
)) != NULL
)
2903 MultiByteToWideChar(CP_ACP
, 0, ex
->lpstrText
, -1, tmp
, nChars
);
2904 r
= ME_FindText(editor
, wParam
, &ex
->chrg
, tmp
, &ex
->chrgText
);
2910 FINDTEXTW
*ft
= (FINDTEXTW
*)lParam
;
2911 return ME_FindText(editor
, wParam
, &ft
->chrg
, ft
->lpstrText
, NULL
);
2913 case EM_FINDTEXTEXW
:
2915 FINDTEXTEXW
*ex
= (FINDTEXTEXW
*)lParam
;
2916 return ME_FindText(editor
, wParam
, &ex
->chrg
, ex
->lpstrText
, &ex
->chrgText
);
2919 if (!wParam
|| !lParam
)
2921 *(int *)wParam
= editor
->nZoomNumerator
;
2922 *(int *)lParam
= editor
->nZoomDenominator
;
2925 return ME_SetZoom(editor
, wParam
, lParam
);
2926 case EM_CHARFROMPOS
:
2927 return ME_CharFromPos(editor
, ((POINTL
*)lParam
)->x
, ((POINTL
*)lParam
)->y
);
2928 case EM_POSFROMCHAR
:
2930 ME_DisplayItem
*pRun
;
2931 int nCharOfs
, nOffset
, nLength
;
2936 /* detect which API version we're dealing with */
2937 if (wParam
>= 0x40000)
2939 nLength
= ME_GetTextLength(editor
);
2941 if (nCharOfs
< nLength
) {
2942 ME_RunOfsFromCharOfs(editor
, nCharOfs
, &pRun
, &nOffset
);
2943 assert(pRun
->type
== diRun
);
2944 pt
.y
= pRun
->member
.run
.pt
.y
;
2945 pt
.x
= pRun
->member
.run
.pt
.x
+ ME_PointFromChar(editor
, &pRun
->member
.run
, nOffset
);
2946 pt
.y
+= ME_GetParagraph(pRun
)->member
.para
.nYPos
;
2949 pt
.y
= editor
->pBuffer
->pLast
->member
.para
.nYPos
;
2951 pt
.x
+= editor
->selofs
;
2953 si
.cbSize
= sizeof(si
);
2955 if (GetScrollInfo(editor
->hWnd
, SB_VERT
, &si
)) pt
.y
-= si
.nPos
;
2956 si
.cbSize
= sizeof(si
);
2958 if (GetScrollInfo(editor
->hWnd
, SB_HORZ
, &si
)) pt
.x
-= si
.nPos
;
2960 if (wParam
>= 0x40000) {
2961 *(POINTL
*)wParam
= pt
;
2963 return (wParam
>= 0x40000) ? 0 : MAKELONG( pt
.x
, pt
.y
);
2966 GetClientRect(hWnd
, &editor
->rcFormat
);
2967 if (GetWindowLongW(hWnd
, GWL_STYLE
) & WS_HSCROLL
)
2968 { /* Squelch the default horizontal scrollbar it would make */
2969 ShowScrollBar(editor
->hWnd
, SB_HORZ
, FALSE
);
2971 ME_CommitUndo(editor
);
2972 ME_WrapMarkedParagraphs(editor
);
2973 ME_MoveCaret(editor
);
2976 ME_DestroyEditor(editor
);
2977 SetWindowLongPtrW(hWnd
, 0, 0);
2979 case WM_LBUTTONDBLCLK
:
2980 case WM_LBUTTONDOWN
:
2982 int clickNum
= (msg
== WM_LBUTTONDBLCLK
) ? 2 : 1;
2983 ME_CommitUndo(editor
); /* End coalesced undos for typed characters */
2984 if ((editor
->nEventMask
& ENM_MOUSEEVENTS
) &&
2985 !ME_FilterEvent(editor
, msg
, &wParam
, &lParam
))
2988 ME_LButtonDown(editor
, (short)LOWORD(lParam
), (short)HIWORD(lParam
),
2991 ME_LinkNotify(editor
,msg
,wParam
,lParam
);
2992 if (!ME_SetCursor(editor
, LOWORD(lParam
))) goto do_default
;
2996 if ((editor
->nEventMask
& ENM_MOUSEEVENTS
) &&
2997 !ME_FilterEvent(editor
, msg
, &wParam
, &lParam
))
2999 if (GetCapture() == hWnd
)
3000 ME_MouseMove(editor
, (short)LOWORD(lParam
), (short)HIWORD(lParam
));
3001 ME_LinkNotify(editor
,msg
,wParam
,lParam
);
3002 if (!ME_SetCursor(editor
, LOWORD(lParam
))) goto do_default
;
3005 if (GetCapture() == hWnd
)
3007 if ((editor
->nEventMask
& ENM_MOUSEEVENTS
) &&
3008 !ME_FilterEvent(editor
, msg
, &wParam
, &lParam
))
3013 ret
= ME_SetCursor(editor
, LOWORD(lParam
));
3014 ME_LinkNotify(editor
,msg
,wParam
,lParam
);
3015 if (!ret
) goto do_default
;
3019 case WM_RBUTTONDOWN
:
3020 ME_CommitUndo(editor
); /* End coalesced undos for typed characters */
3021 if ((editor
->nEventMask
& ENM_MOUSEEVENTS
) &&
3022 !ME_FilterEvent(editor
, msg
, &wParam
, &lParam
))
3025 case WM_CONTEXTMENU
:
3026 if (!ME_ShowContextMenu(editor
, (short)LOWORD(lParam
), (short)HIWORD(lParam
)))
3030 if (editor
->bRedraw
)
3035 hDC
= BeginPaint(hWnd
, &ps
);
3036 ME_PaintContent(editor
, hDC
, FALSE
, &ps
.rcPaint
);
3037 EndPaint(hWnd
, &ps
);
3041 editor
->bHaveFocus
= TRUE
;
3042 ME_ShowCaret(editor
);
3043 ME_SendOldNotify(editor
, EN_SETFOCUS
);
3046 ME_CommitUndo(editor
); /* End coalesced undos for typed characters */
3047 ME_HideCaret(editor
);
3048 editor
->bHaveFocus
= FALSE
;
3049 ME_SendOldNotify(editor
, EN_KILLFOCUS
);
3053 if (editor
->bRedraw
)
3055 HDC hDC
= (HDC
)wParam
;
3057 if (GetUpdateRect(hWnd
,&rc
,TRUE
))
3059 FillRect(hDC
, &rc
, editor
->hbrBackground
);
3065 TRACE("editor wnd command = %d\n", LOWORD(wParam
));
3068 if ((editor
->nEventMask
& ENM_KEYEVENTS
) &&
3069 !ME_FilterEvent(editor
, msg
, &wParam
, &lParam
))
3073 if ((editor
->nEventMask
& ENM_KEYEVENTS
) &&
3074 !ME_FilterEvent(editor
, msg
, &wParam
, &lParam
))
3076 if (ME_KeyDown(editor
, LOWORD(wParam
)))
3084 wstr
= (WCHAR
)wParam
;
3087 CHAR charA
= wParam
;
3088 MultiByteToWideChar(CP_ACP
, 0, &charA
, 1, &wstr
, 1);
3093 case 1: /* Ctrl-A */
3094 ME_SetSelection(editor
, 0, -1);
3096 case 3: /* Ctrl-C */
3097 SendMessageW(editor
->hWnd
, WM_COPY
, 0, 0);
3101 if (GetWindowLongW(editor
->hWnd
, GWL_STYLE
) & ES_READONLY
) {
3102 MessageBeep(MB_ICONERROR
);
3103 return 0; /* FIXME really 0 ? */
3108 case 22: /* Ctrl-V */
3109 SendMessageW(editor
->hWnd
, WM_PASTE
, 0, 0);
3111 case 24: /* Ctrl-X */
3112 SendMessageW(editor
->hWnd
, WM_CUT
, 0, 0);
3114 case 25: /* Ctrl-Y */
3115 SendMessageW(editor
->hWnd
, EM_REDO
, 0, 0);
3117 case 26: /* Ctrl-Z */
3118 SendMessageW(editor
->hWnd
, EM_UNDO
, 0, 0);
3121 if (((unsigned)wstr
)>=' '
3122 || (wstr
=='\r' && (GetWindowLongW(hWnd
, GWL_STYLE
) & ES_MULTILINE
))
3124 /* FIXME maybe it would make sense to call EM_REPLACESEL instead ? */
3125 /* WM_CHAR is restricted to nTextLimit */
3127 ME_GetSelection(editor
, &from
, &to
);
3128 if(editor
->nTextLimit
> ME_GetTextLength(editor
) - (to
-from
))
3130 ME_Style
*style
= ME_GetInsertStyle(editor
, 0);
3131 ME_SaveTempStyle(editor
);
3132 ME_ContinueCoalescingTransaction(editor
);
3133 if (wstr
== '\r' && (GetKeyState(VK_SHIFT
) & 0x8000))
3134 ME_InsertEndRowFromCursor(editor
, 0);
3136 ME_InsertTextFromCursor(editor
, 0, &wstr
, 1, style
);
3137 ME_ReleaseStyle(style
);
3138 ME_CommitCoalescingUndo(editor
);
3141 if (editor
->AutoURLDetect_bEnable
) ME_UpdateSelectionLinkAttribute(editor
);
3143 ME_UpdateRepaint(editor
);
3147 case EM_STOPGROUPTYPING
:
3148 ME_CommitUndo(editor
); /* End coalesced undos for typed characters */
3150 case EM_SCROLL
: /* fall through */
3156 origNPos
= ME_GetYScrollPos(editor
);
3159 if (editor
&& editor
->pBuffer
&& editor
->pBuffer
->pDefaultStyle
)
3160 lineHeight
= editor
->pBuffer
->pDefaultStyle
->tm
.tmHeight
;
3161 if (lineHeight
<= 0) lineHeight
= 24;
3163 switch(LOWORD(wParam
))
3166 ME_ScrollUp(editor
,lineHeight
);
3169 ME_ScrollDown(editor
,lineHeight
);
3172 ME_ScrollUp(editor
,editor
->sizeWindow
.cy
);
3175 ME_ScrollDown(editor
,editor
->sizeWindow
.cy
);
3178 case SB_THUMBPOSITION
:
3179 ME_ScrollAbs(editor
,HIWORD(wParam
));
3182 if (msg
== EM_SCROLL
)
3183 return 0x00010000 | (((ME_GetYScrollPos(editor
) - origNPos
)/lineHeight
) & 0xffff);
3189 UINT pulScrollLines
;
3191 if ((editor
->nEventMask
& ENM_MOUSEEVENTS
) &&
3192 !ME_FilterEvent(editor
, msg
, &wParam
, &lParam
))
3195 SystemParametersInfoW(SPI_GETWHEELSCROLLLINES
,0, &pulScrollLines
, 0);
3196 gcWheelDelta
= -GET_WHEEL_DELTA_WPARAM(wParam
);
3198 if (abs(gcWheelDelta
) >= WHEEL_DELTA
&& pulScrollLines
)
3200 /* FIXME follow the original */
3201 ME_ScrollDown(editor
,pulScrollLines
* (gcWheelDelta
/ WHEEL_DELTA
) * 8);
3207 *((RECT
*)lParam
) = editor
->rcFormat
;
3215 RECT
*rc
= (RECT
*)lParam
;
3219 editor
->rcFormat
.left
+= rc
->left
;
3220 editor
->rcFormat
.top
+= rc
->top
;
3221 editor
->rcFormat
.right
+= rc
->right
;
3222 editor
->rcFormat
.bottom
+= rc
->bottom
;
3226 editor
->rcFormat
= *rc
;
3231 GetClientRect(hWnd
, &editor
->rcFormat
);
3233 if (msg
!= EM_SETRECTNP
)
3234 ME_RewrapRepaint(editor
);
3237 case EM_REQUESTRESIZE
:
3238 ME_SendRequestResize(editor
, TRUE
);
3241 if ((editor
->bRedraw
= wParam
))
3242 ME_RewrapRepaint(editor
);
3246 GetClientRect(hWnd
, &editor
->rcFormat
);
3247 ME_RewrapRepaint(editor
);
3248 return DefWindowProcW(hWnd
, msg
, wParam
, lParam
);
3250 /* IME messages to make richedit controls IME aware */
3251 case WM_IME_SETCONTEXT
:
3252 case WM_IME_CONTROL
:
3254 case WM_IME_COMPOSITIONFULL
:
3256 case WM_IME_STARTCOMPOSITION
:
3258 editor
->imeStartIndex
=ME_GetCursorOfs(editor
,0);
3259 ME_DeleteSelection(editor
);
3260 ME_CommitUndo(editor
);
3261 ME_UpdateRepaint(editor
);
3264 case WM_IME_COMPOSITION
:
3268 ME_Style
*style
= ME_GetInsertStyle(editor
, 0);
3269 hIMC
= ImmGetContext(hWnd
);
3270 ME_DeleteSelection(editor
);
3271 ME_CommitUndo(editor
);
3272 ME_SaveTempStyle(editor
);
3273 if (lParam
& GCS_RESULTSTR
)
3275 LPWSTR lpCompStr
= NULL
;
3278 dwBufLen
= ImmGetCompositionStringW(hIMC
, GCS_RESULTSTR
, NULL
, 0);
3279 lpCompStr
= HeapAlloc(GetProcessHeap(),0,dwBufLen
+ sizeof(WCHAR
));
3280 ImmGetCompositionStringW(hIMC
, GCS_RESULTSTR
, lpCompStr
, dwBufLen
);
3281 lpCompStr
[dwBufLen
/sizeof(WCHAR
)] = 0;
3282 ME_InsertTextFromCursor(editor
,0,lpCompStr
,dwBufLen
/sizeof(WCHAR
),style
);
3284 else if (lParam
& GCS_COMPSTR
)
3286 LPWSTR lpCompStr
= NULL
;
3289 dwBufLen
= ImmGetCompositionStringW(hIMC
, GCS_COMPSTR
, NULL
, 0);
3290 lpCompStr
= HeapAlloc(GetProcessHeap(),0,dwBufLen
+ sizeof(WCHAR
));
3291 ImmGetCompositionStringW(hIMC
, GCS_COMPSTR
, lpCompStr
, dwBufLen
);
3292 lpCompStr
[dwBufLen
/sizeof(WCHAR
)] = 0;
3294 ME_InsertTextFromCursor(editor
,0,lpCompStr
,dwBufLen
/sizeof(WCHAR
),style
);
3295 ME_SetSelection(editor
,editor
->imeStartIndex
,
3296 editor
->imeStartIndex
+ dwBufLen
/sizeof(WCHAR
));
3298 ME_ReleaseStyle(style
);
3299 ME_UpdateRepaint(editor
);
3302 case WM_IME_ENDCOMPOSITION
:
3304 ME_DeleteSelection(editor
);
3305 editor
->imeStartIndex
=-1;
3308 case EM_GETOLEINTERFACE
:
3310 LPVOID
*ppvObj
= (LPVOID
*) lParam
;
3311 return CreateIRichEditOle(editor
, ppvObj
);
3313 case EM_GETPASSWORDCHAR
:
3315 return editor
->cPasswordMask
;
3317 case EM_SETOLECALLBACK
:
3318 if(editor
->lpOleCallback
)
3319 IUnknown_Release(editor
->lpOleCallback
);
3320 editor
->lpOleCallback
= (LPRICHEDITOLECALLBACK
)lParam
;
3321 if(editor
->lpOleCallback
)
3322 IUnknown_AddRef(editor
->lpOleCallback
);
3324 case EM_GETWORDBREAKPROC
:
3325 return (LRESULT
)editor
->pfnWordBreak
;
3326 case EM_SETWORDBREAKPROC
:
3328 EDITWORDBREAKPROCW pfnOld
= editor
->pfnWordBreak
;
3330 editor
->pfnWordBreak
= (EDITWORDBREAKPROCW
)lParam
;
3331 return (LRESULT
)pfnOld
;
3333 case EM_SETTEXTMODE
:
3338 ret
= RichEditWndProc_common(hWnd
, WM_GETTEXTLENGTH
, 0, 0, unicode
);
3341 /*Check for valid wParam*/
3342 if ((((wParam
& TM_RICHTEXT
) && ((wParam
& TM_PLAINTEXT
) << 1))) ||
3343 (((wParam
& TM_MULTILEVELUNDO
) && ((wParam
& TM_SINGLELEVELUNDO
) << 1))) ||
3344 (((wParam
& TM_MULTICODEPAGE
) && ((wParam
& TM_SINGLECODEPAGE
) << 1))))
3348 if (wParam
& (TM_RICHTEXT
| TM_PLAINTEXT
))
3350 mask
|= (TM_RICHTEXT
| TM_PLAINTEXT
);
3351 changes
|= (wParam
& (TM_RICHTEXT
| TM_PLAINTEXT
));
3353 /*FIXME: Currently no support for undo level and code page options*/
3354 editor
->mode
= (editor
->mode
& (~mask
)) | changes
;
3360 case EM_SETPASSWORDCHAR
:
3362 editor
->cPasswordMask
= wParam
;
3363 ME_RewrapRepaint(editor
);
3366 case EM_SETTARGETDEVICE
:
3369 BOOL
new = (lParam
== 0);
3370 if (editor
->bWordWrap
!= new)
3372 editor
->bWordWrap
= new;
3373 ME_RewrapRepaint(editor
);
3376 else FIXME("Unsupported yet non NULL device in EM_SETTARGETDEVICE\n");
3380 return DefWindowProcW(hWnd
, msg
, wParam
, lParam
);
3385 static LRESULT WINAPI
RichEditWndProcW(HWND hWnd
, UINT msg
, WPARAM wParam
, LPARAM lParam
)
3387 BOOL unicode
= TRUE
;
3389 /* Under Win9x RichEdit20W returns ANSI strings, see the tests. */
3390 if (msg
== WM_GETTEXT
&& (GetVersion() & 0x80000000))
3393 return RichEditWndProc_common(hWnd
, msg
, wParam
, lParam
, unicode
);
3396 static LRESULT WINAPI
RichEditWndProcA(HWND hWnd
, UINT msg
, WPARAM wParam
, LPARAM lParam
)
3398 return RichEditWndProc_common(hWnd
, msg
, wParam
, lParam
, FALSE
);
3401 /******************************************************************
3402 * RichEditANSIWndProc (RICHED20.10)
3404 LRESULT WINAPI
RichEditANSIWndProc(HWND hWnd
, UINT msg
, WPARAM wParam
, LPARAM lParam
)
3406 return RichEditWndProcA(hWnd
, msg
, wParam
, lParam
);
3409 /******************************************************************
3410 * RichEdit10ANSIWndProc (RICHED20.9)
3412 LRESULT WINAPI
RichEdit10ANSIWndProc(HWND hWnd
, UINT msg
, WPARAM wParam
, LPARAM lParam
)
3416 /* FIXME: this is NOT the same as 2.0 version */
3417 result
= RichEditANSIWndProc(hWnd
, msg
, wParam
, lParam
);
3418 if (msg
== WM_NCCREATE
)
3420 ME_TextEditor
*editor
= (ME_TextEditor
*)GetWindowLongPtrW(hWnd
, 0);
3422 editor
->bEmulateVersion10
= TRUE
;
3423 editor
->pBuffer
->pLast
->member
.para
.nCharOfs
= 2;
3424 assert(editor
->pBuffer
->pLast
->prev
->type
== diRun
);
3425 assert(editor
->pBuffer
->pLast
->prev
->member
.run
.nFlags
& MERF_ENDPARA
);
3426 editor
->pBuffer
->pLast
->prev
->member
.run
.nLF
= 1;
3431 void ME_SendOldNotify(ME_TextEditor
*editor
, int nCode
)
3433 HWND hWnd
= editor
->hWnd
;
3434 SendMessageA(GetParent(hWnd
), WM_COMMAND
, (nCode
<<16)|GetWindowLongW(hWnd
, GWLP_ID
), (LPARAM
)hWnd
);
3437 void ME_LinkNotify(ME_TextEditor
*editor
, UINT msg
, WPARAM wParam
, LPARAM lParam
)
3440 ME_Cursor tmpCursor
;
3441 int nCharOfs
; /* The start of the clicked text. Absolute character offset */
3446 x
= (short)LOWORD(lParam
);
3447 y
= (short)HIWORD(lParam
);
3448 nCharOfs
= ME_CharFromPos(editor
, x
, y
);
3449 if (nCharOfs
< 0) return;
3451 ME_CursorFromCharOfs(editor
, nCharOfs
, &tmpCursor
);
3452 tmpRun
= &tmpCursor
.pRun
->member
.run
;
3454 if ((tmpRun
->style
->fmt
.dwMask
& CFM_LINK
)
3455 && (tmpRun
->style
->fmt
.dwEffects
& CFE_LINK
))
3456 { /* The clicked run has CFE_LINK set */
3457 info
.nmhdr
.hwndFrom
= editor
->hWnd
;
3458 info
.nmhdr
.idFrom
= GetWindowLongW(editor
->hWnd
, GWLP_ID
);
3459 info
.nmhdr
.code
= EN_LINK
;
3461 info
.wParam
= wParam
;
3462 info
.lParam
= lParam
;
3463 info
.chrg
.cpMin
= ME_CharOfsFromRunOfs(editor
,tmpCursor
.pRun
,0);
3464 info
.chrg
.cpMax
= info
.chrg
.cpMin
+ ME_StrVLen(tmpRun
->strText
);
3465 SendMessageW(GetParent(editor
->hWnd
), WM_NOTIFY
,info
.nmhdr
.idFrom
, (LPARAM
)&info
);
3469 int ME_CountParagraphsBetween(ME_TextEditor
*editor
, int from
, int to
)
3471 ME_DisplayItem
*item
= ME_FindItemFwd(editor
->pBuffer
->pFirst
, diParagraph
);
3474 while(item
&& item
->member
.para
.next_para
->member
.para
.nCharOfs
<= from
)
3475 item
= item
->member
.para
.next_para
;
3478 while(item
&& item
->member
.para
.next_para
->member
.para
.nCharOfs
<= to
) {
3479 item
= item
->member
.para
.next_para
;
3486 int ME_GetTextW(ME_TextEditor
*editor
, WCHAR
*buffer
, int nStart
, int nChars
, int bCRLF
)
3488 ME_DisplayItem
*item
= ME_FindItemAtOffset(editor
, diRun
, nStart
, &nStart
);
3490 WCHAR
*pStart
= buffer
;
3497 /* bCRLF flag is only honored in 2.0 and up. 1.0 must always return text verbatim */
3498 if (editor
->bEmulateVersion10
) bCRLF
= 0;
3502 int nLen
= ME_StrLen(item
->member
.run
.strText
) - nStart
;
3505 CopyMemory(buffer
, item
->member
.run
.strText
->szData
+ nStart
, sizeof(WCHAR
)*nLen
);
3514 item
= ME_FindItemFwd(item
, diRun
);
3517 while(nChars
&& item
)
3519 int nLen
= ME_StrLen(item
->member
.run
.strText
);
3520 if (item
->member
.run
.nFlags
& MERF_ENDPARA
)
3521 nLen
= item
->member
.run
.nCR
+ item
->member
.run
.nLF
;
3525 if (item
->member
.run
.nFlags
& MERF_ENDPARA
)
3527 if (!ME_FindItemFwd(item
, diRun
))
3528 /* No '\r' is appended to the last paragraph. */
3530 else if (bCRLF
&& nChars
== 1) {
3536 /* richedit 2.0 case - actual line-break is \r but should report \r\n */
3539 *buffer
= '\n'; /* Later updated by nLen==1 at the end of the loop */
3546 /* richedit 2.0 verbatim has only \r. richedit 1.0 should honor encodings */
3548 while (nChars
- i
> 0 && i
< item
->member
.run
.nCR
)
3550 buffer
[i
] = '\r'; i
++;
3553 while (nChars
- i
- j
> 0 && j
< item
->member
.run
.nLF
)
3555 buffer
[i
+j
] = '\n'; j
++;
3561 CopyMemory(buffer
, item
->member
.run
.strText
->szData
, sizeof(WCHAR
)*nLen
);
3568 TRACE("nWritten=%d, actual=%d\n", nWritten
, buffer
-pStart
);
3572 item
= ME_FindItemFwd(item
, diRun
);
3575 TRACE("nWritten=%d, actual=%d\n", nWritten
, buffer
-pStart
);
3579 static BOOL
ME_RegisterEditorClass(HINSTANCE hInstance
)
3584 wcW
.style
= CS_DBLCLKS
| CS_HREDRAW
| CS_VREDRAW
| CS_GLOBALCLASS
;
3585 wcW
.lpfnWndProc
= RichEditWndProcW
;
3587 wcW
.cbWndExtra
= sizeof(ME_TextEditor
*);
3588 wcW
.hInstance
= NULL
; /* hInstance would register DLL-local class */
3590 wcW
.hCursor
= LoadCursorW(NULL
, MAKEINTRESOURCEW(IDC_IBEAM
));
3591 wcW
.hbrBackground
= (HBRUSH
)GetStockObject(NULL_BRUSH
);
3592 wcW
.lpszMenuName
= NULL
;
3594 if (is_version_nt())
3596 wcW
.lpszClassName
= RichEdit20W
;
3597 if (!RegisterClassW(&wcW
)) return FALSE
;
3598 wcW
.lpszClassName
= RichEdit50W
;
3599 if (!RegisterClassW(&wcW
)) return FALSE
;
3603 /* WNDCLASSA/W have the same layout */
3604 wcW
.lpszClassName
= (LPCWSTR
)"RichEdit20W";
3605 if (!RegisterClassA((WNDCLASSA
*)&wcW
)) return FALSE
;
3606 wcW
.lpszClassName
= (LPCWSTR
)"RichEdit50W";
3607 if (!RegisterClassA((WNDCLASSA
*)&wcW
)) return FALSE
;
3610 wcA
.style
= CS_DBLCLKS
| CS_HREDRAW
| CS_VREDRAW
| CS_GLOBALCLASS
;
3611 wcA
.lpfnWndProc
= RichEditWndProcA
;
3613 wcA
.cbWndExtra
= sizeof(ME_TextEditor
*);
3614 wcA
.hInstance
= NULL
; /* hInstance would register DLL-local class */
3616 wcA
.hCursor
= LoadCursorW(NULL
, MAKEINTRESOURCEW(IDC_IBEAM
));
3617 wcA
.hbrBackground
= (HBRUSH
)GetStockObject(NULL_BRUSH
);
3618 wcA
.lpszMenuName
= NULL
;
3619 wcA
.lpszClassName
= "RichEdit20A";
3620 if (!RegisterClassA(&wcA
)) return FALSE
;
3621 wcA
.lpszClassName
= "RichEdit50A";
3622 if (!RegisterClassA(&wcA
)) return FALSE
;
3627 LRESULT WINAPI
REComboWndProc(HWND hWnd
, UINT msg
, WPARAM wParam
, LPARAM lParam
) {
3628 /* FIXME: Not implemented */
3629 TRACE("hWnd %p msg %04x (%s) %08lx %08lx\n",
3630 hWnd
, msg
, get_msg_name(msg
), wParam
, lParam
);
3631 return DefWindowProcW(hWnd
, msg
, wParam
, lParam
);
3634 LRESULT WINAPI
REListWndProc(HWND hWnd
, UINT msg
, WPARAM wParam
, LPARAM lParam
) {
3635 /* FIXME: Not implemented */
3636 TRACE("hWnd %p msg %04x (%s) %08lx %08lx\n",
3637 hWnd
, msg
, get_msg_name(msg
), wParam
, lParam
);
3638 return DefWindowProcW(hWnd
, msg
, wParam
, lParam
);
3641 /******************************************************************
3642 * REExtendedRegisterClass (RICHED20.8)
3644 * FIXME undocumented
3645 * Need to check for errors and implement controls and callbacks
3647 LRESULT WINAPI
REExtendedRegisterClass(void)
3652 FIXME("semi stub\n");
3656 wcW
.hInstance
= NULL
;
3659 wcW
.hbrBackground
= (HBRUSH
)(COLOR_WINDOW
+1);
3660 wcW
.lpszMenuName
= NULL
;
3662 if (!ME_ListBoxRegistered
)
3664 wcW
.style
= CS_PARENTDC
| CS_DBLCLKS
| CS_GLOBALCLASS
;
3665 wcW
.lpfnWndProc
= REListWndProc
;
3666 wcW
.lpszClassName
= REListBox20W
;
3667 if (RegisterClassW(&wcW
)) ME_ListBoxRegistered
= TRUE
;
3670 if (!ME_ComboBoxRegistered
)
3672 wcW
.style
= CS_PARENTDC
| CS_DBLCLKS
| CS_GLOBALCLASS
| CS_VREDRAW
| CS_HREDRAW
;
3673 wcW
.lpfnWndProc
= REComboWndProc
;
3674 wcW
.lpszClassName
= REComboBox20W
;
3675 if (RegisterClassW(&wcW
)) ME_ComboBoxRegistered
= TRUE
;
3679 if (ME_ListBoxRegistered
)
3681 if (ME_ComboBoxRegistered
)
3687 int ME_AutoURLDetect(ME_TextEditor
*editor
, WCHAR curChar
)
3707 int curf_ef
, link_ef
, def_ef
;
3708 int cur_prefx
, prefx_cnt
;
3709 int sel_min
, sel_max
;
3712 int URLmin
, URLmax
= 0;
3714 CHARFORMAT2W cur_format
;
3715 CHARFORMAT2W default_format
;
3717 RichEditANSIWndProc(editor
->hWnd
, EM_EXGETSEL
, (WPARAM
) 0, (LPARAM
) &ins_pt
);
3718 sel_min
= ins_pt
.cpMin
;
3719 sel_max
= ins_pt
.cpMax
;
3720 if (sel_min
==sel_max
)
3722 if (sel_min
!=sel_max
)
3723 car_pos
= ME_GetTextLength(editor
)+1;
3724 cur_format
.cbSize
= sizeof(cur_format
);
3725 default_format
.cbSize
= sizeof(default_format
);
3726 RichEditANSIWndProc(editor
->hWnd
, EM_GETCHARFORMAT
, SCF_SELECTION
, (LPARAM
) &cur_format
);
3727 RichEditANSIWndProc(editor
->hWnd
, EM_GETCHARFORMAT
, SCF_DEFAULT
, (LPARAM
) &default_format
);
3728 link
.cbSize
= sizeof(link
);
3729 link
.dwMask
= CFM_LINK
;
3730 link
.dwEffects
= CFE_LINK
;
3731 curf_ef
= cur_format
.dwEffects
& link
.dwEffects
;
3732 def_ef
= default_format
.dwEffects
& link
.dwEffects
;
3733 link_ef
= link
.dwEffects
& link
.dwEffects
;
3734 if (curf_ef
== link_ef
)
3736 if( curChar
== '\n' || curChar
=='\r' || curChar
==' ')
3738 ME_SetSelection(editor
, car_pos
, car_pos
);
3739 RichEditANSIWndProc(editor
->hWnd
, EM_SETCHARFORMAT
, SCF_SELECTION
, (LPARAM
) &default_format
);
3744 if (curf_ef
== def_ef
)
3747 prefx_cnt
= (sizeof(prefixes
)/sizeof(struct prefix_s
))-1;
3748 while (cur_prefx
<=prefx_cnt
)
3752 ft
.lpstrText
= prefixes
[cur_prefx
].text
;
3753 URLmin
=max(0,(car_pos
-prefixes
[cur_prefx
].length
));
3754 URLmax
=max(0, car_pos
);
3755 if ((car_pos
== 0) && (ME_GetTextLength(editor
) != 0))
3757 URLmax
= ME_GetTextLength(editor
)+1;
3759 ft
.chrg
.cpMin
= URLmin
;
3760 ft
.chrg
.cpMax
= URLmax
;
3761 text_pos
=RichEditANSIWndProc(editor
->hWnd
, EM_FINDTEXT
, FR_DOWN
, (LPARAM
)&ft
);
3766 ME_SetCharFormat(editor
, text_pos
, (URLmax
-text_pos
), &link
);
3767 ME_RewrapRepaint(editor
);
3776 static BOOL
isurlspecial(WCHAR c
)
3778 static const WCHAR special_chars
[] = {'.','/','%','@','*','|','\\','+','#',0};
3779 return strchrW( special_chars
, c
) != NULL
;
3783 * This proc takes a selection, and scans it forward in order to select the span
3784 * of a possible URL candidate. A possible URL candidate must start with isalnum
3785 * or one of the following special characters: *|/\+%#@ and must consist entirely
3786 * of the characters allowed to start the URL, plus : (colon) which may occur
3787 * at most once, and not at either end.
3789 * sel_max == -1 indicates scan to end of text.
3791 BOOL
ME_FindNextURLCandidate(ME_TextEditor
*editor
, int sel_min
, int sel_max
,
3792 int * candidate_min
, int * candidate_max
)
3794 ME_DisplayItem
* item
;
3795 ME_DisplayItem
* para
;
3797 BOOL foundColon
= FALSE
;
3798 WCHAR lastAcceptedChar
= '\0';
3800 TRACE("sel_min = %d sel_max = %d\n", sel_min
, sel_max
);
3802 *candidate_min
= *candidate_max
= -1;
3803 item
= ME_FindItemAtOffset(editor
, diRun
, sel_min
, &nStart
);
3804 if (!item
) return FALSE
;
3805 TRACE("nStart = %d\n", nStart
);
3806 para
= ME_GetParagraph(item
);
3807 if (sel_max
== -1) sel_max
= ME_GetTextLength(editor
);
3808 while (item
&& para
->member
.para
.nCharOfs
+ item
->member
.run
.nCharOfs
+ nStart
< sel_max
)
3810 ME_DisplayItem
* next_item
;
3812 if (!(item
->member
.run
.nFlags
& MERF_ENDPARA
)) {
3813 /* Find start of candidate */
3814 if (*candidate_min
== -1) {
3815 while (nStart
< ME_StrLen(item
->member
.run
.strText
) &&
3816 !(isalnumW(item
->member
.run
.strText
->szData
[nStart
]) ||
3817 isurlspecial(item
->member
.run
.strText
->szData
[nStart
]))) {
3820 if (nStart
< ME_StrLen(item
->member
.run
.strText
) &&
3821 (isalnumW(item
->member
.run
.strText
->szData
[nStart
]) ||
3822 isurlspecial(item
->member
.run
.strText
->szData
[nStart
]))) {
3823 *candidate_min
= para
->member
.para
.nCharOfs
+ item
->member
.run
.nCharOfs
+ nStart
;
3824 lastAcceptedChar
= item
->member
.run
.strText
->szData
[nStart
];
3829 /* Find end of candidate */
3830 if (*candidate_min
>= 0) {
3831 while (nStart
< ME_StrLen(item
->member
.run
.strText
) &&
3832 (isalnumW(item
->member
.run
.strText
->szData
[nStart
]) ||
3833 isurlspecial(item
->member
.run
.strText
->szData
[nStart
]) ||
3834 (!foundColon
&& item
->member
.run
.strText
->szData
[nStart
] == ':') )) {
3835 if (item
->member
.run
.strText
->szData
[nStart
] == ':') foundColon
= TRUE
;
3836 lastAcceptedChar
= item
->member
.run
.strText
->szData
[nStart
];
3839 if (nStart
< ME_StrLen(item
->member
.run
.strText
) &&
3840 !(isalnumW(item
->member
.run
.strText
->szData
[nStart
]) ||
3841 isurlspecial(item
->member
.run
.strText
->szData
[nStart
]) )) {
3842 *candidate_max
= para
->member
.para
.nCharOfs
+ item
->member
.run
.nCharOfs
+ nStart
;
3844 if (lastAcceptedChar
== ':') (*candidate_max
)--;
3849 /* End of paragraph: skip it if before candidate span, or terminates
3850 current active span */
3851 if (*candidate_min
>= 0) {
3852 *candidate_max
= para
->member
.para
.nCharOfs
+ item
->member
.run
.nCharOfs
;
3853 if (lastAcceptedChar
== ':') (*candidate_max
)--;
3858 /* Reaching this point means no span was found, so get next span */
3859 next_item
= ME_FindItemFwd(item
, diRun
);
3861 if (*candidate_min
>= 0) {
3862 /* There are no further runs, so take end of text as end of candidate */
3863 *candidate_max
= para
->member
.para
.nCharOfs
+ item
->member
.run
.nCharOfs
+ nStart
;
3864 if (lastAcceptedChar
== ':') (*candidate_max
)--;
3869 para
= ME_GetParagraph(item
);
3874 if (*candidate_min
>= 0) {
3875 /* There are no further runs, so take end of text as end of candidate */
3876 *candidate_max
= para
->member
.para
.nCharOfs
+ item
->member
.run
.nCharOfs
+ nStart
;
3877 if (lastAcceptedChar
== ':') (*candidate_max
)--;
3885 * This proc evaluates the selection and returns TRUE if it can be considered an URL
3887 BOOL
ME_IsCandidateAnURL(ME_TextEditor
*editor
, int sel_min
, int sel_max
)
3893 /* Code below depends on these being in decreasing length order! */
3907 LPWSTR bufferW
= NULL
;
3911 if (sel_max
== -1) sel_max
= ME_GetTextLength(editor
);
3912 assert(sel_min
<= sel_max
);
3913 for (i
= 0; i
< sizeof(prefixes
) / sizeof(struct prefix_s
); i
++)
3915 if (sel_max
- sel_min
< prefixes
[i
].length
) continue;
3916 if (bufferW
== NULL
) {
3917 bufferW
= (LPWSTR
)heap_alloc((sel_max
- sel_min
+ 1) * sizeof(WCHAR
));
3919 ME_GetTextW(editor
, bufferW
, sel_min
, min(sel_max
- sel_min
, strlen(prefixes
[i
].text
)), 0);
3920 MultiByteToWideChar(CP_ACP
, 0, prefixes
[i
].text
, -1, bufW
, 32);
3921 if (!lstrcmpW(bufW
, bufferW
))
3932 * This proc walks through the indicated selection and evaluates whether each
3933 * section identified by ME_FindNextURLCandidate and in-between sections have
3934 * their proper CFE_LINK attributes set or unset. If the CFE_LINK attribute is
3935 * not what it is supposed to be, this proc sets or unsets it as appropriate.
3937 * Returns TRUE if at least one section was modified.
3939 BOOL
ME_UpdateLinkAttribute(ME_TextEditor
*editor
, int sel_min
, int sel_max
)
3941 BOOL modified
= FALSE
;
3944 if (sel_max
== -1) sel_max
= ME_GetTextLength(editor
);
3951 if (ME_FindNextURLCandidate(editor
, sel_min
, sel_max
, &cMin
, &cMax
))
3953 /* Section before candidate is not an URL */
3954 beforeURL
[0] = sel_min
;
3955 beforeURL
[1] = cMin
;
3957 if (ME_IsCandidateAnURL(editor
, cMin
, cMax
))
3959 inURL
[0] = cMin
; inURL
[1] = cMax
;
3963 beforeURL
[1] = cMax
;
3964 inURL
[0] = inURL
[1] = -1;
3970 /* No more candidates until end of selection */
3971 beforeURL
[0] = sel_min
;
3972 beforeURL
[1] = sel_max
;
3973 inURL
[0] = inURL
[1] = -1;
3977 if (beforeURL
[0] < beforeURL
[1])
3979 /* CFE_LINK effect should be consistently unset */
3980 link
.cbSize
= sizeof(link
);
3981 ME_GetCharFormat(editor
, beforeURL
[0], beforeURL
[1], &link
);
3982 if (!(link
.dwMask
& CFM_LINK
) || (link
.dwEffects
& CFE_LINK
))
3984 /* CFE_LINK must be unset from this range */
3985 memset(&link
, 0, sizeof(CHARFORMAT2W
));
3986 link
.cbSize
= sizeof(link
);
3987 link
.dwMask
= CFM_LINK
;
3989 ME_SetCharFormat(editor
, beforeURL
[0], beforeURL
[1] - beforeURL
[0], &link
);
3993 if (inURL
[0] < inURL
[1])
3995 /* CFE_LINK effect should be consistently set */
3996 link
.cbSize
= sizeof(link
);
3997 ME_GetCharFormat(editor
, inURL
[0], inURL
[1], &link
);
3998 if (!(link
.dwMask
& CFM_LINK
) || !(link
.dwEffects
& CFE_LINK
))
4000 /* CFE_LINK must be set on this range */
4001 memset(&link
, 0, sizeof(CHARFORMAT2W
));
4002 link
.cbSize
= sizeof(link
);
4003 link
.dwMask
= CFM_LINK
;
4004 link
.dwEffects
= CFE_LINK
;
4005 ME_SetCharFormat(editor
, inURL
[0], inURL
[1] - inURL
[0], &link
);
4009 } while (sel_min
< sel_max
);
4013 void ME_UpdateSelectionLinkAttribute(ME_TextEditor
*editor
)
4015 ME_DisplayItem
* startPara
, * endPara
;
4016 ME_DisplayItem
* item
;
4020 ME_GetSelection(editor
, &from
, &to
);
4021 if (from
> to
) from
^= to
, to
^=from
, from
^= to
;
4022 startPara
= NULL
; endPara
= NULL
;
4024 /* Find paragraph previous to the one that contains start cursor */
4025 item
= ME_FindItemAtOffset(editor
, diRun
, from
, &dummy
);
4027 startPara
= ME_FindItemBack(item
, diParagraph
);
4028 item
= ME_FindItemBack(startPara
, diParagraph
);
4029 if (item
) startPara
= item
;
4032 /* Find paragraph that contains end cursor */
4033 item
= ME_FindItemAtOffset(editor
, diRun
, to
, &dummy
);
4035 endPara
= ME_FindItemFwd(item
, diParagraph
);
4038 if (startPara
&& endPara
) {
4039 ME_UpdateLinkAttribute(editor
,
4040 startPara
->member
.para
.nCharOfs
,
4041 endPara
->member
.para
.nCharOfs
);
4042 } else if (startPara
) {
4043 ME_UpdateLinkAttribute(editor
,
4044 startPara
->member
.para
.nCharOfs
,