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 1 if two runs can be safely merged into one, 0 otherwise.
35 int 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_w(p
->member
.run
.strText
->szData
), 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
.strText
->nLen
, debugstr_w(p
->member
.run
.strText
->szData
),
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
.strText
->nLen
);
131 ofs
+= p
->member
.run
.strText
->nLen
;
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
.strText
->nLen
;
233 ME_AppendString(p
->member
.run
.strText
, pNext
->member
.run
.strText
);
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 * Splits a run into two in a given place. It also updates the screen position
249 * and size (extent) of the newly generated runs.
251 ME_DisplayItem
*ME_SplitRun(ME_WrapContext
*wc
, ME_DisplayItem
*item
, int nVChar
)
253 ME_TextEditor
*editor
= wc
->context
->editor
;
254 ME_DisplayItem
*item2
= NULL
;
256 ME_Paragraph
*para
= &ME_GetParagraph(item
)->member
.para
;
258 assert(item
->member
.run
.nCharOfs
!= -1);
259 if(TRACE_ON(richedit
))
261 TRACE("Before check before split\n");
262 ME_CheckCharOffsets(editor
);
263 TRACE("After check before split\n");
266 run
= &item
->member
.run
;
268 TRACE("Before split: %s(%d, %d)\n", debugstr_w(run
->strText
->szData
),
269 run
->pt
.x
, run
->pt
.y
);
271 item2
= ME_SplitRunSimple(editor
, item
, nVChar
);
273 run2
= &item2
->member
.run
;
275 ME_CalcRunExtent(wc
->context
, para
, wc
->nRow
? wc
->nLeftMargin
: wc
->nFirstMargin
, run
);
276 ME_CalcRunExtent(wc
->context
, para
, wc
->nRow
? wc
->nLeftMargin
: wc
->nFirstMargin
, run2
);
278 run2
->pt
.x
= run
->pt
.x
+run
->nWidth
;
279 run2
->pt
.y
= run
->pt
.y
;
281 if(TRACE_ON(richedit
))
283 TRACE("Before check after split\n");
284 ME_CheckCharOffsets(editor
);
285 TRACE("After check after split\n");
286 TRACE("After split: %s(%d, %d), %s(%d, %d)\n",
287 debugstr_w(run
->strText
->szData
), run
->pt
.x
, run
->pt
.y
,
288 debugstr_w(run2
->strText
->szData
), run2
->pt
.x
, run2
->pt
.y
);
294 /******************************************************************************
297 * Does the most basic job of splitting a run into two - it does not
298 * update the positions and extents.
300 ME_DisplayItem
*ME_SplitRunSimple(ME_TextEditor
*editor
, ME_DisplayItem
*item
, int nVChar
)
302 ME_Run
*run
= &item
->member
.run
;
303 ME_DisplayItem
*item2
;
306 assert(nVChar
> 0 && nVChar
< run
->strText
->nLen
);
307 assert(item
->type
== diRun
);
308 assert(!(item
->member
.run
.nFlags
& MERF_NONTEXT
));
309 assert(item
->member
.run
.nCharOfs
!= -1);
311 item2
= ME_MakeRun(run
->style
,
312 ME_VSplitString(run
->strText
, nVChar
), run
->nFlags
&MERF_SPLITMASK
);
314 item2
->member
.run
.nCharOfs
= item
->member
.run
.nCharOfs
+ nVChar
;
316 run2
= &item2
->member
.run
;
317 ME_InsertBefore(item
->next
, item2
);
319 ME_UpdateRunFlags(editor
, run
);
320 ME_UpdateRunFlags(editor
, run2
);
321 for (i
=0; i
<editor
->nCursors
; i
++) {
322 if (editor
->pCursors
[i
].pRun
== item
&&
323 editor
->pCursors
[i
].nOffset
>= nVChar
) {
324 assert(item2
->type
== diRun
);
325 editor
->pCursors
[i
].pRun
= item2
;
326 editor
->pCursors
[i
].nOffset
-= nVChar
;
329 ME_GetParagraph(item
)->member
.para
.nFlags
|= MEPF_REWRAP
;
333 /******************************************************************************
336 * A helper function to create run structures quickly.
338 ME_DisplayItem
*ME_MakeRun(ME_Style
*s
, ME_String
*strData
, int nFlags
)
340 ME_DisplayItem
*item
= ME_MakeDI(diRun
);
341 item
->member
.run
.style
= s
;
342 item
->member
.run
.ole_obj
= NULL
;
343 item
->member
.run
.strText
= strData
;
344 item
->member
.run
.nFlags
= nFlags
;
345 item
->member
.run
.nCharOfs
= -1;
350 /******************************************************************************
353 * Inserts a run at a given character position (offset).
355 ME_DisplayItem
*ME_InsertRun(ME_TextEditor
*editor
, int nCharOfs
, ME_DisplayItem
*pItem
)
360 assert(pItem
->type
== diRun
|| pItem
->type
== diUndoInsertRun
);
362 ME_CursorFromCharOfs(editor
, nCharOfs
, &tmp
);
363 pDI
= ME_InsertRunAtCursor(editor
, &tmp
, pItem
->member
.run
.style
,
364 pItem
->member
.run
.strText
->szData
,
365 pItem
->member
.run
.strText
->nLen
,
366 pItem
->member
.run
.nFlags
);
371 /******************************************************************************
372 * ME_InsertRunAtCursor
374 * Inserts a new run with given style, flags and content at a given position,
375 * which is passed as a cursor structure (which consists of a run and
376 * a run-relative character offset).
379 ME_InsertRunAtCursor(ME_TextEditor
*editor
, ME_Cursor
*cursor
, ME_Style
*style
,
380 const WCHAR
*str
, int len
, int flags
)
385 if (cursor
->nOffset
) {
386 /* We're inserting at the middle of the existing run, which means that
387 * that run must be split. It isn't always necessary, but */
388 cursor
->pRun
= ME_SplitRunSimple(editor
, cursor
->pRun
, cursor
->nOffset
);
392 pUI
= ME_AddUndoItem(editor
, diUndoDeleteRun
, NULL
);
394 pUI
->nStart
= cursor
->pPara
->member
.para
.nCharOfs
395 + cursor
->pRun
->member
.run
.nCharOfs
;
399 pDI
= ME_MakeRun(style
, ME_MakeStringN(str
, len
), flags
);
400 pDI
->member
.run
.nCharOfs
= cursor
->pRun
->member
.run
.nCharOfs
;
401 ME_InsertBefore(cursor
->pRun
, pDI
);
402 TRACE("Shift length:%d\n", len
);
403 ME_PropagateCharOffset(cursor
->pRun
, len
);
404 cursor
->pPara
->member
.para
.nFlags
|= MEPF_REWRAP
;
408 /******************************************************************************
411 * Determine some of run attributes given its content (style, text content).
412 * Some flags cannot be determined by this function (MERF_GRAPHICS,
415 void ME_UpdateRunFlags(ME_TextEditor
*editor
, ME_Run
*run
)
417 ME_String
*strText
= run
->strText
;
418 assert(run
->nCharOfs
>= 0);
420 if (RUN_IS_HIDDEN(run
) || run
->nFlags
& MERF_TABLESTART
)
421 run
->nFlags
|= MERF_HIDDEN
;
423 run
->nFlags
&= ~MERF_HIDDEN
;
425 if (ME_IsSplitable(strText
))
426 run
->nFlags
|= MERF_SPLITTABLE
;
428 run
->nFlags
&= ~MERF_SPLITTABLE
;
430 if (!(run
->nFlags
& MERF_NOTEXT
)) {
431 if (ME_IsWhitespaces(strText
))
432 run
->nFlags
|= MERF_WHITESPACE
| MERF_STARTWHITE
| MERF_ENDWHITE
;
435 run
->nFlags
&= ~MERF_WHITESPACE
;
437 if (ME_IsWSpace(strText
->szData
[0]))
438 run
->nFlags
|= MERF_STARTWHITE
;
440 run
->nFlags
&= ~MERF_STARTWHITE
;
442 if (ME_IsWSpace(strText
->szData
[strText
->nLen
- 1]))
443 run
->nFlags
|= MERF_ENDWHITE
;
445 run
->nFlags
&= ~MERF_ENDWHITE
;
449 run
->nFlags
&= ~(MERF_WHITESPACE
| MERF_STARTWHITE
| MERF_ENDWHITE
);
452 /******************************************************************************
455 * Returns a character position inside the run given a run-relative
456 * pixel horizontal position. This version rounds left (ie. if the second
457 * character is at pixel position 8, then for cx=0..7 it returns 0).
459 int ME_CharFromPoint(ME_Context
*c
, int cx
, ME_Run
*run
)
464 if (!run
->strText
->nLen
)
467 if (run
->nFlags
& MERF_TAB
||
468 (run
->nFlags
& (MERF_ENDCELL
|MERF_ENDPARA
)) == MERF_ENDCELL
)
470 if (cx
< run
->nWidth
/2)
474 if (run
->nFlags
& MERF_GRAPHICS
)
477 ME_GetOLEObjectSize(c
, run
, &sz
);
482 hOldFont
= ME_SelectStyleFont(c
, run
->style
);
484 if (c
->editor
->cPasswordMask
)
486 ME_String
*strMasked
= ME_MakeStringR(c
->editor
->cPasswordMask
, run
->strText
->nLen
);
487 GetTextExtentExPointW(c
->hDC
, strMasked
->szData
, run
->strText
->nLen
,
488 cx
, &fit
, NULL
, &sz
);
489 ME_DestroyString(strMasked
);
493 GetTextExtentExPointW(c
->hDC
, run
->strText
->szData
, run
->strText
->nLen
,
494 cx
, &fit
, NULL
, &sz
);
497 ME_UnselectStyleFont(c
, run
->style
, hOldFont
);
502 /******************************************************************************
503 * ME_CharFromPointCursor
505 * Returns a character position inside the run given a run-relative
506 * pixel horizontal position. This version rounds to the nearest character edge
507 * (ie. if the second character is at pixel position 8, then for cx=0..3
508 * it returns 0, and for cx=4..7 it returns 1).
510 * It is used for mouse click handling, for better usability (and compatibility
511 * with the native control).
513 int ME_CharFromPointCursor(ME_TextEditor
*editor
, int cx
, ME_Run
*run
)
515 ME_String
*strRunText
;
516 /* This could point to either the run's real text, or it's masked form in a password control */
522 if (!run
->strText
->nLen
)
525 if (run
->nFlags
& (MERF_TAB
| MERF_ENDCELL
))
527 if (cx
< run
->nWidth
/2)
531 ME_InitContext(&c
, editor
, ITextHost_TxGetDC(editor
->texthost
));
532 if (run
->nFlags
& MERF_GRAPHICS
)
535 ME_GetOLEObjectSize(&c
, run
, &sz
);
536 ME_DestroyContext(&c
);
542 if (editor
->cPasswordMask
)
543 strRunText
= ME_MakeStringR(editor
->cPasswordMask
, run
->strText
->nLen
);
545 strRunText
= run
->strText
;
547 hOldFont
= ME_SelectStyleFont(&c
, run
->style
);
548 GetTextExtentExPointW(c
.hDC
, strRunText
->szData
, strRunText
->nLen
,
549 cx
, &fit
, NULL
, &sz
);
550 if (fit
!= strRunText
->nLen
)
552 GetTextExtentPoint32W(c
.hDC
, strRunText
->szData
, fit
, &sz2
);
553 GetTextExtentPoint32W(c
.hDC
, strRunText
->szData
, fit
+ 1, &sz3
);
554 if (cx
>= (sz2
.cx
+sz3
.cx
)/2)
558 if (editor
->cPasswordMask
)
559 ME_DestroyString(strRunText
);
561 ME_UnselectStyleFont(&c
, run
->style
, hOldFont
);
562 ME_DestroyContext(&c
);
566 /******************************************************************************
569 * Finds a width and a height of the text using a specified style
571 static void ME_GetTextExtent(ME_Context
*c
, LPCWSTR szText
, int nChars
, ME_Style
*s
, SIZE
*size
)
574 hOldFont
= ME_SelectStyleFont(c
, s
);
575 GetTextExtentPoint32W(c
->hDC
, szText
, nChars
, size
);
576 ME_UnselectStyleFont(c
, s
, hOldFont
);
579 /******************************************************************************
582 * Returns a run-relative pixel position given a run-relative character
583 * position (character offset)
585 int ME_PointFromChar(ME_TextEditor
*editor
, ME_Run
*pRun
, int nOffset
)
589 ME_String
*strRunText
;
590 /* This could point to either the run's real text, or it's masked form in a password control */
592 ME_InitContext(&c
, editor
, ITextHost_TxGetDC(editor
->texthost
));
593 if (pRun
->nFlags
& MERF_GRAPHICS
)
596 ME_GetOLEObjectSize(&c
, pRun
, &size
);
597 ME_DestroyContext(&c
);
599 } else if (pRun
->nFlags
& MERF_ENDPARA
) {
603 if (editor
->cPasswordMask
)
604 strRunText
= ME_MakeStringR(editor
->cPasswordMask
, pRun
->strText
->nLen
);
606 strRunText
= pRun
->strText
;
608 ME_GetTextExtent(&c
, strRunText
->szData
, nOffset
, pRun
->style
, &size
);
609 ME_DestroyContext(&c
);
610 if (editor
->cPasswordMask
)
611 ME_DestroyString(strRunText
);
615 /******************************************************************************
616 * ME_GetRunSizeCommon
618 * Finds width, height, ascent and descent of a run, up to given character
621 static SIZE
ME_GetRunSizeCommon(ME_Context
*c
, const ME_Paragraph
*para
, ME_Run
*run
, int nLen
,
622 int startx
, int *pAscent
, int *pDescent
)
625 int nMaxLen
= run
->strText
->nLen
;
630 /* FIXME the following call also ensures that TEXTMETRIC structure is filled
631 * this is wasteful for MERF_NONTEXT runs, but that shouldn't matter
635 if (c
->editor
->cPasswordMask
)
637 ME_String
*szMasked
= ME_MakeStringR(c
->editor
->cPasswordMask
,nLen
);
638 ME_GetTextExtent(c
, szMasked
->szData
, nLen
,run
->style
, &size
);
639 ME_DestroyString(szMasked
);
643 ME_GetTextExtent(c
, run
->strText
->szData
, nLen
, run
->style
, &size
);
645 *pAscent
= run
->style
->tm
.tmAscent
;
646 *pDescent
= run
->style
->tm
.tmDescent
;
647 size
.cy
= *pAscent
+ *pDescent
;
649 if (run
->nFlags
& MERF_TAB
)
651 int pos
= 0, i
= 0, ppos
, shift
= 0;
652 PARAFORMAT2
*pFmt
= para
->pFmt
;
654 if (c
->editor
->bEmulateVersion10
&& /* v1.0 - 3.0 */
655 pFmt
->dwMask
& PFM_TABLE
&& pFmt
->wEffects
& PFE_TABLE
)
656 /* The horizontal gap shifts the tab positions to leave the gap. */
657 shift
= pFmt
->dxOffset
* 2;
659 if (i
< pFmt
->cTabCount
)
661 /* Only one side of the horizontal gap is needed at the end of
663 if (i
== pFmt
->cTabCount
-1)
665 pos
= shift
+ (pFmt
->rgxTabs
[i
]&0x00FFFFFF);
670 pos
+= lDefaultTab
- (pos
% lDefaultTab
);
672 ppos
= ME_twips2pointsX(c
, pos
);
673 if (ppos
> startx
+ run
->pt
.x
) {
674 size
.cx
= ppos
- startx
- run
->pt
.x
;
678 size
.cy
= *pAscent
+ *pDescent
;
681 if (run
->nFlags
& MERF_GRAPHICS
)
683 ME_GetOLEObjectSize(c
, run
, &size
);
684 if (size
.cy
> *pAscent
)
686 /* descent is unchanged */
692 /******************************************************************************
695 * Finds width and height (but not ascent and descent) of a part of the run
696 * up to given character.
698 SIZE
ME_GetRunSize(ME_Context
*c
, const ME_Paragraph
*para
,
699 ME_Run
*run
, int nLen
, int startx
)
702 return ME_GetRunSizeCommon(c
, para
, run
, nLen
, startx
, &asc
, &desc
);
705 /******************************************************************************
708 * Updates the size of the run (fills width, ascent and descent). The height
709 * is calculated based on whole row's ascent and descent anyway, so no need
712 void ME_CalcRunExtent(ME_Context
*c
, const ME_Paragraph
*para
, int startx
, ME_Run
*run
)
714 if (run
->nFlags
& MERF_HIDDEN
)
718 int nEnd
= run
->strText
->nLen
;
719 SIZE size
= ME_GetRunSizeCommon(c
, para
, run
, nEnd
, startx
,
720 &run
->nAscent
, &run
->nDescent
);
721 run
->nWidth
= size
.cx
;
723 WARN("size.cx == 0\n");
727 /******************************************************************************
730 * This should ensure that the given paragraph is wrapped so that its screen
731 * row structure may be used. But it doesn't, yet.
733 void ME_MustBeWrapped(ME_Context
*c
, ME_DisplayItem
*para
)
735 assert(para
->type
== diParagraph
);
739 /******************************************************************************
740 * ME_SetSelectionCharFormat
742 * Applies a style change, either to a current selection, or to insert cursor
743 * (ie. the style next typed characters will use).
745 void ME_SetSelectionCharFormat(ME_TextEditor
*editor
, CHARFORMAT2W
*pFmt
)
748 ME_GetSelection(editor
, &nFrom
, &nTo
);
752 if (!editor
->pBuffer
->pCharStyle
)
753 editor
->pBuffer
->pCharStyle
= ME_GetInsertStyle(editor
, 0);
754 s
= ME_ApplyStyle(editor
->pBuffer
->pCharStyle
, pFmt
);
755 ME_ReleaseStyle(editor
->pBuffer
->pCharStyle
);
756 editor
->pBuffer
->pCharStyle
= s
;
759 ME_SetCharFormat(editor
, nFrom
, nTo
-nFrom
, pFmt
);
762 /******************************************************************************
765 * Applies a style change to the specified part of the text
767 void ME_SetCharFormat(ME_TextEditor
*editor
, int nOfs
, int nChars
, CHARFORMAT2W
*pFmt
)
770 ME_DisplayItem
*para
;
772 ME_CursorFromCharOfs(editor
, nOfs
, &tmp
);
774 tmp
.pRun
= ME_SplitRunSimple(editor
, tmp
.pRun
, tmp
.nOffset
);
776 ME_CursorFromCharOfs(editor
, nOfs
+nChars
, &tmp2
);
778 tmp2
.pRun
= ME_SplitRunSimple(editor
, tmp2
.pRun
, tmp2
.nOffset
);
781 para
->member
.para
.nFlags
|= MEPF_REWRAP
;
783 while(tmp
.pRun
!= tmp2
.pRun
)
785 ME_UndoItem
*undo
= NULL
;
786 ME_Style
*new_style
= ME_ApplyStyle(tmp
.pRun
->member
.run
.style
, pFmt
);
787 /* ME_DumpStyle(new_style); */
788 undo
= ME_AddUndoItem(editor
, diUndoSetCharFormat
, NULL
);
790 undo
->nStart
= tmp
.pRun
->member
.run
.nCharOfs
+para
->member
.para
.nCharOfs
;
791 undo
->nLen
= tmp
.pRun
->member
.run
.strText
->nLen
;
792 undo
->di
.member
.ustyle
= tmp
.pRun
->member
.run
.style
;
793 /* we'd have to addref undo...ustyle and release tmp...style
794 but they'd cancel each other out so we can do nothing instead */
797 ME_ReleaseStyle(tmp
.pRun
->member
.run
.style
);
798 tmp
.pRun
->member
.run
.style
= new_style
;
799 tmp
.pRun
= ME_FindItemFwd(tmp
.pRun
, diRunOrParagraph
);
800 if (tmp
.pRun
->type
== diParagraph
)
803 tmp
.pRun
= ME_FindItemFwd(tmp
.pRun
, diRun
);
804 if (tmp
.pRun
!= tmp2
.pRun
)
805 para
->member
.para
.nFlags
|= MEPF_REWRAP
;
811 /******************************************************************************
812 * ME_SetDefaultCharFormat
814 * Applies a style change to the default character style.
816 void ME_SetDefaultCharFormat(ME_TextEditor
*editor
, CHARFORMAT2W
*mod
)
820 assert(mod
->cbSize
== sizeof(CHARFORMAT2W
));
821 style
= ME_ApplyStyle(editor
->pBuffer
->pDefaultStyle
, mod
);
822 editor
->pBuffer
->pDefaultStyle
->fmt
= style
->fmt
;
823 editor
->pBuffer
->pDefaultStyle
->tm
= style
->tm
;
824 ME_ReleaseStyle(style
);
825 ME_MarkAllForWrapping(editor
);
826 /* pcf = editor->pBuffer->pDefaultStyle->fmt; */
829 static void ME_GetRunCharFormat(ME_TextEditor
*editor
, ME_DisplayItem
*run
, CHARFORMAT2W
*pFmt
)
831 ME_CopyCharFormat(pFmt
, &run
->member
.run
.style
->fmt
);
832 if ((pFmt
->dwMask
& CFM_UNDERLINETYPE
) && (pFmt
->bUnderlineType
== CFU_CF1UNDERLINE
))
834 pFmt
->dwMask
|= CFM_UNDERLINE
;
835 pFmt
->dwEffects
|= CFE_UNDERLINE
;
837 if ((pFmt
->dwMask
& CFM_UNDERLINETYPE
) && (pFmt
->bUnderlineType
== CFU_UNDERLINENONE
))
839 pFmt
->dwMask
|= CFM_UNDERLINE
;
840 pFmt
->dwEffects
&= ~CFE_UNDERLINE
;
844 /******************************************************************************
845 * ME_GetDefaultCharFormat
847 * Retrieves the current default character style (the one applied where no
848 * other style was applied) .
850 void ME_GetDefaultCharFormat(ME_TextEditor
*editor
, CHARFORMAT2W
*pFmt
)
852 ME_CopyCharFormat(pFmt
, &editor
->pBuffer
->pDefaultStyle
->fmt
);
855 /******************************************************************************
856 * ME_GetSelectionCharFormat
858 * If selection exists, it returns all style elements that are set consistently
859 * in the whole selection. If not, it just returns the current style.
861 void ME_GetSelectionCharFormat(ME_TextEditor
*editor
, CHARFORMAT2W
*pFmt
)
864 ME_GetSelection(editor
, &nFrom
, &nTo
);
865 if (nFrom
== nTo
&& editor
->pBuffer
->pCharStyle
)
867 ME_CopyCharFormat(pFmt
, &editor
->pBuffer
->pCharStyle
->fmt
);
870 ME_GetCharFormat(editor
, nFrom
, nTo
, pFmt
);
873 /******************************************************************************
876 * Returns the style consisting of those attributes which are consistently set
877 * in the whole character range.
879 void ME_GetCharFormat(ME_TextEditor
*editor
, int nFrom
, int nTo
, CHARFORMAT2W
*pFmt
)
881 ME_DisplayItem
*run
, *run_end
;
882 int nOffset
, nOffset2
;
885 ME_RunOfsFromCharOfs(editor
, nFrom
, NULL
, &run
, &nOffset
);
886 if (nFrom
== nTo
) /* special case - if selection is empty, take previous char's formatting */
890 ME_DisplayItem
*tmp_run
= ME_FindItemBack(run
, diRunOrParagraph
);
891 if (tmp_run
->type
== diRun
) {
892 ME_GetRunCharFormat(editor
, tmp_run
, pFmt
);
896 ME_GetRunCharFormat(editor
, run
, pFmt
);
900 if (nTo
>nFrom
) /* selection consists of chars from nFrom up to nTo-1 */
902 ME_RunOfsFromCharOfs(editor
, nTo
, NULL
, &run_end
, &nOffset2
);
904 ME_GetRunCharFormat(editor
, run
, pFmt
);
906 if (run
== run_end
) return;
909 /* FIXME add more style feature comparisons */
910 int nAttribs
= CFM_SIZE
| CFM_FACE
| CFM_COLOR
| CFM_UNDERLINETYPE
;
911 int nEffects
= CFM_BOLD
| CFM_ITALIC
| CFM_UNDERLINE
| CFM_STRIKEOUT
| CFM_PROTECTED
| CFM_LINK
| CFM_SUPERSCRIPT
;
913 run
= ME_FindItemFwd(run
, diRun
);
915 ZeroMemory(&tmp
, sizeof(tmp
));
916 tmp
.cbSize
= sizeof(tmp
);
917 ME_GetRunCharFormat(editor
, run
, &tmp
);
919 assert((tmp
.dwMask
& nAttribs
) == nAttribs
);
920 /* reset flags that differ */
922 if (pFmt
->yHeight
!= tmp
.yHeight
)
923 pFmt
->dwMask
&= ~CFM_SIZE
;
924 if (pFmt
->dwMask
& CFM_FACE
)
926 if (!(tmp
.dwMask
& CFM_FACE
))
927 pFmt
->dwMask
&= ~CFM_FACE
;
928 else if (lstrcmpW(pFmt
->szFaceName
, tmp
.szFaceName
) ||
929 pFmt
->bPitchAndFamily
!= tmp
.bPitchAndFamily
)
930 pFmt
->dwMask
&= ~CFM_FACE
;
932 if (pFmt
->yHeight
!= tmp
.yHeight
)
933 pFmt
->dwMask
&= ~CFM_SIZE
;
934 if (pFmt
->bUnderlineType
!= tmp
.bUnderlineType
)
935 pFmt
->dwMask
&= ~CFM_UNDERLINETYPE
;
936 if (pFmt
->dwMask
& CFM_COLOR
)
938 if (!((pFmt
->dwEffects
&CFE_AUTOCOLOR
) & (tmp
.dwEffects
&CFE_AUTOCOLOR
)))
940 if (pFmt
->crTextColor
!= tmp
.crTextColor
)
941 pFmt
->dwMask
&= ~CFM_COLOR
;
945 pFmt
->dwMask
&= ~((pFmt
->dwEffects
^ tmp
.dwEffects
) & nEffects
);
946 pFmt
->dwEffects
= tmp
.dwEffects
;
948 } while(run
!= run_end
);