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