2 * RichEdit - Paragraph wrapping. Don't try to understand it. You've been
5 * Copyright 2004 by Krzysztof Foltman
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
25 WINE_DEFAULT_DEBUG_CHANNEL(richedit
);
30 * - center and right align in WordPad omits all spaces at the start, we don't
31 * - objects/images are not handled yet
35 /******************************************************************************
38 * Updates the size of the run (fills width, ascent and descent). The height
39 * is calculated based on whole row's ascent and descent anyway, so no need
42 static void calc_run_extent(ME_Context
*c
, const ME_Paragraph
*para
, int startx
, ME_Run
*run
)
44 if (run
->nFlags
& MERF_HIDDEN
) run
->nWidth
= 0;
47 SIZE size
= ME_GetRunSizeCommon( c
, para
, run
, run
->len
, startx
, &run
->nAscent
, &run
->nDescent
);
48 run
->nWidth
= size
.cx
;
52 /******************************************************************************
55 * Splits a run into two in a given place. It also updates the screen position
56 * and size (extent) of the newly generated runs.
58 static ME_DisplayItem
*split_run_extents(ME_WrapContext
*wc
, ME_DisplayItem
*item
, int nVChar
)
60 ME_TextEditor
*editor
= wc
->context
->editor
;
62 ME_Paragraph
*para
= &wc
->pPara
->member
.para
;
63 ME_Cursor cursor
= {wc
->pPara
, item
, nVChar
};
65 assert(item
->member
.run
.nCharOfs
!= -1);
66 if(TRACE_ON(richedit
))
68 TRACE("Before check before split\n");
69 ME_CheckCharOffsets(editor
);
70 TRACE("After check before split\n");
73 run
= &item
->member
.run
;
75 TRACE("Before split: %s(%d, %d)\n", debugstr_run( run
),
76 run
->pt
.x
, run
->pt
.y
);
78 ME_SplitRunSimple(editor
, &cursor
);
80 run2
= &cursor
.pRun
->member
.run
;
82 calc_run_extent(wc
->context
, para
, wc
->nRow
? wc
->nLeftMargin
: wc
->nFirstMargin
, run
);
84 run2
->pt
.x
= run
->pt
.x
+run
->nWidth
;
85 run2
->pt
.y
= run
->pt
.y
;
87 if(TRACE_ON(richedit
))
89 TRACE("Before check after split\n");
90 ME_CheckCharOffsets(editor
);
91 TRACE("After check after split\n");
92 TRACE("After split: %s(%d, %d), %s(%d, %d)\n",
93 debugstr_run( run
), run
->pt
.x
, run
->pt
.y
,
94 debugstr_run( run2
), run2
->pt
.x
, run2
->pt
.y
);
100 /******************************************************************************
103 * Returns a character position to split inside the run given a run-relative
104 * pixel horizontal position. This version rounds left (ie. if the second
105 * character is at pixel position 8, then for cx=0..7 it returns 0).
107 static int find_split_point( ME_Context
*c
, int cx
, ME_Run
*run
)
109 if (!run
->len
|| cx
<= 0) return 0;
110 return ME_CharFromPointContext( c
, cx
, run
, FALSE
, FALSE
);
113 static ME_DisplayItem
*ME_MakeRow(int height
, int baseline
, int width
)
115 ME_DisplayItem
*item
= ME_MakeDI(diStartRow
);
117 item
->member
.row
.nHeight
= height
;
118 item
->member
.row
.nBaseline
= baseline
;
119 item
->member
.row
.nWidth
= width
;
123 static void ME_BeginRow(ME_WrapContext
*wc
)
126 ME_DisplayItem
*para
= wc
->pPara
;
128 pFmt
= para
->member
.para
.pFmt
;
129 wc
->pRowStart
= NULL
;
130 wc
->bOverflown
= FALSE
;
131 wc
->pLastSplittableRun
= NULL
;
132 wc
->bWordWrap
= wc
->context
->editor
->bWordWrap
;
133 if (para
->member
.para
.nFlags
& (MEPF_ROWSTART
|MEPF_ROWEND
)) {
135 wc
->bWordWrap
= FALSE
;
136 if (para
->member
.para
.nFlags
& MEPF_ROWEND
)
138 ME_Cell
*cell
= &ME_FindItemBack(para
, diCell
)->member
.cell
;
141 } else if (para
->member
.para
.pCell
) {
142 ME_Cell
*cell
= ¶
->member
.para
.pCell
->member
.cell
;
145 width
= cell
->nRightBoundary
;
147 width
-= cell
->prev_cell
->member
.cell
.nRightBoundary
;
148 if (!cell
->prev_cell
)
150 int rowIndent
= ME_GetTableRowEnd(para
)->member
.para
.pFmt
->dxStartIndent
;
153 cell
->nWidth
= max(ME_twips2pointsX(wc
->context
, width
), 0);
155 wc
->nAvailWidth
= cell
->nWidth
156 - (wc
->nRow
? wc
->nLeftMargin
: wc
->nFirstMargin
) - wc
->nRightMargin
;
157 wc
->bWordWrap
= TRUE
;
159 wc
->nAvailWidth
= wc
->context
->nAvailWidth
160 - (wc
->nRow
? wc
->nLeftMargin
: wc
->nFirstMargin
) - wc
->nRightMargin
;
162 wc
->pt
.x
= wc
->context
->pt
.x
;
163 if (wc
->context
->editor
->bEmulateVersion10
&& /* v1.0 - 3.0 */
164 pFmt
->dwMask
& PFM_TABLE
&& pFmt
->wEffects
& PFE_TABLE
)
165 /* Shift the text down because of the border. */
169 static void ME_InsertRowStart(ME_WrapContext
*wc
, const ME_DisplayItem
*pEnd
)
171 ME_DisplayItem
*p
, *row
, *para
;
172 BOOL bSkippingSpaces
= TRUE
;
173 int ascent
= 0, descent
= 0, width
=0, shift
= 0, align
= 0;
177 pFmt
= para
->member
.para
.pFmt
;
179 for (p
= pEnd
->prev
; p
!=wc
->pRowStart
->prev
; p
= p
->prev
)
181 /* ENDPARA run shouldn't affect row height, except if it's the only run in the paragraph */
182 if (p
->type
==diRun
&& ((p
==wc
->pRowStart
) || !(p
->member
.run
.nFlags
& MERF_ENDPARA
))) { /* FIXME add more run types */
183 if (p
->member
.run
.nAscent
>ascent
)
184 ascent
= p
->member
.run
.nAscent
;
185 if (p
->member
.run
.nDescent
>descent
)
186 descent
= p
->member
.run
.nDescent
;
189 /* Exclude space characters from run width.
190 * Other whitespace or delimiters are not treated this way. */
191 int len
= p
->member
.run
.len
;
192 WCHAR
*text
= get_text( &p
->member
.run
, len
- 1 );
195 if (~p
->member
.run
.nFlags
& MERF_GRAPHICS
)
196 while (len
&& *(text
--) == ' ')
200 if (len
== p
->member
.run
.len
)
201 width
+= p
->member
.run
.nWidth
;
203 width
+= ME_PointFromCharContext( wc
->context
, &p
->member
.run
, len
, FALSE
);
205 bSkippingSpaces
= !len
;
206 } else if (!(p
->member
.run
.nFlags
& MERF_ENDPARA
))
207 width
+= p
->member
.run
.nWidth
;
211 para
->member
.para
.nWidth
= max(para
->member
.para
.nWidth
, width
);
212 row
= ME_MakeRow(ascent
+descent
, ascent
, width
);
213 if (wc
->context
->editor
->bEmulateVersion10
&& /* v1.0 - 3.0 */
214 pFmt
->dwMask
& PFM_TABLE
&& pFmt
->wEffects
& PFE_TABLE
)
216 /* The text was shifted down in ME_BeginRow so move the wrap context
217 * back to where it should be. */
219 /* The height of the row is increased by the borders. */
220 row
->member
.row
.nHeight
+= 2;
222 row
->member
.row
.pt
= wc
->pt
;
223 row
->member
.row
.nLMargin
= (!wc
->nRow
? wc
->nFirstMargin
: wc
->nLeftMargin
);
224 row
->member
.row
.nRMargin
= wc
->nRightMargin
;
225 assert(para
->member
.para
.pFmt
->dwMask
& PFM_ALIGNMENT
);
226 align
= para
->member
.para
.pFmt
->wAlignment
;
227 if (align
== PFA_CENTER
)
228 shift
= max((wc
->nAvailWidth
-width
)/2, 0);
229 if (align
== PFA_RIGHT
)
230 shift
= max(wc
->nAvailWidth
-width
, 0);
231 row
->member
.row
.pt
.x
= row
->member
.row
.nLMargin
+ shift
;
232 for (p
= wc
->pRowStart
; p
!=pEnd
; p
= p
->next
)
234 if (p
->type
==diRun
) { /* FIXME add more run types */
235 p
->member
.run
.pt
.x
+= row
->member
.row
.nLMargin
+shift
;
238 ME_InsertBefore(wc
->pRowStart
, row
);
240 wc
->pt
.y
+= row
->member
.row
.nHeight
;
244 static void ME_WrapEndParagraph(ME_WrapContext
*wc
, ME_DisplayItem
*p
)
246 ME_DisplayItem
*para
= wc
->pPara
;
247 PARAFORMAT2
*pFmt
= para
->member
.para
.pFmt
;
249 ME_InsertRowStart(wc
, p
);
250 if (wc
->context
->editor
->bEmulateVersion10
&& /* v1.0 - 3.0 */
251 pFmt
->dwMask
& PFM_TABLE
&& pFmt
->wEffects
& PFE_TABLE
)
253 /* ME_BeginRow was called an extra time for the paragraph, and it shifts the
254 * text down by one pixel for the border, so fix up the wrap context. */
261 if (p->type == diParagraph || p->type == diTextEnd)
263 if (p->type == diRun)
265 ME_Run *run = &p->member.run;
266 TRACE("%s - (%d, %d)\n", debugstr_run(run), run->pt.x, run->pt.y);
273 static void ME_WrapSizeRun(ME_WrapContext
*wc
, ME_DisplayItem
*p
)
275 /* FIXME compose style (out of character and paragraph styles) here */
277 ME_UpdateRunFlags(wc
->context
->editor
, &p
->member
.run
);
279 calc_run_extent(wc
->context
, &wc
->pPara
->member
.para
,
280 wc
->nRow
? wc
->nLeftMargin
: wc
->nFirstMargin
, &p
->member
.run
);
284 static int find_non_whitespace(const WCHAR
*s
, int len
, int start
)
287 for (i
= start
; i
< len
&& ME_IsWSpace( s
[i
] ); i
++)
293 /* note: these two really return the first matching offset (starting from EOS)+1
294 * in other words, an offset of the first trailing white/black */
296 /* note: returns offset of the first trailing whitespace */
297 static int reverse_find_non_whitespace(const WCHAR
*s
, int start
)
300 for (i
= start
; i
> 0 && ME_IsWSpace( s
[i
- 1] ); i
--)
306 /* note: returns offset of the first trailing nonwhitespace */
307 static int reverse_find_whitespace(const WCHAR
*s
, int start
)
310 for (i
= start
; i
> 0 && !ME_IsWSpace( s
[i
- 1] ); i
--)
316 static ME_DisplayItem
*ME_MaximizeSplit(ME_WrapContext
*wc
, ME_DisplayItem
*p
, int i
)
318 ME_DisplayItem
*pp
, *piter
= p
;
322 j
= reverse_find_non_whitespace( get_text( &p
->member
.run
, 0 ), i
);
324 pp
= split_run_extents(wc
, piter
, j
);
325 wc
->pt
.x
+= piter
->member
.run
.nWidth
;
331 /* omit all spaces before split point */
332 while(piter
!= wc
->pRowStart
)
334 piter
= ME_FindItemBack(piter
, diRun
);
335 if (piter
->member
.run
.nFlags
& MERF_WHITESPACE
)
340 if (piter
->member
.run
.nFlags
& MERF_ENDWHITE
)
342 i
= reverse_find_non_whitespace( get_text( &piter
->member
.run
, 0 ),
343 piter
->member
.run
.len
);
344 pp
= split_run_extents(wc
, piter
, i
);
345 wc
->pt
= pp
->member
.run
.pt
;
348 /* this run is the end of spaces, so the run edge is a good point to split */
349 wc
->pt
= pp
->member
.run
.pt
;
350 wc
->bOverflown
= TRUE
;
351 TRACE("Split point is: %s|%s\n", debugstr_run( &piter
->member
.run
), debugstr_run( &pp
->member
.run
));
354 wc
->pt
= piter
->member
.run
.pt
;
359 static ME_DisplayItem
*ME_SplitByBacktracking(ME_WrapContext
*wc
, ME_DisplayItem
*p
, int loc
)
361 ME_DisplayItem
*piter
= p
, *pp
;
363 ME_Run
*run
= &p
->member
.run
;
365 idesp
= i
= find_split_point( wc
->context
, loc
, run
);
370 /* don't split words */
371 i
= reverse_find_whitespace( get_text( run
, 0 ), i
);
372 pp
= ME_MaximizeSplit(wc
, p
, i
);
376 TRACE("Must backtrack to split at: %s\n", debugstr_run( &p
->member
.run
));
377 if (wc
->pLastSplittableRun
)
379 if (wc
->pLastSplittableRun
->member
.run
.nFlags
& (MERF_GRAPHICS
|MERF_TAB
))
381 wc
->pt
= wc
->pLastSplittableRun
->member
.run
.pt
;
382 return wc
->pLastSplittableRun
;
384 else if (wc
->pLastSplittableRun
->member
.run
.nFlags
& MERF_SPLITTABLE
)
386 /* the following two lines are just to check if we forgot to call UpdateRunFlags earlier,
387 they serve no other purpose */
388 ME_UpdateRunFlags(wc
->context
->editor
, run
);
389 assert((wc
->pLastSplittableRun
->member
.run
.nFlags
& MERF_SPLITTABLE
));
391 piter
= wc
->pLastSplittableRun
;
392 run
= &piter
->member
.run
;
394 /* don't split words */
395 i
= reverse_find_whitespace( get_text( run
, 0 ), len
);
397 i
= reverse_find_non_whitespace( get_text( run
, 0 ), len
);
399 ME_DisplayItem
*piter2
= split_run_extents(wc
, piter
, i
);
400 wc
->pt
= piter2
->member
.run
.pt
;
403 /* splittable = must have whitespaces */
404 assert(0 == "Splittable, but no whitespaces");
408 /* restart from the first run beginning with spaces */
409 wc
->pt
= wc
->pLastSplittableRun
->member
.run
.pt
;
410 return wc
->pLastSplittableRun
;
413 TRACE("Backtracking failed, trying desperate: %s\n", debugstr_run( &p
->member
.run
));
414 /* OK, no better idea, so assume we MAY split words if we can split at all*/
416 return split_run_extents(wc
, piter
, idesp
);
418 if (wc
->pRowStart
&& piter
!= wc
->pRowStart
)
420 /* don't need to break current run, because it's possible to split
422 wc
->bOverflown
= TRUE
;
427 /* split point inside first character - no choice but split after that char */
429 /* the run is more than 1 char, so we may split */
430 return split_run_extents(wc
, piter
, 1);
432 /* the run is one char, can't split it */
437 static ME_DisplayItem
*ME_WrapHandleRun(ME_WrapContext
*wc
, ME_DisplayItem
*p
)
443 assert(p
->type
== diRun
);
446 run
= &p
->member
.run
;
447 run
->pt
.x
= wc
->pt
.x
;
448 run
->pt
.y
= wc
->pt
.y
;
449 ME_WrapSizeRun(wc
, p
);
452 if (wc
->bOverflown
) /* just skipping final whitespaces */
454 /* End paragraph run can't overflow to the next line by itself. */
455 if (run
->nFlags
& MERF_ENDPARA
)
458 if (run
->nFlags
& MERF_WHITESPACE
) {
459 wc
->pt
.x
+= run
->nWidth
;
460 /* skip runs consisting of only whitespaces */
464 if (run
->nFlags
& MERF_STARTWHITE
) {
465 /* try to split the run at the first non-white char */
467 black
= find_non_whitespace( get_text( run
, 0 ), run
->len
, 0 );
469 wc
->bOverflown
= FALSE
;
470 pp
= split_run_extents(wc
, p
, black
);
471 calc_run_extent(wc
->context
, &wc
->pPara
->member
.para
,
472 wc
->nRow
? wc
->nLeftMargin
: wc
->nFirstMargin
,
474 ME_InsertRowStart(wc
, pp
);
478 /* black run: the row goes from pRowStart to the previous run */
479 ME_InsertRowStart(wc
, p
);
482 /* simply end the current row and move on to next one */
483 if (run
->nFlags
& MERF_ENDROW
)
486 ME_InsertRowStart(wc
, p
);
490 /* will current run fit? */
492 wc
->pt
.x
+ run
->nWidth
- wc
->context
->pt
.x
> wc
->nAvailWidth
)
494 int loc
= wc
->context
->pt
.x
+ wc
->nAvailWidth
- wc
->pt
.x
;
495 /* total white run ? */
496 if (run
->nFlags
& MERF_WHITESPACE
) {
497 /* let the overflow logic handle it */
498 wc
->bOverflown
= TRUE
;
501 /* TAB: we can split before */
502 if (run
->nFlags
& MERF_TAB
) {
503 wc
->bOverflown
= TRUE
;
504 if (wc
->pRowStart
== p
)
505 /* Don't split before the start of the run, or we will get an
511 /* graphics: we can split before, if run's width is smaller than row's width */
512 if ((run
->nFlags
& MERF_GRAPHICS
) && run
->nWidth
<= wc
->nAvailWidth
) {
513 wc
->bOverflown
= TRUE
;
516 /* can we separate out the last spaces ? (to use overflow logic later) */
517 if (run
->nFlags
& MERF_ENDWHITE
)
519 /* we aren't sure if it's *really* necessary, it's a good start however */
520 int black
= reverse_find_non_whitespace( get_text( run
, 0 ), len
);
521 split_run_extents(wc
, p
, black
);
522 /* handle both parts again */
525 /* determine the split point by backtracking */
526 pp
= ME_SplitByBacktracking(wc
, p
, loc
);
527 if (pp
== wc
->pRowStart
)
529 if (run
->nFlags
& MERF_STARTWHITE
)
531 /* We had only spaces so far, so we must be on the first line of the
532 * paragraph (or the first line after MERF_ENDROW forced the line
533 * break within the paragraph), since no other lines of the paragraph
534 * start with spaces. */
536 /* The lines will only contain spaces, and the rest of the run will
537 * overflow onto the next line. */
538 wc
->bOverflown
= TRUE
;
541 /* Couldn't split the first run, possible because we have a large font
542 * with a single character that caused an overflow.
544 wc
->pt
.x
+= run
->nWidth
;
547 if (p
!= pp
) /* found a suitable split point */
549 wc
->bOverflown
= TRUE
;
552 /* we detected that it's best to split on start of this run */
556 /* not found anything - writing over margins is the only option left */
558 if ((run
->nFlags
& (MERF_SPLITTABLE
| MERF_STARTWHITE
))
559 || ((run
->nFlags
& (MERF_GRAPHICS
|MERF_TAB
)) && (p
!= wc
->pRowStart
)))
561 wc
->pLastSplittableRun
= p
;
563 wc
->pt
.x
+= run
->nWidth
;
567 static int ME_GetParaLineSpace(ME_Context
* c
, ME_Paragraph
* para
)
570 if (!(para
->pFmt
->dwMask
& PFM_LINESPACING
)) return 0;
572 /* FIXME: how to compute simply the line space in ls ??? */
573 /* FIXME: does line spacing include the line itself ??? */
574 switch (para
->pFmt
->bLineSpacingRule
)
576 case 0: sp
= ls
; break;
577 case 1: sp
= (3 * ls
) / 2; break;
578 case 2: sp
= 2 * ls
; break;
579 case 3: sp
= ME_twips2pointsY(c
, para
->pFmt
->dyLineSpacing
); if (sp
< ls
) sp
= ls
; break;
580 case 4: sp
= ME_twips2pointsY(c
, para
->pFmt
->dyLineSpacing
); break;
581 case 5: sp
= para
->pFmt
->dyLineSpacing
/ 20; break;
582 default: FIXME("Unsupported spacing rule value %d\n", para
->pFmt
->bLineSpacingRule
);
584 if (c
->editor
->nZoomNumerator
== 0)
587 return sp
* c
->editor
->nZoomNumerator
/ c
->editor
->nZoomDenominator
;
590 static void ME_PrepareParagraphForWrapping(ME_Context
*c
, ME_DisplayItem
*tp
) {
593 tp
->member
.para
.nWidth
= 0;
594 /* remove row start items as they will be reinserted by the
595 * paragraph wrapper anyway */
596 tp
->member
.para
.nRows
= 0;
597 for (p
= tp
->next
; p
!= tp
->member
.para
.next_para
; p
= p
->next
) {
598 if (p
->type
== diStartRow
) {
599 ME_DisplayItem
*pRow
= p
;
602 ME_DestroyDisplayItem(pRow
);
605 /* join runs that can be joined */
606 for (p
= tp
->next
; p
!= tp
->member
.para
.next_para
; p
= p
->next
) {
607 assert(p
->type
!= diStartRow
); /* should have been deleted above */
608 if (p
->type
== diRun
) {
609 while (p
->next
->type
== diRun
&& /* FIXME */
610 ME_CanJoinRuns(&p
->member
.run
, &p
->next
->member
.run
)) {
611 ME_JoinRuns(c
->editor
, p
);
617 static void ME_WrapTextParagraph(ME_Context
*c
, ME_DisplayItem
*tp
) {
624 assert(tp
->type
== diParagraph
);
625 if (!(tp
->member
.para
.nFlags
& MEPF_REWRAP
)) {
628 ME_PrepareParagraphForWrapping(c
, tp
);
629 pFmt
= tp
->member
.para
.pFmt
;
633 /* wc.para_style = tp->member.para.style; */
635 if (tp
->member
.para
.nFlags
& MEPF_ROWEND
) {
636 wc
.nFirstMargin
= wc
.nLeftMargin
= wc
.nRightMargin
= 0;
638 int dxStartIndent
= pFmt
->dxStartIndent
;
639 if (tp
->member
.para
.pCell
) {
640 dxStartIndent
+= ME_GetTableRowEnd(tp
)->member
.para
.pFmt
->dxOffset
;
642 wc
.nFirstMargin
= ME_twips2pointsX(c
, dxStartIndent
);
643 wc
.nLeftMargin
= wc
.nFirstMargin
+ ME_twips2pointsX(c
, pFmt
->dxOffset
);
644 wc
.nRightMargin
= ME_twips2pointsX(c
, pFmt
->dxRightIndent
);
646 if (c
->editor
->bEmulateVersion10
&& /* v1.0 - 3.0 */
647 pFmt
->dwMask
& PFM_TABLE
&& pFmt
->wEffects
& PFE_TABLE
)
649 wc
.nFirstMargin
+= ME_twips2pointsX(c
, pFmt
->dxOffset
* 2);
653 if (pFmt
->dwMask
& PFM_SPACEBEFORE
)
654 wc
.pt
.y
+= ME_twips2pointsY(c
, pFmt
->dySpaceBefore
);
655 if (!(pFmt
->dwMask
& PFM_TABLE
&& pFmt
->wEffects
& PFE_TABLE
) &&
656 pFmt
->dwMask
& PFM_BORDER
)
658 border
= ME_GetParaBorderWidth(c
, tp
->member
.para
.pFmt
->wBorders
);
659 if (pFmt
->wBorders
& 1) {
660 wc
.nFirstMargin
+= border
;
661 wc
.nLeftMargin
+= border
;
663 if (pFmt
->wBorders
& 2)
664 wc
.nRightMargin
-= border
;
665 if (pFmt
->wBorders
& 4)
669 linespace
= ME_GetParaLineSpace(c
, &tp
->member
.para
);
672 for (p
= tp
->next
; p
!=tp
->member
.para
.next_para
; ) {
673 assert(p
->type
!= diStartRow
);
674 if (p
->type
== diRun
) {
675 p
= ME_WrapHandleRun(&wc
, p
);
678 if (wc
.nRow
&& p
== wc
.pRowStart
)
679 wc
.pt
.y
+= linespace
;
681 ME_WrapEndParagraph(&wc
, p
);
682 if (!(pFmt
->dwMask
& PFM_TABLE
&& pFmt
->wEffects
& PFE_TABLE
) &&
683 (pFmt
->dwMask
& PFM_BORDER
) && (pFmt
->wBorders
& 8))
685 if (tp
->member
.para
.pFmt
->dwMask
& PFM_SPACEAFTER
)
686 wc
.pt
.y
+= ME_twips2pointsY(c
, pFmt
->dySpaceAfter
);
688 tp
->member
.para
.nFlags
&= ~MEPF_REWRAP
;
689 tp
->member
.para
.nHeight
= wc
.pt
.y
;
690 tp
->member
.para
.nRows
= wc
.nRow
;
693 static void ME_MarkRepaintEnd(ME_DisplayItem
*para
,
694 ME_DisplayItem
**repaint_start
,
695 ME_DisplayItem
**repaint_end
)
698 *repaint_start
= para
;
702 BOOL
ME_WrapMarkedParagraphs(ME_TextEditor
*editor
)
704 ME_DisplayItem
*item
;
707 ME_DisplayItem
*repaint_start
= NULL
, *repaint_end
= NULL
;
709 ME_InitContext(&c
, editor
, ITextHost_TxGetDC(editor
->texthost
));
711 item
= editor
->pBuffer
->pFirst
->next
;
712 while(item
!= editor
->pBuffer
->pLast
) {
713 BOOL bRedraw
= FALSE
;
715 assert(item
->type
== diParagraph
);
716 if ((item
->member
.para
.nFlags
& MEPF_REWRAP
)
717 || (item
->member
.para
.pt
.y
!= c
.pt
.y
))
719 item
->member
.para
.pt
= c
.pt
;
721 ME_WrapTextParagraph(&c
, item
);
724 ME_MarkRepaintEnd(item
, &repaint_start
, &repaint_end
);
726 if (item
->member
.para
.nFlags
& MEPF_ROWSTART
)
728 ME_DisplayItem
*cell
= ME_FindItemFwd(item
, diCell
);
729 ME_DisplayItem
*endRowPara
;
731 cell
->member
.cell
.pt
= c
.pt
;
732 /* Offset the text by the largest top border width. */
733 while (cell
->member
.cell
.next_cell
) {
734 borderWidth
= max(borderWidth
, cell
->member
.cell
.border
.top
.width
);
735 cell
= cell
->member
.cell
.next_cell
;
737 endRowPara
= ME_FindItemFwd(cell
, diParagraph
);
738 assert(endRowPara
->member
.para
.nFlags
& MEPF_ROWEND
);
741 borderWidth
= max(ME_twips2pointsY(&c
, borderWidth
), 1);
743 cell
->member
.cell
.yTextOffset
= borderWidth
;
744 cell
= cell
->member
.cell
.prev_cell
;
746 c
.pt
.y
+= borderWidth
;
748 if (endRowPara
->member
.para
.pFmt
->dxStartIndent
> 0)
750 int dxStartIndent
= endRowPara
->member
.para
.pFmt
->dxStartIndent
;
751 cell
= ME_FindItemFwd(item
, diCell
);
752 cell
->member
.cell
.pt
.x
+= ME_twips2pointsX(&c
, dxStartIndent
);
753 c
.pt
.x
= cell
->member
.cell
.pt
.x
;
756 else if (item
->member
.para
.nFlags
& MEPF_ROWEND
)
758 /* Set all the cells to the height of the largest cell */
759 ME_DisplayItem
*startRowPara
;
760 int prevHeight
, nHeight
, bottomBorder
= 0;
761 ME_DisplayItem
*cell
= ME_FindItemBack(item
, diCell
);
762 item
->member
.para
.nWidth
= cell
->member
.cell
.pt
.x
+ cell
->member
.cell
.nWidth
;
763 if (!(item
->member
.para
.next_para
->member
.para
.nFlags
& MEPF_ROWSTART
))
765 /* Last row, the bottom border is added to the height. */
766 cell
= cell
->member
.cell
.prev_cell
;
769 bottomBorder
= max(bottomBorder
, cell
->member
.cell
.border
.bottom
.width
);
770 cell
= cell
->member
.cell
.prev_cell
;
772 bottomBorder
= ME_twips2pointsY(&c
, bottomBorder
);
773 cell
= ME_FindItemBack(item
, diCell
);
775 prevHeight
= cell
->member
.cell
.nHeight
;
776 nHeight
= cell
->member
.cell
.prev_cell
->member
.cell
.nHeight
+ bottomBorder
;
777 cell
->member
.cell
.nHeight
= nHeight
;
778 item
->member
.para
.nHeight
= nHeight
;
779 cell
= cell
->member
.cell
.prev_cell
;
780 cell
->member
.cell
.nHeight
= nHeight
;
781 while (cell
->member
.cell
.prev_cell
)
783 cell
= cell
->member
.cell
.prev_cell
;
784 cell
->member
.cell
.nHeight
= nHeight
;
786 /* Also set the height of the start row paragraph */
787 startRowPara
= ME_FindItemBack(cell
, diParagraph
);
788 startRowPara
->member
.para
.nHeight
= nHeight
;
789 c
.pt
.x
= startRowPara
->member
.para
.pt
.x
;
790 c
.pt
.y
= cell
->member
.cell
.pt
.y
+ nHeight
;
791 if (prevHeight
< nHeight
)
793 /* The height of the cells has grown, so invalidate the bottom of
795 ME_MarkRepaintEnd(item
, &repaint_start
, &repaint_end
);
796 cell
= ME_FindItemBack(item
, diCell
);
798 ME_MarkRepaintEnd(ME_FindItemBack(cell
, diParagraph
), &repaint_start
, &repaint_end
);
799 cell
= cell
->member
.cell
.prev_cell
;
803 else if (item
->member
.para
.pCell
&&
804 item
->member
.para
.pCell
!= item
->member
.para
.next_para
->member
.para
.pCell
)
806 /* The next paragraph is in the next cell in the table row. */
807 ME_Cell
*cell
= &item
->member
.para
.pCell
->member
.cell
;
808 cell
->nHeight
= c
.pt
.y
+ item
->member
.para
.nHeight
- cell
->pt
.y
;
810 /* Propagate the largest height to the end so that it can be easily
811 * sent back to all the cells at the end of the row. */
813 cell
->nHeight
= max(cell
->nHeight
, cell
->prev_cell
->member
.cell
.nHeight
);
815 c
.pt
.x
= cell
->pt
.x
+ cell
->nWidth
;
817 cell
->next_cell
->member
.cell
.pt
= c
.pt
;
818 if (!(item
->member
.para
.next_para
->member
.para
.nFlags
& MEPF_ROWEND
))
819 c
.pt
.y
+= cell
->yTextOffset
;
823 if (item
->member
.para
.pCell
) {
824 /* Next paragraph in the same cell. */
825 c
.pt
.x
= item
->member
.para
.pCell
->member
.cell
.pt
.x
;
827 /* Normal paragraph */
830 c
.pt
.y
+= item
->member
.para
.nHeight
;
833 totalWidth
= max(totalWidth
, item
->member
.para
.nWidth
);
834 item
= item
->member
.para
.next_para
;
836 editor
->sizeWindow
.cx
= c
.rcView
.right
-c
.rcView
.left
;
837 editor
->sizeWindow
.cy
= c
.rcView
.bottom
-c
.rcView
.top
;
839 editor
->nTotalLength
= c
.pt
.y
;
840 editor
->nTotalWidth
= totalWidth
;
841 editor
->pBuffer
->pLast
->member
.para
.pt
.x
= 0;
842 editor
->pBuffer
->pLast
->member
.para
.pt
.y
= c
.pt
.y
;
844 ME_DestroyContext(&c
);
846 if (repaint_start
|| editor
->nTotalLength
< editor
->nLastTotalLength
)
847 ME_InvalidateParagraphRange(editor
, repaint_start
, repaint_end
);
848 return !!repaint_start
;
851 void ME_InvalidateParagraphRange(ME_TextEditor
*editor
,
852 ME_DisplayItem
*start_para
,
853 ME_DisplayItem
*last_para
)
859 ME_InitContext(&c
, editor
, ITextHost_TxGetDC(editor
->texthost
));
861 ofs
= editor
->vert_si
.nPos
;
864 start_para
= ME_GetOuterParagraph(start_para
);
865 last_para
= ME_GetOuterParagraph(last_para
);
866 rc
.top
= c
.rcView
.top
+ start_para
->member
.para
.pt
.y
- ofs
;
868 rc
.top
= c
.rcView
.top
+ editor
->nTotalLength
- ofs
;
870 if (editor
->nTotalLength
< editor
->nLastTotalLength
)
871 rc
.bottom
= c
.rcView
.top
+ editor
->nLastTotalLength
- ofs
;
873 rc
.bottom
= c
.rcView
.top
+ last_para
->member
.para
.pt
.y
+ last_para
->member
.para
.nHeight
- ofs
;
874 ITextHost_TxInvalidateRect(editor
->texthost
, &rc
, TRUE
);
876 ME_DestroyContext(&c
);
881 ME_SendRequestResize(ME_TextEditor
*editor
, BOOL force
)
883 if (editor
->nEventMask
& ENM_REQUESTRESIZE
)
887 ITextHost_TxGetClientRect(editor
->texthost
, &rc
);
889 if (force
|| rc
.bottom
!= editor
->nTotalLength
)
893 info
.nmhdr
.hwndFrom
= NULL
;
894 info
.nmhdr
.idFrom
= 0;
895 info
.nmhdr
.code
= EN_REQUESTRESIZE
;
897 info
.rc
.right
= editor
->nTotalWidth
;
898 info
.rc
.bottom
= editor
->nTotalLength
;
900 editor
->nEventMask
&= ~ENM_REQUESTRESIZE
;
901 ITextHost_TxNotify(editor
->texthost
, info
.nmhdr
.code
, &info
);
902 editor
->nEventMask
|= ENM_REQUESTRESIZE
;