2 * RichEdit - operations on runs (diRun, rectangular pieces of paragraphs).
3 * Splitting/joining runs. Adjusting offsets after deleting/adding content.
4 * Character/pixel conversions.
6 * Copyright 2004 by Krzysztof Foltman
7 * Copyright 2006 by Phil Krylov
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
26 WINE_DEFAULT_DEBUG_CHANNEL(richedit
);
27 WINE_DECLARE_DEBUG_CHANNEL(richedit_check
);
28 WINE_DECLARE_DEBUG_CHANNEL(richedit_lists
);
30 /******************************************************************************
33 * Returns TRUE if two runs can be safely merged into one, FALSE otherwise.
35 BOOL
ME_CanJoinRuns(const ME_Run
*run1
, const ME_Run
*run2
)
37 if ((run1
->nFlags
| run2
->nFlags
) & MERF_NOJOIN
)
39 if (run1
->style
!= run2
->style
)
41 if ((run1
->nFlags
& MERF_STYLEFLAGS
) != (run2
->nFlags
& MERF_STYLEFLAGS
))
46 void ME_SkipAndPropagateCharOffset(ME_DisplayItem
*p
, int shift
)
48 p
= ME_FindItemFwd(p
, diRunOrParagraphOrEnd
);
50 ME_PropagateCharOffset(p
, shift
);
53 /******************************************************************************
54 * ME_PropagateCharOffsets
56 * Shifts (increases or decreases) character offset (relative to beginning of
57 * the document) of the part of the text starting from given place.
59 void ME_PropagateCharOffset(ME_DisplayItem
*p
, int shift
)
61 /* Runs in one paragraph contain character offset relative to their owning
62 * paragraph. If we start the shifting from the run, we need to shift
63 * all the relative offsets until the end of the paragraph
65 if (p
->type
== diRun
) /* propagate in all runs in this para */
67 TRACE("PropagateCharOffset(%s, %d)\n", debugstr_run( &p
->member
.run
), shift
);
69 p
->member
.run
.nCharOfs
+= shift
;
70 assert(p
->member
.run
.nCharOfs
>= 0);
71 p
= ME_FindItemFwd(p
, diRunOrParagraphOrEnd
);
72 } while(p
->type
== diRun
);
74 /* Runs in next paragraphs don't need their offsets updated, because they,
75 * again, those offsets are relative to their respective paragraphs.
76 * Instead of that, we're updating paragraphs' character offsets.
78 if (p
->type
== diParagraph
) /* propagate in all next paras */
81 p
->member
.para
.nCharOfs
+= shift
;
82 assert(p
->member
.para
.nCharOfs
>= 0);
83 p
= p
->member
.para
.next_para
;
84 } while(p
->type
== diParagraph
);
86 /* diTextEnd also has character offset in it, which makes finding text length
87 * easier. But it needs to be up to date first.
89 if (p
->type
== diTextEnd
)
91 p
->member
.para
.nCharOfs
+= shift
;
92 assert(p
->member
.para
.nCharOfs
>= 0);
96 /******************************************************************************
99 * Checks if editor lists' validity and optionally dumps the document structure
101 void ME_CheckCharOffsets(ME_TextEditor
*editor
)
103 ME_DisplayItem
*p
= editor
->pBuffer
->pFirst
;
104 int ofs
= 0, ofsp
= 0;
105 if(TRACE_ON(richedit_lists
))
107 TRACE_(richedit_lists
)("---\n");
108 ME_DumpDocument(editor
->pBuffer
);
111 p
= ME_FindItemFwd(p
, diRunOrParagraphOrEnd
);
114 TRACE_(richedit_check
)("tend, real ofsp = %d, counted = %d\n", p
->member
.para
.nCharOfs
, ofsp
+ofs
);
115 assert(ofsp
+ofs
== p
->member
.para
.nCharOfs
);
118 TRACE_(richedit_check
)("para, real ofsp = %d, counted = %d\n", p
->member
.para
.nCharOfs
, ofsp
+ofs
);
119 assert(ofsp
+ofs
== p
->member
.para
.nCharOfs
);
120 ofsp
= p
->member
.para
.nCharOfs
;
124 TRACE_(richedit_check
)("run, real ofs = %d (+ofsp = %d), counted = %d, len = %d, txt = %s, flags=%08x, fx&mask = %08x\n",
125 p
->member
.run
.nCharOfs
, p
->member
.run
.nCharOfs
+ofsp
, ofsp
+ofs
,
126 p
->member
.run
.len
, debugstr_run( &p
->member
.run
),
127 p
->member
.run
.nFlags
,
128 p
->member
.run
.style
->fmt
.dwMask
& p
->member
.run
.style
->fmt
.dwEffects
);
129 assert(ofs
== p
->member
.run
.nCharOfs
);
130 assert(p
->member
.run
.len
);
131 ofs
+= p
->member
.run
.len
;
134 TRACE_(richedit_check
)("cell\n");
142 /******************************************************************************
143 * ME_CharOfsFromRunOfs
145 * Converts a character position relative to the start of the run, to a
146 * character position relative to the start of the document.
147 * Kind of a "local to global" offset conversion.
149 int ME_CharOfsFromRunOfs(ME_TextEditor
*editor
, const ME_DisplayItem
*pPara
,
150 const ME_DisplayItem
*pRun
, int nOfs
)
152 assert(pRun
&& pRun
->type
== diRun
);
153 assert(pPara
&& pPara
->type
== diParagraph
);
154 return pPara
->member
.para
.nCharOfs
+ pRun
->member
.run
.nCharOfs
+ nOfs
;
157 /******************************************************************************
158 * ME_CursorFromCharOfs
160 * Converts a character offset (relative to the start of the document) to
161 * a cursor structure (which contains a run and a position relative to that
164 void ME_CursorFromCharOfs(ME_TextEditor
*editor
, int nCharOfs
, ME_Cursor
*pCursor
)
166 ME_RunOfsFromCharOfs(editor
, nCharOfs
, &pCursor
->pPara
,
167 &pCursor
->pRun
, &pCursor
->nOffset
);
170 /******************************************************************************
171 * ME_RunOfsFromCharOfs
173 * Find a run and relative character offset given an absolute character offset
174 * (absolute offset being an offset relative to the start of the document).
175 * Kind of a "global to local" offset conversion.
177 void ME_RunOfsFromCharOfs(ME_TextEditor
*editor
,
179 ME_DisplayItem
**ppPara
,
180 ME_DisplayItem
**ppRun
,
183 ME_DisplayItem
*item
, *next_item
;
185 nCharOfs
= max(nCharOfs
, 0);
186 nCharOfs
= min(nCharOfs
, ME_GetTextLength(editor
));
188 /* Find the paragraph at the offset. */
189 next_item
= editor
->pBuffer
->pFirst
->member
.para
.next_para
;
192 next_item
= item
->member
.para
.next_para
;
193 } while (next_item
->member
.para
.nCharOfs
<= nCharOfs
);
194 assert(item
->type
== diParagraph
);
195 nCharOfs
-= item
->member
.para
.nCharOfs
;
196 if (ppPara
) *ppPara
= item
;
198 /* Find the run at the offset. */
199 next_item
= ME_FindItemFwd(item
, diRun
);
202 next_item
= ME_FindItemFwd(item
, diRunOrParagraphOrEnd
);
203 } while (next_item
->type
== diRun
&&
204 next_item
->member
.run
.nCharOfs
<= nCharOfs
);
205 assert(item
->type
== diRun
);
206 nCharOfs
-= item
->member
.run
.nCharOfs
;
208 if (ppRun
) *ppRun
= item
;
209 if (pOfs
) *pOfs
= nCharOfs
;
212 /******************************************************************************
215 * Merges two adjacent runs, the one given as a parameter and the next one.
217 void ME_JoinRuns(ME_TextEditor
*editor
, ME_DisplayItem
*p
)
219 ME_DisplayItem
*pNext
= p
->next
;
221 assert(p
->type
== diRun
&& pNext
->type
== diRun
);
222 assert(p
->member
.run
.nCharOfs
!= -1);
223 ME_GetParagraph(p
)->member
.para
.nFlags
|= MEPF_REWRAP
;
225 /* Update all cursors so that they don't contain the soon deleted run */
226 for (i
=0; i
<editor
->nCursors
; i
++) {
227 if (editor
->pCursors
[i
].pRun
== pNext
) {
228 editor
->pCursors
[i
].pRun
= p
;
229 editor
->pCursors
[i
].nOffset
+= p
->member
.run
.len
;
233 p
->member
.run
.len
+= pNext
->member
.run
.len
;
235 ME_DestroyDisplayItem(pNext
);
236 ME_UpdateRunFlags(editor
, &p
->member
.run
);
237 if(TRACE_ON(richedit
))
239 TRACE("Before check after join\n");
240 ME_CheckCharOffsets(editor
);
241 TRACE("After check after join\n");
245 /******************************************************************************
248 * Does the most basic job of splitting a run into two - it does not
249 * update the positions and extents.
251 ME_DisplayItem
*ME_SplitRunSimple(ME_TextEditor
*editor
, ME_Cursor
*cursor
)
253 ME_DisplayItem
*run
= cursor
->pRun
;
254 ME_DisplayItem
*new_run
;
256 int nOffset
= cursor
->nOffset
;
258 assert(!(run
->member
.run
.nFlags
& MERF_NONTEXT
));
260 new_run
= ME_MakeRun(run
->member
.run
.style
,
261 run
->member
.run
.nFlags
& MERF_SPLITMASK
);
262 new_run
->member
.run
.nCharOfs
= run
->member
.run
.nCharOfs
+ nOffset
;
263 new_run
->member
.run
.len
= run
->member
.run
.len
- nOffset
;
264 new_run
->member
.run
.para
= run
->member
.run
.para
;
265 run
->member
.run
.len
= nOffset
;
266 cursor
->pRun
= new_run
;
269 ME_InsertBefore(run
->next
, new_run
);
271 ME_UpdateRunFlags(editor
, &run
->member
.run
);
272 ME_UpdateRunFlags(editor
, &new_run
->member
.run
);
273 for (i
= 0; i
< editor
->nCursors
; i
++) {
274 if (editor
->pCursors
[i
].pRun
== run
&&
275 editor
->pCursors
[i
].nOffset
>= nOffset
) {
276 editor
->pCursors
[i
].pRun
= new_run
;
277 editor
->pCursors
[i
].nOffset
-= nOffset
;
280 cursor
->pPara
->member
.para
.nFlags
|= MEPF_REWRAP
;
284 /******************************************************************************
287 * A helper function to create run structures quickly.
289 ME_DisplayItem
*ME_MakeRun(ME_Style
*s
, int nFlags
)
291 ME_DisplayItem
*item
= ME_MakeDI(diRun
);
292 item
->member
.run
.style
= s
;
293 item
->member
.run
.ole_obj
= NULL
;
294 item
->member
.run
.nFlags
= nFlags
;
295 item
->member
.run
.nCharOfs
= -1;
296 item
->member
.run
.len
= 0;
297 item
->member
.run
.para
= NULL
;
298 item
->member
.run
.num_glyphs
= 0;
299 item
->member
.run
.max_glyphs
= 0;
300 item
->member
.run
.glyphs
= NULL
;
301 item
->member
.run
.vis_attrs
= NULL
;
302 item
->member
.run
.advances
= NULL
;
303 item
->member
.run
.offsets
= NULL
;
304 item
->member
.run
.max_clusters
= 0;
305 item
->member
.run
.clusters
= NULL
;
310 /******************************************************************************
311 * ME_InsertRunAtCursor
313 * Inserts a new run with given style, flags and content at a given position,
314 * which is passed as a cursor structure (which consists of a run and
315 * a run-relative character offset).
318 ME_InsertRunAtCursor(ME_TextEditor
*editor
, ME_Cursor
*cursor
, ME_Style
*style
,
319 const WCHAR
*str
, int len
, int flags
)
321 ME_DisplayItem
*pDI
, *insert_before
= cursor
->pRun
, *prev
;
325 if (cursor
->nOffset
== cursor
->pRun
->member
.run
.len
)
327 insert_before
= ME_FindItemFwd( cursor
->pRun
, diRun
);
328 if (!insert_before
) insert_before
= cursor
->pRun
; /* Always insert before the final eop run */
332 ME_SplitRunSimple( editor
, cursor
);
333 insert_before
= cursor
->pRun
;
337 add_undo_delete_run( editor
, insert_before
->member
.run
.para
->nCharOfs
+
338 insert_before
->member
.run
.nCharOfs
, len
);
340 pDI
= ME_MakeRun(style
, flags
);
341 pDI
->member
.run
.nCharOfs
= insert_before
->member
.run
.nCharOfs
;
342 pDI
->member
.run
.len
= len
;
343 pDI
->member
.run
.para
= insert_before
->member
.run
.para
;
344 ME_InsertString( pDI
->member
.run
.para
->text
, pDI
->member
.run
.nCharOfs
, str
, len
);
345 ME_InsertBefore( insert_before
, pDI
);
346 TRACE("Shift length:%d\n", len
);
347 ME_PropagateCharOffset( insert_before
, len
);
348 insert_before
->member
.run
.para
->nFlags
|= MEPF_REWRAP
;
350 /* Move any cursors that were at the end of the previous run to the end of the inserted run */
351 prev
= ME_FindItemBack( pDI
, diRun
);
356 for (i
= 0; i
< editor
->nCursors
; i
++)
358 if (editor
->pCursors
[i
].pRun
== prev
&&
359 editor
->pCursors
[i
].nOffset
== prev
->member
.run
.len
)
361 editor
->pCursors
[i
].pRun
= pDI
;
362 editor
->pCursors
[i
].nOffset
= len
;
370 static BOOL
run_is_splittable( const ME_Run
*run
)
372 WCHAR
*str
= get_text( run
, 0 ), *p
;
374 BOOL found_ink
= FALSE
;
376 for (i
= 0, p
= str
; i
< run
->len
; i
++, p
++)
378 if (ME_IsWSpace( *p
))
380 if (found_ink
) return TRUE
;
388 static BOOL
run_is_entirely_ws( const ME_Run
*run
)
390 WCHAR
*str
= get_text( run
, 0 ), *p
;
393 for (i
= 0, p
= str
; i
< run
->len
; i
++, p
++)
394 if (!ME_IsWSpace( *p
)) return FALSE
;
399 /******************************************************************************
402 * Determine some of run attributes given its content (style, text content).
403 * Some flags cannot be determined by this function (MERF_GRAPHICS,
406 void ME_UpdateRunFlags(ME_TextEditor
*editor
, ME_Run
*run
)
408 assert(run
->nCharOfs
>= 0);
410 if (RUN_IS_HIDDEN(run
) || run
->nFlags
& MERF_TABLESTART
)
411 run
->nFlags
|= MERF_HIDDEN
;
413 run
->nFlags
&= ~MERF_HIDDEN
;
415 if (run_is_splittable( run
))
416 run
->nFlags
|= MERF_SPLITTABLE
;
418 run
->nFlags
&= ~MERF_SPLITTABLE
;
420 if (!(run
->nFlags
& MERF_NOTEXT
))
422 if (run_is_entirely_ws( run
))
423 run
->nFlags
|= MERF_WHITESPACE
| MERF_STARTWHITE
| MERF_ENDWHITE
;
426 run
->nFlags
&= ~MERF_WHITESPACE
;
428 if (ME_IsWSpace( *get_text( run
, 0 ) ))
429 run
->nFlags
|= MERF_STARTWHITE
;
431 run
->nFlags
&= ~MERF_STARTWHITE
;
433 if (ME_IsWSpace( *get_text( run
, run
->len
- 1 ) ))
434 run
->nFlags
|= MERF_ENDWHITE
;
436 run
->nFlags
&= ~MERF_ENDWHITE
;
440 run
->nFlags
&= ~(MERF_WHITESPACE
| MERF_STARTWHITE
| MERF_ENDWHITE
);
443 /******************************************************************************
444 * ME_CharFromPointContext
446 * Returns a character position inside the run given a run-relative
447 * pixel horizontal position.
449 * If closest is FALSE return the actual character
450 * If closest is TRUE will round to the closest leading edge.
451 * ie. if the second character is at pixel position 8 and third at 16 then for:
452 * closest = FALSE cx = 0..7 return 0, cx = 8..15 return 1
453 * closest = TRUE cx = 0..3 return 0, cx = 4..11 return 1.
455 int ME_CharFromPointContext(ME_Context
*c
, int cx
, ME_Run
*run
, BOOL closest
, BOOL visual_order
)
457 ME_String
*mask_text
= NULL
;
462 if (!run
->len
|| cx
<= 0)
465 if (run
->nFlags
& (MERF_TAB
| MERF_ENDCELL
))
467 if (!closest
|| cx
< run
->nWidth
/ 2) return 0;
471 if (run
->nFlags
& MERF_GRAPHICS
)
474 ME_GetOLEObjectSize(c
, run
, &sz
);
475 if (!closest
|| cx
< sz
.cx
/ 2) return 0;
479 if (run
->para
->nFlags
& MEPF_COMPLEX
)
482 if (visual_order
&& run
->script_analysis
.fRTL
) cx
= run
->nWidth
- cx
- 1;
484 ScriptXtoCP( cx
, run
->len
, run
->num_glyphs
, run
->clusters
, run
->vis_attrs
, run
->advances
, &run
->script_analysis
,
486 TRACE("x %d cp %d trailing %d (run width %d) rtl %d log order %d\n", cx
, cp
, trailing
, run
->nWidth
,
487 run
->script_analysis
.fRTL
, run
->script_analysis
.fLogicalOrder
);
488 return closest
? cp
+ trailing
: cp
;
491 if (c
->editor
->cPasswordMask
)
493 mask_text
= ME_MakeStringR( c
->editor
->cPasswordMask
, run
->len
);
494 str
= mask_text
->szData
;
497 str
= get_text( run
, 0 );
499 hOldFont
= ME_SelectStyleFont(c
, run
->style
);
500 GetTextExtentExPointW(c
->hDC
, str
, run
->len
,
501 cx
, &fit
, NULL
, &sz
);
502 if (closest
&& fit
!= run
->len
)
504 GetTextExtentPoint32W(c
->hDC
, str
, fit
, &sz2
);
505 GetTextExtentPoint32W(c
->hDC
, str
, fit
+ 1, &sz3
);
506 if (cx
>= (sz2
.cx
+sz3
.cx
)/2)
510 ME_DestroyString( mask_text
);
512 ME_UnselectStyleFont(c
, run
->style
, hOldFont
);
516 int ME_CharFromPoint(ME_TextEditor
*editor
, int cx
, ME_Run
*run
, BOOL closest
, BOOL visual_order
)
521 ME_InitContext( &c
, editor
, ITextHost_TxGetDC( editor
->texthost
) );
522 ret
= ME_CharFromPointContext( &c
, cx
, run
, closest
, visual_order
);
523 ME_DestroyContext(&c
);
527 /******************************************************************************
530 * Finds a width and a height of the text using a specified style
532 static void ME_GetTextExtent(ME_Context
*c
, LPCWSTR szText
, int nChars
, ME_Style
*s
, SIZE
*size
)
536 hOldFont
= ME_SelectStyleFont(c
, s
);
537 GetTextExtentPoint32W(c
->hDC
, szText
, nChars
, size
);
538 ME_UnselectStyleFont(c
, s
, hOldFont
);
545 /******************************************************************************
546 * ME_PointFromCharContext
548 * Returns a run-relative pixel position given a run-relative character
549 * position (character offset)
551 int ME_PointFromCharContext(ME_Context
*c
, ME_Run
*pRun
, int nOffset
, BOOL visual_order
)
554 ME_String
*mask_text
= NULL
;
557 if (pRun
->nFlags
& MERF_GRAPHICS
)
560 ME_GetOLEObjectSize(c
, pRun
, &size
);
562 } else if (pRun
->nFlags
& MERF_ENDPARA
) {
566 if (pRun
->para
->nFlags
& MEPF_COMPLEX
)
569 ScriptCPtoX( nOffset
, FALSE
, pRun
->len
, pRun
->num_glyphs
, pRun
->clusters
,
570 pRun
->vis_attrs
, pRun
->advances
, &pRun
->script_analysis
, &x
);
571 if (visual_order
&& pRun
->script_analysis
.fRTL
) x
= pRun
->nWidth
- x
- 1;
574 if (c
->editor
->cPasswordMask
)
576 mask_text
= ME_MakeStringR(c
->editor
->cPasswordMask
, pRun
->len
);
577 str
= mask_text
->szData
;
580 str
= get_text( pRun
, 0 );
582 ME_GetTextExtent(c
, str
, nOffset
, pRun
->style
, &size
);
583 ME_DestroyString( mask_text
);
587 /******************************************************************************
590 * Calls ME_PointFromCharContext after first creating a context.
592 int ME_PointFromChar(ME_TextEditor
*editor
, ME_Run
*pRun
, int nOffset
, BOOL visual_order
)
597 ME_InitContext(&c
, editor
, ITextHost_TxGetDC(editor
->texthost
));
598 ret
= ME_PointFromCharContext( &c
, pRun
, nOffset
, visual_order
);
599 ME_DestroyContext(&c
);
604 /******************************************************************************
605 * ME_GetRunSizeCommon
607 * Finds width, height, ascent and descent of a run, up to given character
610 SIZE
ME_GetRunSizeCommon(ME_Context
*c
, const ME_Paragraph
*para
, ME_Run
*run
, int nLen
,
611 int startx
, int *pAscent
, int *pDescent
)
614 int nMaxLen
= run
->len
;
619 /* FIXME the following call also ensures that TEXTMETRIC structure is filled
620 * this is wasteful for MERF_NONTEXT runs, but that shouldn't matter
624 if (para
->nFlags
& MEPF_COMPLEX
)
626 size
.cx
= run
->nWidth
;
628 else if (c
->editor
->cPasswordMask
)
630 ME_String
*szMasked
= ME_MakeStringR(c
->editor
->cPasswordMask
,nLen
);
631 ME_GetTextExtent(c
, szMasked
->szData
, nLen
,run
->style
, &size
);
632 ME_DestroyString(szMasked
);
636 ME_GetTextExtent(c
, get_text( run
, 0 ), nLen
, run
->style
, &size
);
638 *pAscent
= run
->style
->tm
.tmAscent
;
639 *pDescent
= run
->style
->tm
.tmDescent
;
640 size
.cy
= *pAscent
+ *pDescent
;
642 if (run
->nFlags
& MERF_TAB
)
644 int pos
= 0, i
= 0, ppos
, shift
= 0;
645 PARAFORMAT2
*pFmt
= para
->pFmt
;
647 if (c
->editor
->bEmulateVersion10
&& /* v1.0 - 3.0 */
648 pFmt
->dwMask
& PFM_TABLE
&& pFmt
->wEffects
& PFE_TABLE
)
649 /* The horizontal gap shifts the tab positions to leave the gap. */
650 shift
= pFmt
->dxOffset
* 2;
652 if (i
< pFmt
->cTabCount
)
654 /* Only one side of the horizontal gap is needed at the end of
656 if (i
== pFmt
->cTabCount
-1)
658 pos
= shift
+ (pFmt
->rgxTabs
[i
]&0x00FFFFFF);
663 pos
+= lDefaultTab
- (pos
% lDefaultTab
);
665 ppos
= ME_twips2pointsX(c
, pos
);
666 if (ppos
> startx
+ run
->pt
.x
) {
667 size
.cx
= ppos
- startx
- run
->pt
.x
;
671 size
.cy
= *pAscent
+ *pDescent
;
674 if (run
->nFlags
& MERF_GRAPHICS
)
676 ME_GetOLEObjectSize(c
, run
, &size
);
677 if (size
.cy
> *pAscent
)
679 /* descent is unchanged */
685 /******************************************************************************
686 * ME_SetSelectionCharFormat
688 * Applies a style change, either to a current selection, or to insert cursor
689 * (ie. the style next typed characters will use).
691 void ME_SetSelectionCharFormat(ME_TextEditor
*editor
, CHARFORMAT2W
*pFmt
)
693 if (!ME_IsSelection(editor
))
696 if (!editor
->pBuffer
->pCharStyle
)
697 editor
->pBuffer
->pCharStyle
= ME_GetInsertStyle(editor
, 0);
698 s
= ME_ApplyStyle(editor
->pBuffer
->pCharStyle
, pFmt
);
699 ME_ReleaseStyle(editor
->pBuffer
->pCharStyle
);
700 editor
->pBuffer
->pCharStyle
= s
;
702 ME_Cursor
*from
, *to
;
703 ME_GetSelection(editor
, &from
, &to
);
704 ME_SetCharFormat(editor
, from
, to
, pFmt
);
708 /******************************************************************************
711 * Applies a style change to the specified part of the text
713 * The start and end cursors specify the part of the text. These cursors will
714 * be updated to stay valid, but this function may invalidate other
715 * non-selection cursors. The end cursor may be NULL to specify all the text
716 * following the start cursor.
718 * If no text is selected, then nothing is done.
720 void ME_SetCharFormat(ME_TextEditor
*editor
, ME_Cursor
*start
, ME_Cursor
*end
, CHARFORMAT2W
*pFmt
)
722 ME_DisplayItem
*run
, *start_run
= start
->pRun
, *end_run
= NULL
;
724 if (end
&& start
->pRun
== end
->pRun
&& start
->nOffset
== end
->nOffset
)
727 if (start
->nOffset
== start
->pRun
->member
.run
.len
)
728 start_run
= ME_FindItemFwd( start
->pRun
, diRun
);
729 else if (start
->nOffset
)
731 /* SplitRunSimple may or may not update the cursors, depending on whether they
732 * are selection cursors, but we need to make sure they are valid. */
733 int split_offset
= start
->nOffset
;
734 ME_DisplayItem
*split_run
= ME_SplitRunSimple(editor
, start
);
735 start_run
= start
->pRun
;
736 if (end
&& end
->pRun
== split_run
)
738 end
->pRun
= start
->pRun
;
739 end
->nOffset
-= split_offset
;
745 if (end
->nOffset
== end
->pRun
->member
.run
.len
)
746 end_run
= ME_FindItemFwd( end
->pRun
, diRun
);
749 if (end
->nOffset
) ME_SplitRunSimple(editor
, end
);
754 for (run
= start_run
; run
!= end_run
; run
= ME_FindItemFwd( run
, diRun
))
756 ME_Style
*new_style
= ME_ApplyStyle(run
->member
.run
.style
, pFmt
);
758 add_undo_set_char_fmt( editor
, run
->member
.run
.para
->nCharOfs
+ run
->member
.run
.nCharOfs
,
759 run
->member
.run
.len
, &run
->member
.run
.style
->fmt
);
760 ME_ReleaseStyle(run
->member
.run
.style
);
761 run
->member
.run
.style
= new_style
;
762 run
->member
.run
.para
->nFlags
|= MEPF_REWRAP
;
766 /******************************************************************************
767 * ME_SetDefaultCharFormat
769 * Applies a style change to the default character style.
771 void ME_SetDefaultCharFormat(ME_TextEditor
*editor
, CHARFORMAT2W
*mod
)
775 assert(mod
->cbSize
== sizeof(CHARFORMAT2W
));
776 style
= ME_ApplyStyle(editor
->pBuffer
->pDefaultStyle
, mod
);
777 editor
->pBuffer
->pDefaultStyle
->fmt
= style
->fmt
;
778 editor
->pBuffer
->pDefaultStyle
->tm
= style
->tm
;
779 ScriptFreeCache( &editor
->pBuffer
->pDefaultStyle
->script_cache
);
780 ME_ReleaseStyle(style
);
781 ME_MarkAllForWrapping(editor
);
782 /* pcf = editor->pBuffer->pDefaultStyle->fmt; */
785 static void ME_GetRunCharFormat(ME_TextEditor
*editor
, ME_DisplayItem
*run
, CHARFORMAT2W
*pFmt
)
787 ME_CopyCharFormat(pFmt
, &run
->member
.run
.style
->fmt
);
788 if ((pFmt
->dwMask
& CFM_UNDERLINETYPE
) && (pFmt
->bUnderlineType
== CFU_CF1UNDERLINE
))
790 pFmt
->dwMask
|= CFM_UNDERLINE
;
791 pFmt
->dwEffects
|= CFE_UNDERLINE
;
793 if ((pFmt
->dwMask
& CFM_UNDERLINETYPE
) && (pFmt
->bUnderlineType
== CFU_UNDERLINENONE
))
795 pFmt
->dwMask
|= CFM_UNDERLINE
;
796 pFmt
->dwEffects
&= ~CFE_UNDERLINE
;
800 /******************************************************************************
801 * ME_GetDefaultCharFormat
803 * Retrieves the current default character style (the one applied where no
804 * other style was applied) .
806 void ME_GetDefaultCharFormat(ME_TextEditor
*editor
, CHARFORMAT2W
*pFmt
)
808 ME_CopyCharFormat(pFmt
, &editor
->pBuffer
->pDefaultStyle
->fmt
);
811 /******************************************************************************
812 * ME_GetSelectionCharFormat
814 * If selection exists, it returns all style elements that are set consistently
815 * in the whole selection. If not, it just returns the current style.
817 void ME_GetSelectionCharFormat(ME_TextEditor
*editor
, CHARFORMAT2W
*pFmt
)
819 ME_Cursor
*from
, *to
;
820 if (!ME_IsSelection(editor
) && editor
->pBuffer
->pCharStyle
)
822 ME_CopyCharFormat(pFmt
, &editor
->pBuffer
->pCharStyle
->fmt
);
825 ME_GetSelection(editor
, &from
, &to
);
826 ME_GetCharFormat(editor
, from
, to
, pFmt
);
829 /******************************************************************************
832 * Returns the style consisting of those attributes which are consistently set
833 * in the whole character range.
835 void ME_GetCharFormat(ME_TextEditor
*editor
, const ME_Cursor
*from
,
836 const ME_Cursor
*to
, CHARFORMAT2W
*pFmt
)
838 ME_DisplayItem
*run
, *run_end
;
842 /* special case - if selection is empty, take previous char's formatting */
843 if (from
->pRun
== to
->pRun
&& from
->nOffset
== to
->nOffset
)
847 ME_DisplayItem
*tmp_run
= ME_FindItemBack(run
, diRunOrParagraph
);
848 if (tmp_run
->type
== diRun
) {
849 ME_GetRunCharFormat(editor
, tmp_run
, pFmt
);
853 ME_GetRunCharFormat(editor
, run
, pFmt
);
859 run_end
= ME_FindItemBack(run_end
, diRun
);
861 ME_GetRunCharFormat(editor
, run
, pFmt
);
863 if (run
== run_end
) return;
866 /* FIXME add more style feature comparisons */
867 DWORD dwAttribs
= CFM_SIZE
| CFM_FACE
| CFM_COLOR
| CFM_UNDERLINETYPE
;
868 DWORD dwEffects
= CFM_BOLD
| CFM_ITALIC
| CFM_UNDERLINE
| CFM_STRIKEOUT
| CFM_PROTECTED
| CFM_LINK
| CFM_SUPERSCRIPT
;
870 run
= ME_FindItemFwd(run
, diRun
);
872 ZeroMemory(&tmp
, sizeof(tmp
));
873 tmp
.cbSize
= sizeof(tmp
);
874 ME_GetRunCharFormat(editor
, run
, &tmp
);
876 assert((tmp
.dwMask
& dwAttribs
) == dwAttribs
);
877 /* reset flags that differ */
879 if (pFmt
->yHeight
!= tmp
.yHeight
)
880 pFmt
->dwMask
&= ~CFM_SIZE
;
881 if (pFmt
->dwMask
& CFM_FACE
)
883 if (!(tmp
.dwMask
& CFM_FACE
))
884 pFmt
->dwMask
&= ~CFM_FACE
;
885 else if (lstrcmpW(pFmt
->szFaceName
, tmp
.szFaceName
) ||
886 pFmt
->bPitchAndFamily
!= tmp
.bPitchAndFamily
)
887 pFmt
->dwMask
&= ~CFM_FACE
;
889 if (pFmt
->yHeight
!= tmp
.yHeight
)
890 pFmt
->dwMask
&= ~CFM_SIZE
;
891 if (pFmt
->bUnderlineType
!= tmp
.bUnderlineType
)
892 pFmt
->dwMask
&= ~CFM_UNDERLINETYPE
;
893 if (pFmt
->dwMask
& CFM_COLOR
)
895 if (!((pFmt
->dwEffects
&CFE_AUTOCOLOR
) & (tmp
.dwEffects
&CFE_AUTOCOLOR
)))
897 if (pFmt
->crTextColor
!= tmp
.crTextColor
)
898 pFmt
->dwMask
&= ~CFM_COLOR
;
902 pFmt
->dwMask
&= ~((pFmt
->dwEffects
^ tmp
.dwEffects
) & dwEffects
);
903 pFmt
->dwEffects
= tmp
.dwEffects
;
905 } while(run
!= run_end
);