1 // Copyright 2014 The PDFium Authors
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 // Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
6
7 #include "xfa/fde/cfde_textout.h"
8
9 #include <algorithm>
10 #include <utility>
11
12 #include "build/build_config.h"
13 #include "core/fxcrt/fx_coordinates.h"
14 #include "core/fxcrt/fx_extension.h"
15 #include "core/fxcrt/fx_system.h"
16 #include "core/fxcrt/stl_util.h"
17 #include "core/fxge/cfx_font.h"
18 #include "core/fxge/cfx_path.h"
19 #include "core/fxge/cfx_renderdevice.h"
20 #include "core/fxge/cfx_substfont.h"
21 #include "core/fxge/cfx_textrenderoptions.h"
22 #include "core/fxge/fx_font.h"
23 #include "core/fxge/text_char_pos.h"
24 #include "third_party/base/check.h"
25 #include "third_party/base/check_op.h"
26 #include "third_party/base/numerics/safe_conversions.h"
27 #include "xfa/fgas/font/cfgas_gefont.h"
28 #include "xfa/fgas/layout/cfgas_txtbreak.h"
29
30 namespace {
31
TextAlignmentVerticallyCentered(const FDE_TextAlignment align)32 bool TextAlignmentVerticallyCentered(const FDE_TextAlignment align) {
33 return align == FDE_TextAlignment::kCenterLeft ||
34 align == FDE_TextAlignment::kCenter ||
35 align == FDE_TextAlignment::kCenterRight;
36 }
37
IsTextAlignmentTop(const FDE_TextAlignment align)38 bool IsTextAlignmentTop(const FDE_TextAlignment align) {
39 return align == FDE_TextAlignment::kTopLeft;
40 }
41
42 } // namespace
43
44 // static
DrawString(CFX_RenderDevice * device,FX_ARGB color,const RetainPtr<CFGAS_GEFont> & pFont,pdfium::span<TextCharPos> pCharPos,float fFontSize,const CFX_Matrix & matrix)45 bool CFDE_TextOut::DrawString(CFX_RenderDevice* device,
46 FX_ARGB color,
47 const RetainPtr<CFGAS_GEFont>& pFont,
48 pdfium::span<TextCharPos> pCharPos,
49 float fFontSize,
50 const CFX_Matrix& matrix) {
51 DCHECK(pFont);
52 DCHECK(!pCharPos.empty());
53
54 CFX_Font* pFxFont = pFont->GetDevFont();
55 if (FontStyleIsItalic(pFont->GetFontStyles()) && !pFxFont->IsItalic()) {
56 for (auto& pos : pCharPos) {
57 static constexpr float mc = 0.267949f;
58 pos.m_AdjustMatrix[2] += mc * pos.m_AdjustMatrix[0];
59 pos.m_AdjustMatrix[3] += mc * pos.m_AdjustMatrix[1];
60 }
61 }
62
63 #if !BUILDFLAG(IS_WIN)
64 uint32_t dwFontStyle = pFont->GetFontStyles();
65 CFX_Font FxFont;
66 auto SubstFxFont = std::make_unique<CFX_SubstFont>();
67 SubstFxFont->m_Weight = FontStyleIsForceBold(dwFontStyle) ? 700 : 400;
68 SubstFxFont->m_ItalicAngle = FontStyleIsItalic(dwFontStyle) ? -12 : 0;
69 SubstFxFont->m_WeightCJK = SubstFxFont->m_Weight;
70 SubstFxFont->m_bItalicCJK = FontStyleIsItalic(dwFontStyle);
71 FxFont.SetSubstFont(std::move(SubstFxFont));
72 #endif
73
74 RetainPtr<CFGAS_GEFont> pCurFont;
75 TextCharPos* pCurCP = nullptr;
76 int32_t iCurCount = 0;
77 static constexpr CFX_TextRenderOptions kOptions(CFX_TextRenderOptions::kLcd);
78 for (auto& pos : pCharPos) {
79 RetainPtr<CFGAS_GEFont> pSTFont =
80 pFont->GetSubstFont(static_cast<int32_t>(pos.m_GlyphIndex));
81 pos.m_GlyphIndex &= 0x00FFFFFF;
82 pos.m_bFontStyle = false;
83 if (pCurFont != pSTFont) {
84 if (pCurFont) {
85 pFxFont = pCurFont->GetDevFont();
86
87 CFX_Font* font;
88 #if !BUILDFLAG(IS_WIN)
89 FxFont.SetFace(pFxFont->GetFace());
90 FxFont.SetFontSpan(pFxFont->GetFontSpan());
91 font = &FxFont;
92 #else
93 font = pFxFont;
94 #endif
95
96 device->DrawNormalText(pdfium::make_span(pCurCP, iCurCount), font,
97 -fFontSize, matrix, color, kOptions);
98 }
99 pCurFont = pSTFont;
100 pCurCP = &pos;
101 iCurCount = 1;
102 } else {
103 ++iCurCount;
104 }
105 }
106
107 bool bRet = true;
108 if (pCurFont && iCurCount) {
109 pFxFont = pCurFont->GetDevFont();
110 CFX_Font* font;
111 #if !BUILDFLAG(IS_WIN)
112 FxFont.SetFace(pFxFont->GetFace());
113 FxFont.SetFontSpan(pFxFont->GetFontSpan());
114 font = &FxFont;
115 #else
116 font = pFxFont;
117 #endif
118
119 bRet = device->DrawNormalText(pdfium::make_span(pCurCP, iCurCount), font,
120 -fFontSize, matrix, color, kOptions);
121 }
122
123 return bRet;
124 }
125
126 CFDE_TextOut::Piece::Piece() = default;
127
128 CFDE_TextOut::Piece::Piece(const Piece& that) = default;
129
130 CFDE_TextOut::Piece::~Piece() = default;
131
CFDE_TextOut()132 CFDE_TextOut::CFDE_TextOut()
133 : m_pTxtBreak(std::make_unique<CFGAS_TxtBreak>()) {}
134
135 CFDE_TextOut::~CFDE_TextOut() = default;
136
SetFont(RetainPtr<CFGAS_GEFont> pFont)137 void CFDE_TextOut::SetFont(RetainPtr<CFGAS_GEFont> pFont) {
138 DCHECK(pFont);
139 m_pFont = std::move(pFont);
140 m_pTxtBreak->SetFont(m_pFont);
141 }
142
SetFontSize(float fFontSize)143 void CFDE_TextOut::SetFontSize(float fFontSize) {
144 DCHECK(fFontSize > 0);
145 m_fFontSize = fFontSize;
146 m_pTxtBreak->SetFontSize(fFontSize);
147 }
148
SetStyles(const FDE_TextStyle & dwStyles)149 void CFDE_TextOut::SetStyles(const FDE_TextStyle& dwStyles) {
150 m_Styles = dwStyles;
151 m_dwTxtBkStyles = m_Styles.single_line_
152 ? CFGAS_Break::LayoutStyle::kSingleLine
153 : CFGAS_Break::LayoutStyle::kNone;
154
155 m_pTxtBreak->SetLayoutStyles(m_dwTxtBkStyles);
156 }
157
SetAlignment(FDE_TextAlignment iAlignment)158 void CFDE_TextOut::SetAlignment(FDE_TextAlignment iAlignment) {
159 m_iAlignment = iAlignment;
160
161 int32_t txtBreakAlignment = 0;
162 switch (m_iAlignment) {
163 case FDE_TextAlignment::kCenter:
164 txtBreakAlignment = CFX_TxtLineAlignment_Center;
165 break;
166 case FDE_TextAlignment::kCenterRight:
167 txtBreakAlignment = CFX_TxtLineAlignment_Right;
168 break;
169 case FDE_TextAlignment::kCenterLeft:
170 case FDE_TextAlignment::kTopLeft:
171 txtBreakAlignment = CFX_TxtLineAlignment_Left;
172 break;
173 }
174 m_pTxtBreak->SetAlignment(txtBreakAlignment);
175 }
176
SetLineSpace(float fLineSpace)177 void CFDE_TextOut::SetLineSpace(float fLineSpace) {
178 DCHECK(fLineSpace > 1.0f);
179 m_fLineSpace = fLineSpace;
180 }
181
SetLineBreakTolerance(float fTolerance)182 void CFDE_TextOut::SetLineBreakTolerance(float fTolerance) {
183 m_fTolerance = fTolerance;
184 m_pTxtBreak->SetLineBreakTolerance(m_fTolerance);
185 }
186
CalcLogicSize(WideStringView str,CFX_SizeF * pSize)187 void CFDE_TextOut::CalcLogicSize(WideStringView str, CFX_SizeF* pSize) {
188 CFX_RectF rtText(0.0f, 0.0f, pSize->width, pSize->height);
189 CalcLogicSize(str, &rtText);
190 *pSize = rtText.Size();
191 }
192
CalcLogicSize(WideStringView str,CFX_RectF * pRect)193 void CFDE_TextOut::CalcLogicSize(WideStringView str, CFX_RectF* pRect) {
194 if (str.IsEmpty()) {
195 pRect->width = 0.0f;
196 pRect->height = 0.0f;
197 return;
198 }
199
200 DCHECK(m_pFont);
201 DCHECK(m_fFontSize >= 1.0f);
202
203 if (!m_Styles.single_line_) {
204 if (pRect->Width() < 1.0f)
205 pRect->width = m_fFontSize * 1000.0f;
206
207 m_pTxtBreak->SetLineWidth(pRect->Width());
208 }
209
210 m_iTotalLines = 0;
211 float fWidth = 0.0f;
212 float fHeight = 0.0f;
213 float fStartPos = pRect->right();
214 CFGAS_Char::BreakType dwBreakStatus = CFGAS_Char::BreakType::kNone;
215 bool break_char_is_set = false;
216 for (const wchar_t& wch : str) {
217 if (!break_char_is_set && (wch == L'\n' || wch == L'\r')) {
218 break_char_is_set = true;
219 m_pTxtBreak->SetParagraphBreakChar(wch);
220 }
221 dwBreakStatus = m_pTxtBreak->AppendChar(wch);
222 if (!CFX_BreakTypeNoneOrPiece(dwBreakStatus))
223 RetrieveLineWidth(dwBreakStatus, &fStartPos, &fWidth, &fHeight);
224 }
225
226 dwBreakStatus = m_pTxtBreak->EndBreak(CFGAS_Char::BreakType::kParagraph);
227 if (!CFX_BreakTypeNoneOrPiece(dwBreakStatus))
228 RetrieveLineWidth(dwBreakStatus, &fStartPos, &fWidth, &fHeight);
229
230 m_pTxtBreak->Reset();
231 float fInc = pRect->Height() - fHeight;
232 if (TextAlignmentVerticallyCentered(m_iAlignment))
233 fInc /= 2.0f;
234 else if (IsTextAlignmentTop(m_iAlignment))
235 fInc = 0.0f;
236
237 pRect->left += fStartPos;
238 pRect->top += fInc;
239 pRect->width = std::min(fWidth, pRect->Width());
240 pRect->height = fHeight;
241 if (m_Styles.last_line_height_)
242 pRect->height -= m_fLineSpace - m_fFontSize;
243 }
244
RetrieveLineWidth(CFGAS_Char::BreakType dwBreakStatus,float * pStartPos,float * pWidth,float * pHeight)245 bool CFDE_TextOut::RetrieveLineWidth(CFGAS_Char::BreakType dwBreakStatus,
246 float* pStartPos,
247 float* pWidth,
248 float* pHeight) {
249 if (CFX_BreakTypeNoneOrPiece(dwBreakStatus))
250 return false;
251
252 float fLineStep = std::max(m_fLineSpace, m_fFontSize);
253 float fLineWidth = 0.0f;
254 for (int32_t i = 0; i < m_pTxtBreak->CountBreakPieces(); i++) {
255 const CFGAS_BreakPiece* pPiece = m_pTxtBreak->GetBreakPieceUnstable(i);
256 fLineWidth += static_cast<float>(pPiece->GetWidth()) / 20000.0f;
257 *pStartPos = std::min(*pStartPos,
258 static_cast<float>(pPiece->GetStartPos()) / 20000.0f);
259 }
260 m_pTxtBreak->ClearBreakPieces();
261
262 if (dwBreakStatus == CFGAS_Char::BreakType::kParagraph)
263 m_pTxtBreak->Reset();
264 if (!m_Styles.line_wrap_ && dwBreakStatus == CFGAS_Char::BreakType::kLine) {
265 *pWidth += fLineWidth;
266 } else {
267 *pWidth = std::max(*pWidth, fLineWidth);
268 *pHeight += fLineStep;
269 }
270 ++m_iTotalLines;
271 return true;
272 }
273
DrawLogicText(CFX_RenderDevice * device,const WideString & str,const CFX_RectF & rect)274 void CFDE_TextOut::DrawLogicText(CFX_RenderDevice* device,
275 const WideString& str,
276 const CFX_RectF& rect) {
277 DCHECK(m_pFont);
278 DCHECK(m_fFontSize >= 1.0f);
279
280 if (str.IsEmpty())
281 return;
282 if (rect.width < m_fFontSize || rect.height < m_fFontSize)
283 return;
284
285 float fLineWidth = rect.width;
286 m_pTxtBreak->SetLineWidth(fLineWidth);
287 m_ttoLines.clear();
288 m_wsText.clear();
289
290 LoadText(str, rect);
291 Reload(rect);
292 DoAlignment(rect);
293
294 if (!device || m_ttoLines.empty())
295 return;
296
297 CFX_RectF rtClip = m_Matrix.TransformRect(CFX_RectF());
298 device->SaveState();
299 if (rtClip.Width() > 0.0f && rtClip.Height() > 0.0f)
300 device->SetClip_Rect(rtClip.GetOuterRect());
301
302 for (auto& line : m_ttoLines) {
303 for (size_t i = 0; i < line.GetSize(); ++i) {
304 const Piece* pPiece = line.GetPieceAtIndex(i);
305 size_t szCount = GetDisplayPos(pPiece);
306 if (szCount == 0)
307 continue;
308
309 CFDE_TextOut::DrawString(device, m_TxtColor, m_pFont,
310 {m_CharPos.data(), szCount}, m_fFontSize,
311 m_Matrix);
312 }
313 }
314 device->RestoreState(false);
315 }
316
LoadText(const WideString & str,const CFX_RectF & rect)317 void CFDE_TextOut::LoadText(const WideString& str, const CFX_RectF& rect) {
318 DCHECK(!str.IsEmpty());
319
320 m_wsText = str;
321
322 if (m_CharWidths.size() < str.GetLength())
323 m_CharWidths.resize(str.GetLength(), 0);
324
325 float fLineStep = std::max(m_fLineSpace, m_fFontSize);
326 float fLineStop = rect.bottom();
327 m_fLinePos = rect.top;
328 size_t start_char = 0;
329 int32_t iPieceWidths = 0;
330 CFGAS_Char::BreakType dwBreakStatus;
331 bool bRet = false;
332 for (const auto& wch : str) {
333 dwBreakStatus = m_pTxtBreak->AppendChar(wch);
334 if (CFX_BreakTypeNoneOrPiece(dwBreakStatus))
335 continue;
336
337 bool bEndofLine =
338 RetrievePieces(dwBreakStatus, false, rect, &start_char, &iPieceWidths);
339 if (bEndofLine && (m_Styles.line_wrap_ ||
340 dwBreakStatus == CFGAS_Char::BreakType::kParagraph ||
341 dwBreakStatus == CFGAS_Char::BreakType::kPage)) {
342 iPieceWidths = 0;
343 ++m_iCurLine;
344 m_fLinePos += fLineStep;
345 }
346 if (m_fLinePos + fLineStep > fLineStop) {
347 size_t iCurLine = bEndofLine ? m_iCurLine - 1 : m_iCurLine;
348 CHECK_LT(m_iCurLine, m_ttoLines.size());
349 m_ttoLines[iCurLine].set_new_reload(true);
350 bRet = true;
351 break;
352 }
353 }
354
355 dwBreakStatus = m_pTxtBreak->EndBreak(CFGAS_Char::BreakType::kParagraph);
356 if (!CFX_BreakTypeNoneOrPiece(dwBreakStatus) && !bRet)
357 RetrievePieces(dwBreakStatus, false, rect, &start_char, &iPieceWidths);
358
359 m_pTxtBreak->ClearBreakPieces();
360 m_pTxtBreak->Reset();
361 }
362
RetrievePieces(CFGAS_Char::BreakType dwBreakStatus,bool bReload,const CFX_RectF & rect,size_t * pStartChar,int32_t * pPieceWidths)363 bool CFDE_TextOut::RetrievePieces(CFGAS_Char::BreakType dwBreakStatus,
364 bool bReload,
365 const CFX_RectF& rect,
366 size_t* pStartChar,
367 int32_t* pPieceWidths) {
368 float fLineStep = std::max(m_fLineSpace, m_fFontSize);
369 bool bNeedReload = false;
370 int32_t iLineWidth = FXSYS_roundf(rect.Width() * 20000.0f);
371 int32_t iCount = m_pTxtBreak->CountBreakPieces();
372
373 size_t chars_to_skip = *pStartChar;
374 for (int32_t i = 0; i < iCount; i++) {
375 const CFGAS_BreakPiece* pPiece = m_pTxtBreak->GetBreakPieceUnstable(i);
376 size_t iPieceChars = pPiece->GetLength();
377 if (chars_to_skip > iPieceChars) {
378 chars_to_skip -= iPieceChars;
379 continue;
380 }
381
382 size_t iChar = *pStartChar;
383 int32_t iWidth = 0;
384 size_t j = chars_to_skip;
385 for (; j < iPieceChars; j++) {
386 const CFGAS_Char* pTC = pPiece->GetChar(j);
387 int32_t iCurCharWidth = std::max(pTC->m_iCharWidth, 0);
388 if (m_Styles.single_line_ || !m_Styles.line_wrap_) {
389 if (iLineWidth - *pPieceWidths - iWidth < iCurCharWidth) {
390 bNeedReload = true;
391 break;
392 }
393 }
394 iWidth += iCurCharWidth;
395 m_CharWidths[iChar++] = iCurCharWidth;
396 }
397
398 if (j == chars_to_skip && !bReload) {
399 CHECK_LT(m_iCurLine, m_ttoLines.size());
400 m_ttoLines[m_iCurLine].set_new_reload(true);
401 } else if (j > chars_to_skip) {
402 Piece piece;
403 piece.start_char = *pStartChar;
404 piece.char_count = j - chars_to_skip;
405 piece.char_styles = pPiece->GetCharStyles();
406 piece.bounds = CFX_RectF(
407 rect.left + static_cast<float>(pPiece->GetStartPos()) / 20000.0f,
408 m_fLinePos, iWidth / 20000.0f, fLineStep);
409
410 if (FX_IsOdd(pPiece->GetBidiLevel()))
411 piece.char_styles |= FX_TXTCHARSTYLE_OddBidiLevel;
412
413 AppendPiece(piece, bNeedReload, (bReload && i == iCount - 1));
414 }
415 *pStartChar += iPieceChars;
416 *pPieceWidths += iWidth;
417 }
418 m_pTxtBreak->ClearBreakPieces();
419
420 return m_Styles.single_line_ || m_Styles.line_wrap_ || bNeedReload ||
421 dwBreakStatus == CFGAS_Char::BreakType::kParagraph;
422 }
423
AppendPiece(const Piece & piece,bool bNeedReload,bool bEnd)424 void CFDE_TextOut::AppendPiece(const Piece& piece,
425 bool bNeedReload,
426 bool bEnd) {
427 if (m_iCurLine >= m_ttoLines.size()) {
428 Line ttoLine;
429 ttoLine.set_new_reload(bNeedReload);
430
431 m_iCurPiece = ttoLine.AddPiece(m_iCurPiece, piece);
432 m_ttoLines.push_back(ttoLine);
433 m_iCurLine = m_ttoLines.size() - 1;
434 } else {
435 Line* pLine = &m_ttoLines[m_iCurLine];
436 pLine->set_new_reload(bNeedReload);
437
438 m_iCurPiece = pLine->AddPiece(m_iCurPiece, piece);
439 if (bEnd) {
440 size_t iPieces = pLine->GetSize();
441 if (m_iCurPiece < iPieces)
442 pLine->RemoveLast(iPieces - m_iCurPiece - 1);
443 }
444 }
445 if (!bEnd && bNeedReload)
446 m_iCurPiece = 0;
447 }
448
Reload(const CFX_RectF & rect)449 void CFDE_TextOut::Reload(const CFX_RectF& rect) {
450 size_t i = 0;
451 for (auto& line : m_ttoLines) {
452 if (line.new_reload()) {
453 m_iCurLine = i;
454 m_iCurPiece = 0;
455 ReloadLinePiece(&line, rect);
456 }
457 ++i;
458 }
459 }
460
ReloadLinePiece(Line * line,const CFX_RectF & rect)461 void CFDE_TextOut::ReloadLinePiece(Line* line, const CFX_RectF& rect) {
462 pdfium::span<const wchar_t> text_span = m_wsText.span();
463 size_t start_char = 0;
464 size_t piece_count = line->GetSize();
465 int32_t piece_widths = 0;
466 CFGAS_Char::BreakType break_status = CFGAS_Char::BreakType::kNone;
467 for (size_t piece_index = 0; piece_index < piece_count; ++piece_index) {
468 const Piece* piece = line->GetPieceAtIndex(piece_index);
469 if (piece_index == 0)
470 m_fLinePos = piece->bounds.top;
471
472 start_char = piece->start_char;
473 const size_t end = piece->start_char + piece->char_count;
474 for (size_t char_index = start_char; char_index < end; ++char_index) {
475 break_status = m_pTxtBreak->AppendChar(text_span[char_index]);
476 if (!CFX_BreakTypeNoneOrPiece(break_status))
477 RetrievePieces(break_status, true, rect, &start_char, &piece_widths);
478 }
479 }
480
481 break_status = m_pTxtBreak->EndBreak(CFGAS_Char::BreakType::kParagraph);
482 if (!CFX_BreakTypeNoneOrPiece(break_status))
483 RetrievePieces(break_status, true, rect, &start_char, &piece_widths);
484
485 m_pTxtBreak->Reset();
486 }
487
DoAlignment(const CFX_RectF & rect)488 void CFDE_TextOut::DoAlignment(const CFX_RectF& rect) {
489 if (m_ttoLines.empty())
490 return;
491
492 const Piece* pFirstPiece = m_ttoLines.back().GetPieceAtIndex(0);
493 if (!pFirstPiece)
494 return;
495
496 float fInc = rect.bottom() - pFirstPiece->bounds.bottom();
497 if (TextAlignmentVerticallyCentered(m_iAlignment))
498 fInc /= 2.0f;
499 else if (IsTextAlignmentTop(m_iAlignment))
500 fInc = 0.0f;
501
502 if (fInc < 1.0f)
503 return;
504
505 for (auto& line : m_ttoLines) {
506 for (size_t i = 0; i < line.GetSize(); ++i)
507 line.GetPieceAtIndex(i)->bounds.top += fInc;
508 }
509 }
510
GetDisplayPos(const Piece * pPiece)511 size_t CFDE_TextOut::GetDisplayPos(const Piece* pPiece) {
512 if (m_CharPos.size() < pPiece->char_count)
513 m_CharPos.resize(pPiece->char_count, TextCharPos());
514
515 CFGAS_TxtBreak::Run tr;
516 tr.wsStr = m_wsText.Substr(pPiece->start_char);
517 tr.pWidths = &m_CharWidths[pPiece->start_char];
518 tr.iLength = pdfium::base::checked_cast<int32_t>(pPiece->char_count);
519 tr.pFont = m_pFont;
520 tr.fFontSize = m_fFontSize;
521 tr.dwStyles = m_dwTxtBkStyles;
522 tr.dwCharStyles = pPiece->char_styles;
523 tr.pRect = &pPiece->bounds;
524
525 return m_pTxtBreak->GetDisplayPos(tr, m_CharPos.data());
526 }
527
528 CFDE_TextOut::Line::Line() = default;
529
Line(const Line & that)530 CFDE_TextOut::Line::Line(const Line& that)
531 : new_reload_(that.new_reload_), pieces_(that.pieces_) {}
532
533 CFDE_TextOut::Line::~Line() = default;
534
AddPiece(size_t index,const Piece & piece)535 size_t CFDE_TextOut::Line::AddPiece(size_t index, const Piece& piece) {
536 if (index >= pieces_.size()) {
537 pieces_.push_back(piece);
538 return pieces_.size();
539 }
540 pieces_[index] = piece;
541 return index;
542 }
543
GetSize() const544 size_t CFDE_TextOut::Line::GetSize() const {
545 return pieces_.size();
546 }
547
GetPieceAtIndex(size_t index) const548 const CFDE_TextOut::Piece* CFDE_TextOut::Line::GetPieceAtIndex(
549 size_t index) const {
550 CHECK(fxcrt::IndexInBounds(pieces_, index));
551 return &pieces_[index];
552 }
553
GetPieceAtIndex(size_t index)554 CFDE_TextOut::Piece* CFDE_TextOut::Line::GetPieceAtIndex(size_t index) {
555 CHECK(fxcrt::IndexInBounds(pieces_, index));
556 return &pieces_[index];
557 }
558
RemoveLast(size_t count)559 void CFDE_TextOut::Line::RemoveLast(size_t count) {
560 pieces_.erase(pieces_.end() - std::min(count, pieces_.size()), pieces_.end());
561 }
562