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