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;
106 TRACE_(richedit_check
)("Checking begin\n");
107 if(TRACE_ON(richedit_lists
))
109 TRACE_(richedit_lists
)("---\n");
110 ME_DumpDocument(editor
->pBuffer
);
113 p
= ME_FindItemFwd(p
, diRunOrParagraphOrEnd
);
116 TRACE_(richedit_check
)("tend, real ofsp = %d, counted = %d\n", p
->member
.para
.nCharOfs
, ofsp
+ofs
);
117 assert(ofsp
+ofs
== p
->member
.para
.nCharOfs
);
118 TRACE_(richedit_check
)("Checking finished\n");
121 TRACE_(richedit_check
)("para, real ofsp = %d, counted = %d\n", p
->member
.para
.nCharOfs
, ofsp
+ofs
);
122 assert(ofsp
+ofs
== p
->member
.para
.nCharOfs
);
123 ofsp
= p
->member
.para
.nCharOfs
;
127 TRACE_(richedit_check
)("run, real ofs = %d (+ofsp = %d), counted = %d, len = %d, txt = %s, flags=%08x, fx&mask = %08x\n",
128 p
->member
.run
.nCharOfs
, p
->member
.run
.nCharOfs
+ofsp
, ofsp
+ofs
,
129 p
->member
.run
.len
, debugstr_run( &p
->member
.run
),
130 p
->member
.run
.nFlags
,
131 p
->member
.run
.style
->fmt
.dwMask
& p
->member
.run
.style
->fmt
.dwEffects
);
132 assert(ofs
== p
->member
.run
.nCharOfs
);
133 assert(p
->member
.run
.len
);
134 ofs
+= p
->member
.run
.len
;
137 TRACE_(richedit_check
)("cell\n");
143 TRACE_(richedit_check
)("Checking finished\n");
146 /******************************************************************************
147 * ME_CharOfsFromRunOfs
149 * Converts a character position relative to the start of the run, to a
150 * character position relative to the start of the document.
151 * Kind of a "local to global" offset conversion.
153 int ME_CharOfsFromRunOfs(ME_TextEditor
*editor
, const ME_DisplayItem
*pPara
,
154 const ME_DisplayItem
*pRun
, int nOfs
)
156 assert(pRun
&& pRun
->type
== diRun
);
157 assert(pPara
&& pPara
->type
== diParagraph
);
158 return pPara
->member
.para
.nCharOfs
+ pRun
->member
.run
.nCharOfs
+ nOfs
;
161 /******************************************************************************
162 * ME_CursorFromCharOfs
164 * Converts a character offset (relative to the start of the document) to
165 * a cursor structure (which contains a run and a position relative to that
168 void ME_CursorFromCharOfs(ME_TextEditor
*editor
, int nCharOfs
, ME_Cursor
*pCursor
)
170 ME_RunOfsFromCharOfs(editor
, nCharOfs
, &pCursor
->pPara
,
171 &pCursor
->pRun
, &pCursor
->nOffset
);
174 /******************************************************************************
175 * ME_RunOfsFromCharOfs
177 * Find a run and relative character offset given an absolute character offset
178 * (absolute offset being an offset relative to the start of the document).
179 * Kind of a "global to local" offset conversion.
181 void ME_RunOfsFromCharOfs(ME_TextEditor
*editor
,
183 ME_DisplayItem
**ppPara
,
184 ME_DisplayItem
**ppRun
,
187 ME_DisplayItem
*item
, *next_item
;
188 int endOfs
= nCharOfs
, len
= ME_GetTextLength(editor
);
190 nCharOfs
= max(nCharOfs
, 0);
191 nCharOfs
= min(nCharOfs
, len
);
193 /* Find the paragraph at the offset. */
194 next_item
= editor
->pBuffer
->pFirst
->member
.para
.next_para
;
197 next_item
= item
->member
.para
.next_para
;
198 } while (next_item
->member
.para
.nCharOfs
<= nCharOfs
);
199 assert(item
->type
== diParagraph
);
200 nCharOfs
-= item
->member
.para
.nCharOfs
;
201 if (ppPara
) *ppPara
= item
;
203 /* Find the run at the offset. */
204 next_item
= ME_FindItemFwd(item
, diRun
);
207 next_item
= ME_FindItemFwd(item
, diRunOrParagraphOrEnd
);
208 } while (next_item
->type
== diRun
&&
209 next_item
->member
.run
.nCharOfs
<= nCharOfs
);
210 assert(item
->type
== diRun
);
211 nCharOfs
-= item
->member
.run
.nCharOfs
;
213 if (ppRun
) *ppRun
= item
;
215 if (((*ppRun
)->member
.run
.nFlags
& MERF_ENDPARA
) && endOfs
> len
)
216 *pOfs
= (*ppRun
)->member
.run
.len
;
217 else *pOfs
= nCharOfs
;
221 /******************************************************************************
224 * Merges two adjacent runs, the one given as a parameter and the next one.
226 void ME_JoinRuns(ME_TextEditor
*editor
, ME_DisplayItem
*p
)
228 ME_DisplayItem
*pNext
= p
->next
;
230 assert(p
->type
== diRun
&& pNext
->type
== diRun
);
231 assert(p
->member
.run
.nCharOfs
!= -1);
232 ME_GetParagraph(p
)->member
.para
.nFlags
|= MEPF_REWRAP
;
234 /* Update all cursors so that they don't contain the soon deleted run */
235 for (i
=0; i
<editor
->nCursors
; i
++) {
236 if (editor
->pCursors
[i
].pRun
== pNext
) {
237 editor
->pCursors
[i
].pRun
= p
;
238 editor
->pCursors
[i
].nOffset
+= p
->member
.run
.len
;
242 p
->member
.run
.len
+= pNext
->member
.run
.len
;
244 ME_DestroyDisplayItem(pNext
);
245 ME_UpdateRunFlags(editor
, &p
->member
.run
);
246 if(TRACE_ON(richedit_check
))
247 ME_CheckCharOffsets(editor
);
250 /******************************************************************************
253 * Does the most basic job of splitting a run into two - it does not
254 * update the positions and extents.
256 ME_DisplayItem
*ME_SplitRunSimple(ME_TextEditor
*editor
, ME_Cursor
*cursor
)
258 ME_DisplayItem
*run
= cursor
->pRun
;
259 ME_DisplayItem
*new_run
;
261 int nOffset
= cursor
->nOffset
;
263 assert(!(run
->member
.run
.nFlags
& MERF_NONTEXT
));
265 new_run
= ME_MakeRun(run
->member
.run
.style
,
266 run
->member
.run
.nFlags
& MERF_SPLITMASK
);
267 new_run
->member
.run
.nCharOfs
= run
->member
.run
.nCharOfs
+ nOffset
;
268 new_run
->member
.run
.len
= run
->member
.run
.len
- nOffset
;
269 new_run
->member
.run
.para
= run
->member
.run
.para
;
270 run
->member
.run
.len
= nOffset
;
271 cursor
->pRun
= new_run
;
274 ME_InsertBefore(run
->next
, new_run
);
276 ME_UpdateRunFlags(editor
, &run
->member
.run
);
277 ME_UpdateRunFlags(editor
, &new_run
->member
.run
);
278 for (i
= 0; i
< editor
->nCursors
; i
++) {
279 if (editor
->pCursors
[i
].pRun
== run
&&
280 editor
->pCursors
[i
].nOffset
>= nOffset
) {
281 editor
->pCursors
[i
].pRun
= new_run
;
282 editor
->pCursors
[i
].nOffset
-= nOffset
;
285 cursor
->pPara
->member
.para
.nFlags
|= MEPF_REWRAP
;
289 /******************************************************************************
292 * A helper function to create run structures quickly.
294 ME_DisplayItem
*ME_MakeRun(ME_Style
*s
, int nFlags
)
296 ME_DisplayItem
*item
= ME_MakeDI(diRun
);
297 item
->member
.run
.style
= s
;
298 item
->member
.run
.reobj
= NULL
;
299 item
->member
.run
.nFlags
= nFlags
;
300 item
->member
.run
.nCharOfs
= -1;
301 item
->member
.run
.len
= 0;
302 item
->member
.run
.para
= NULL
;
303 item
->member
.run
.num_glyphs
= 0;
304 item
->member
.run
.max_glyphs
= 0;
305 item
->member
.run
.glyphs
= NULL
;
306 item
->member
.run
.vis_attrs
= NULL
;
307 item
->member
.run
.advances
= NULL
;
308 item
->member
.run
.offsets
= NULL
;
309 item
->member
.run
.max_clusters
= 0;
310 item
->member
.run
.clusters
= NULL
;
315 /******************************************************************************
316 * ME_InsertRunAtCursor
318 * Inserts a new run with given style, flags and content at a given position,
319 * which is passed as a cursor structure (which consists of a run and
320 * a run-relative character offset).
323 ME_InsertRunAtCursor(ME_TextEditor
*editor
, ME_Cursor
*cursor
, ME_Style
*style
,
324 const WCHAR
*str
, int len
, int flags
)
326 ME_DisplayItem
*pDI
, *insert_before
= cursor
->pRun
, *prev
;
330 if (cursor
->nOffset
== cursor
->pRun
->member
.run
.len
)
332 insert_before
= ME_FindItemFwd( cursor
->pRun
, diRun
);
333 if (!insert_before
) insert_before
= cursor
->pRun
; /* Always insert before the final eop run */
337 ME_SplitRunSimple( editor
, cursor
);
338 insert_before
= cursor
->pRun
;
342 add_undo_delete_run( editor
, insert_before
->member
.run
.para
->nCharOfs
+
343 insert_before
->member
.run
.nCharOfs
, len
);
345 pDI
= ME_MakeRun(style
, flags
);
346 pDI
->member
.run
.nCharOfs
= insert_before
->member
.run
.nCharOfs
;
347 pDI
->member
.run
.len
= len
;
348 pDI
->member
.run
.para
= insert_before
->member
.run
.para
;
349 ME_InsertString( pDI
->member
.run
.para
->text
, pDI
->member
.run
.nCharOfs
, str
, len
);
350 ME_InsertBefore( insert_before
, pDI
);
351 TRACE("Shift length:%d\n", len
);
352 ME_PropagateCharOffset( insert_before
, len
);
353 insert_before
->member
.run
.para
->nFlags
|= MEPF_REWRAP
;
355 /* Move any cursors that were at the end of the previous run to the end of the inserted run */
356 prev
= ME_FindItemBack( pDI
, diRun
);
361 for (i
= 0; i
< editor
->nCursors
; i
++)
363 if (editor
->pCursors
[i
].pRun
== prev
&&
364 editor
->pCursors
[i
].nOffset
== prev
->member
.run
.len
)
366 editor
->pCursors
[i
].pRun
= pDI
;
367 editor
->pCursors
[i
].nOffset
= len
;
375 static BOOL
run_is_splittable( const ME_Run
*run
)
377 WCHAR
*str
= get_text( run
, 0 ), *p
;
379 BOOL found_ink
= FALSE
;
381 for (i
= 0, p
= str
; i
< run
->len
; i
++, p
++)
383 if (ME_IsWSpace( *p
))
385 if (found_ink
) return TRUE
;
393 static BOOL
run_is_entirely_ws( const ME_Run
*run
)
395 WCHAR
*str
= get_text( run
, 0 ), *p
;
398 for (i
= 0, p
= str
; i
< run
->len
; i
++, p
++)
399 if (!ME_IsWSpace( *p
)) return FALSE
;
404 /******************************************************************************
407 * Determine some of run attributes given its content (style, text content).
408 * Some flags cannot be determined by this function (MERF_GRAPHICS,
411 void ME_UpdateRunFlags(ME_TextEditor
*editor
, ME_Run
*run
)
413 assert(run
->nCharOfs
>= 0);
415 if (RUN_IS_HIDDEN(run
) || run
->nFlags
& MERF_TABLESTART
)
416 run
->nFlags
|= MERF_HIDDEN
;
418 run
->nFlags
&= ~MERF_HIDDEN
;
420 if (run_is_splittable( run
))
421 run
->nFlags
|= MERF_SPLITTABLE
;
423 run
->nFlags
&= ~MERF_SPLITTABLE
;
425 if (!(run
->nFlags
& MERF_NOTEXT
))
427 if (run_is_entirely_ws( run
))
428 run
->nFlags
|= MERF_WHITESPACE
| MERF_STARTWHITE
| MERF_ENDWHITE
;
431 run
->nFlags
&= ~MERF_WHITESPACE
;
433 if (ME_IsWSpace( *get_text( run
, 0 ) ))
434 run
->nFlags
|= MERF_STARTWHITE
;
436 run
->nFlags
&= ~MERF_STARTWHITE
;
438 if (ME_IsWSpace( *get_text( run
, run
->len
- 1 ) ))
439 run
->nFlags
|= MERF_ENDWHITE
;
441 run
->nFlags
&= ~MERF_ENDWHITE
;
445 run
->nFlags
&= ~(MERF_WHITESPACE
| MERF_STARTWHITE
| MERF_ENDWHITE
);
448 /******************************************************************************
449 * ME_CharFromPointContext
451 * Returns a character position inside the run given a run-relative
452 * pixel horizontal position.
454 * If closest is FALSE return the actual character
455 * If closest is TRUE will round to the closest leading edge.
456 * ie. if the second character is at pixel position 8 and third at 16 then for:
457 * closest = FALSE cx = 0..7 return 0, cx = 8..15 return 1
458 * closest = TRUE cx = 0..3 return 0, cx = 4..11 return 1.
460 int ME_CharFromPointContext(ME_Context
*c
, int cx
, ME_Run
*run
, BOOL closest
, BOOL visual_order
)
462 ME_String
*mask_text
= NULL
;
467 if (!run
->len
|| cx
<= 0)
470 if (run
->nFlags
& (MERF_TAB
| MERF_ENDCELL
))
472 if (!closest
|| cx
< run
->nWidth
/ 2) return 0;
476 if (run
->nFlags
& MERF_GRAPHICS
)
479 ME_GetOLEObjectSize(c
, run
, &sz
);
480 if (!closest
|| cx
< sz
.cx
/ 2) return 0;
484 if (run
->para
->nFlags
& MEPF_COMPLEX
)
487 if (visual_order
&& run
->script_analysis
.fRTL
) cx
= run
->nWidth
- cx
- 1;
489 ScriptXtoCP( cx
, run
->len
, run
->num_glyphs
, run
->clusters
, run
->vis_attrs
, run
->advances
, &run
->script_analysis
,
491 TRACE("x %d cp %d trailing %d (run width %d) rtl %d log order %d\n", cx
, cp
, trailing
, run
->nWidth
,
492 run
->script_analysis
.fRTL
, run
->script_analysis
.fLogicalOrder
);
493 return closest
? cp
+ trailing
: cp
;
496 if (c
->editor
->cPasswordMask
)
498 mask_text
= ME_MakeStringR( c
->editor
->cPasswordMask
, run
->len
);
499 str
= mask_text
->szData
;
502 str
= get_text( run
, 0 );
504 hOldFont
= ME_SelectStyleFont(c
, run
->style
);
505 GetTextExtentExPointW(c
->hDC
, str
, run
->len
,
506 cx
, &fit
, NULL
, &sz
);
507 if (closest
&& fit
!= run
->len
)
509 GetTextExtentPoint32W(c
->hDC
, str
, fit
, &sz2
);
510 GetTextExtentPoint32W(c
->hDC
, str
, fit
+ 1, &sz3
);
511 if (cx
>= (sz2
.cx
+sz3
.cx
)/2)
515 ME_DestroyString( mask_text
);
517 ME_UnselectStyleFont(c
, run
->style
, hOldFont
);
521 int ME_CharFromPoint(ME_TextEditor
*editor
, int cx
, ME_Run
*run
, BOOL closest
, BOOL visual_order
)
526 ME_InitContext( &c
, editor
, ITextHost_TxGetDC( editor
->texthost
) );
527 ret
= ME_CharFromPointContext( &c
, cx
, run
, closest
, visual_order
);
528 ME_DestroyContext(&c
);
532 /******************************************************************************
535 * Finds a width and a height of the text using a specified style
537 static void ME_GetTextExtent(ME_Context
*c
, LPCWSTR szText
, int nChars
, ME_Style
*s
, SIZE
*size
)
541 hOldFont
= ME_SelectStyleFont(c
, s
);
542 GetTextExtentPoint32W(c
->hDC
, szText
, nChars
, size
);
543 ME_UnselectStyleFont(c
, s
, hOldFont
);
550 /******************************************************************************
551 * ME_PointFromCharContext
553 * Returns a run-relative pixel position given a run-relative character
554 * position (character offset)
556 int ME_PointFromCharContext(ME_Context
*c
, ME_Run
*pRun
, int nOffset
, BOOL visual_order
)
559 ME_String
*mask_text
= NULL
;
562 if (pRun
->nFlags
& MERF_GRAPHICS
)
565 ME_GetOLEObjectSize(c
, pRun
, &size
);
567 } else if (pRun
->nFlags
& MERF_ENDPARA
) {
571 if (pRun
->para
->nFlags
& MEPF_COMPLEX
)
574 ScriptCPtoX( nOffset
, FALSE
, pRun
->len
, pRun
->num_glyphs
, pRun
->clusters
,
575 pRun
->vis_attrs
, pRun
->advances
, &pRun
->script_analysis
, &x
);
576 if (visual_order
&& pRun
->script_analysis
.fRTL
) x
= pRun
->nWidth
- x
- 1;
579 if (c
->editor
->cPasswordMask
)
581 mask_text
= ME_MakeStringR(c
->editor
->cPasswordMask
, pRun
->len
);
582 str
= mask_text
->szData
;
585 str
= get_text( pRun
, 0 );
587 ME_GetTextExtent(c
, str
, nOffset
, pRun
->style
, &size
);
588 ME_DestroyString( mask_text
);
592 /******************************************************************************
595 * Calls ME_PointFromCharContext after first creating a context.
597 int ME_PointFromChar(ME_TextEditor
*editor
, ME_Run
*pRun
, int nOffset
, BOOL visual_order
)
602 ME_InitContext(&c
, editor
, ITextHost_TxGetDC(editor
->texthost
));
603 ret
= ME_PointFromCharContext( &c
, pRun
, nOffset
, visual_order
);
604 ME_DestroyContext(&c
);
609 /******************************************************************************
610 * ME_GetRunSizeCommon
612 * Finds width, height, ascent and descent of a run, up to given character
615 SIZE
ME_GetRunSizeCommon(ME_Context
*c
, const ME_Paragraph
*para
, ME_Run
*run
, int nLen
,
616 int startx
, int *pAscent
, int *pDescent
)
619 WCHAR spaceW
[] = {' ',0};
621 nLen
= min( nLen
, run
->len
);
623 if (run
->nFlags
& MERF_ENDPARA
)
625 nLen
= min( nLen
, 1 );
626 ME_GetTextExtent(c
, spaceW
, nLen
, run
->style
, &size
);
628 else if (para
->nFlags
& MEPF_COMPLEX
)
630 size
.cx
= run
->nWidth
;
632 else if (c
->editor
->cPasswordMask
)
634 ME_String
*szMasked
= ME_MakeStringR(c
->editor
->cPasswordMask
,nLen
);
635 ME_GetTextExtent(c
, szMasked
->szData
, nLen
,run
->style
, &size
);
636 ME_DestroyString(szMasked
);
640 ME_GetTextExtent(c
, get_text( run
, 0 ), nLen
, run
->style
, &size
);
642 *pAscent
= run
->style
->tm
.tmAscent
;
643 *pDescent
= run
->style
->tm
.tmDescent
;
644 size
.cy
= *pAscent
+ *pDescent
;
646 if (run
->nFlags
& MERF_TAB
)
648 int pos
= 0, i
= 0, ppos
, shift
= 0;
649 const PARAFORMAT2
*pFmt
= ¶
->fmt
;
651 if (c
->editor
->bEmulateVersion10
&& /* v1.0 - 3.0 */
652 pFmt
->dwMask
& PFM_TABLE
&& pFmt
->wEffects
& PFE_TABLE
)
653 /* The horizontal gap shifts the tab positions to leave the gap. */
654 shift
= pFmt
->dxOffset
* 2;
656 if (i
< pFmt
->cTabCount
)
658 /* Only one side of the horizontal gap is needed at the end of
660 if (i
== pFmt
->cTabCount
-1)
662 pos
= shift
+ (pFmt
->rgxTabs
[i
]&0x00FFFFFF);
667 pos
+= lDefaultTab
- (pos
% lDefaultTab
);
669 ppos
= ME_twips2pointsX(c
, pos
);
670 if (ppos
> startx
+ run
->pt
.x
) {
671 size
.cx
= ppos
- startx
- run
->pt
.x
;
675 size
.cy
= *pAscent
+ *pDescent
;
678 if (run
->nFlags
& MERF_GRAPHICS
)
680 ME_GetOLEObjectSize(c
, run
, &size
);
681 if (size
.cy
> *pAscent
)
683 /* descent is unchanged */
689 /******************************************************************************
690 * ME_SetSelectionCharFormat
692 * Applies a style change, either to a current selection, or to insert cursor
693 * (ie. the style next typed characters will use).
695 void ME_SetSelectionCharFormat(ME_TextEditor
*editor
, CHARFORMAT2W
*pFmt
)
697 if (!ME_IsSelection(editor
))
700 if (!editor
->pBuffer
->pCharStyle
)
701 editor
->pBuffer
->pCharStyle
= ME_GetInsertStyle(editor
, 0);
702 s
= ME_ApplyStyle(editor
, editor
->pBuffer
->pCharStyle
, pFmt
);
703 ME_ReleaseStyle(editor
->pBuffer
->pCharStyle
);
704 editor
->pBuffer
->pCharStyle
= s
;
706 ME_Cursor
*from
, *to
;
707 ME_GetSelection(editor
, &from
, &to
);
708 ME_SetCharFormat(editor
, from
, to
, pFmt
);
712 /******************************************************************************
715 * Applies a style change to the specified part of the text
717 * The start and end cursors specify the part of the text. These cursors will
718 * be updated to stay valid, but this function may invalidate other
719 * non-selection cursors. The end cursor may be NULL to specify all the text
720 * following the start cursor.
722 * If no text is selected, then nothing is done.
724 void ME_SetCharFormat(ME_TextEditor
*editor
, ME_Cursor
*start
, ME_Cursor
*end
, CHARFORMAT2W
*pFmt
)
726 ME_DisplayItem
*run
, *start_run
= start
->pRun
, *end_run
= NULL
;
728 if (end
&& start
->pRun
== end
->pRun
&& start
->nOffset
== end
->nOffset
)
731 if (start
->nOffset
== start
->pRun
->member
.run
.len
)
732 start_run
= ME_FindItemFwd( start
->pRun
, diRun
);
733 else if (start
->nOffset
)
735 /* SplitRunSimple may or may not update the cursors, depending on whether they
736 * are selection cursors, but we need to make sure they are valid. */
737 int split_offset
= start
->nOffset
;
738 ME_DisplayItem
*split_run
= ME_SplitRunSimple(editor
, start
);
739 start_run
= start
->pRun
;
740 if (end
&& end
->pRun
== split_run
)
742 end
->pRun
= start
->pRun
;
743 end
->nOffset
-= split_offset
;
749 if (end
->nOffset
== end
->pRun
->member
.run
.len
)
750 end_run
= ME_FindItemFwd( end
->pRun
, diRun
);
753 if (end
->nOffset
) ME_SplitRunSimple(editor
, end
);
758 for (run
= start_run
; run
!= end_run
; run
= ME_FindItemFwd( run
, diRun
))
760 ME_Style
*new_style
= ME_ApplyStyle(editor
, run
->member
.run
.style
, pFmt
);
761 ME_Paragraph
*para
= run
->member
.run
.para
;
763 add_undo_set_char_fmt( editor
, run
->member
.run
.para
->nCharOfs
+ run
->member
.run
.nCharOfs
,
764 run
->member
.run
.len
, &run
->member
.run
.style
->fmt
);
765 ME_ReleaseStyle(run
->member
.run
.style
);
766 run
->member
.run
.style
= new_style
;
768 /* The para numbering style depends on the eop style */
769 if ((run
->member
.run
.nFlags
& MERF_ENDPARA
) && para
->para_num
.style
)
771 ME_ReleaseStyle(para
->para_num
.style
);
772 para
->para_num
.style
= NULL
;
774 para
->nFlags
|= MEPF_REWRAP
;
778 static void ME_GetRunCharFormat(ME_TextEditor
*editor
, ME_DisplayItem
*run
, CHARFORMAT2W
*pFmt
)
780 ME_CopyCharFormat(pFmt
, &run
->member
.run
.style
->fmt
);
783 /******************************************************************************
784 * ME_GetDefaultCharFormat
786 * Retrieves the current default character style (the one applied where no
787 * other style was applied) .
789 void ME_GetDefaultCharFormat(ME_TextEditor
*editor
, CHARFORMAT2W
*pFmt
)
791 ME_CopyCharFormat(pFmt
, &editor
->pBuffer
->pDefaultStyle
->fmt
);
794 /******************************************************************************
795 * ME_GetSelectionCharFormat
797 * If selection exists, it returns all style elements that are set consistently
798 * in the whole selection. If not, it just returns the current style.
800 void ME_GetSelectionCharFormat(ME_TextEditor
*editor
, CHARFORMAT2W
*pFmt
)
802 ME_Cursor
*from
, *to
;
803 if (!ME_IsSelection(editor
) && editor
->pBuffer
->pCharStyle
)
805 ME_CopyCharFormat(pFmt
, &editor
->pBuffer
->pCharStyle
->fmt
);
808 ME_GetSelection(editor
, &from
, &to
);
809 ME_GetCharFormat(editor
, from
, to
, pFmt
);
812 /******************************************************************************
815 * Returns the style consisting of those attributes which are consistently set
816 * in the whole character range.
818 void ME_GetCharFormat(ME_TextEditor
*editor
, const ME_Cursor
*from
,
819 const ME_Cursor
*to
, CHARFORMAT2W
*pFmt
)
821 ME_DisplayItem
*run
, *run_end
;
825 /* special case - if selection is empty, take previous char's formatting */
826 if (from
->pRun
== to
->pRun
&& from
->nOffset
== to
->nOffset
)
830 ME_DisplayItem
*tmp_run
= ME_FindItemBack(run
, diRunOrParagraph
);
831 if (tmp_run
->type
== diRun
) {
832 ME_GetRunCharFormat(editor
, tmp_run
, pFmt
);
836 ME_GetRunCharFormat(editor
, run
, pFmt
);
842 run_end
= ME_FindItemBack(run_end
, diRun
);
844 ME_GetRunCharFormat(editor
, run
, pFmt
);
846 if (run
== run_end
) return;
849 /* FIXME add more style feature comparisons */
850 DWORD dwAttribs
= CFM_SIZE
| CFM_FACE
| CFM_COLOR
| CFM_UNDERLINETYPE
;
851 DWORD dwEffects
= CFM_BOLD
| CFM_ITALIC
| CFM_UNDERLINE
| CFM_STRIKEOUT
| CFM_PROTECTED
| CFM_LINK
| CFM_SUPERSCRIPT
;
853 run
= ME_FindItemFwd(run
, diRun
);
855 ZeroMemory(&tmp
, sizeof(tmp
));
856 tmp
.cbSize
= sizeof(tmp
);
857 ME_GetRunCharFormat(editor
, run
, &tmp
);
859 assert((tmp
.dwMask
& dwAttribs
) == dwAttribs
);
860 /* reset flags that differ */
862 if (pFmt
->yHeight
!= tmp
.yHeight
)
863 pFmt
->dwMask
&= ~CFM_SIZE
;
864 if (pFmt
->dwMask
& CFM_FACE
)
866 if (!(tmp
.dwMask
& CFM_FACE
))
867 pFmt
->dwMask
&= ~CFM_FACE
;
868 else if (lstrcmpW(pFmt
->szFaceName
, tmp
.szFaceName
) ||
869 pFmt
->bPitchAndFamily
!= tmp
.bPitchAndFamily
)
870 pFmt
->dwMask
&= ~CFM_FACE
;
872 if (pFmt
->yHeight
!= tmp
.yHeight
)
873 pFmt
->dwMask
&= ~CFM_SIZE
;
874 if (pFmt
->bUnderlineType
!= tmp
.bUnderlineType
)
875 pFmt
->dwMask
&= ~CFM_UNDERLINETYPE
;
876 if (pFmt
->dwMask
& CFM_COLOR
)
878 if (!((pFmt
->dwEffects
&CFE_AUTOCOLOR
) & (tmp
.dwEffects
&CFE_AUTOCOLOR
)))
880 if (pFmt
->crTextColor
!= tmp
.crTextColor
)
881 pFmt
->dwMask
&= ~CFM_COLOR
;
885 pFmt
->dwMask
&= ~((pFmt
->dwEffects
^ tmp
.dwEffects
) & dwEffects
);
886 pFmt
->dwEffects
= tmp
.dwEffects
;
888 } while(run
!= run_end
);