text_edit.h

// Copyright (c) 2009-2025 Avanquest Software. All rights reserved.
 
#ifndef PDFSDK_CXX_TEXT_EDIT_H_INCLUDED_
#define PDFSDK_CXX_TEXT_EDIT_H_INCLUDED_
 
#include <pdfsdk/cxx/element.h>
#include <pdfsdk/cxx/math.h>
#include <pdfsdk/cxx/text_run.h>
#include <pdfsdk/text_edit.h>
 
#include "forward_declarations.h"
#include "wrapper_base.h"
 
namespace PDF {
namespace TextEdit {
 
class CharIterator;
class Layout;
class TextBlock;
class TextCommand;
 
class Layout : public detail::RefCountedHandle<PDTLayout> {
public:
    static Layout BuildForPage(const Page& page);
 
    static Layout BuildForFormXObject(const Document& doc, const XObject& xform);
 
    TextBlock NewTextBlock(size_t index);
 
    void InsertTextBlock(size_t index, const TextBlock& text_block);
 
    void RemoveTextBlock(size_t index);
 
    size_t GetNumTextBlocks() const;
 
    TextBlock GetTextBlock(size_t index) const;
 
    size_t FindTextBlockIndex(const TextBlock& text_block) const;
 
    CharIterator GetCharsBegin() const;
 
    CharIterator GetCharsEnd() const;
 
    CharIterator GetCharIterAtPoint(const PointF& point) const;
 
    CharIterator GetCharIterForItem(const TextRun& text_run, size_t char_index) const;
 
    CharIterator GetCharIterForItemAtPoint(const TextRun& text_run, const PointF& point) const;
 
    PDF_CXX_CORE_WRAPPER_DEFINE_MEMBERS_(Layout, PDTLayout)
};
 
class TextBlock : public detail::RefCountedHandle<PDTTextBlock> {
public:
    bool Equals(const TextBlock& that) const;
 
    PointF GetPosition() const;
 
    SizeF GetSize() const;
 
    float GetRotation() const;
 
    bool IsReflected() const;
 
    RectF GetBBox() const;
 
    CharIterator GetCharBegin(const Layout& text_layout) const;
 
    CharIterator GetCharEnd(const Layout& text_layout) const;
 
    Element CreateTextElement() const;
 
    bool IsExplicitWidth() const;
 
    void SetExplicitWidth(bool value);
 
    PDF_CXX_CORE_WRAPPER_DEFINE_MEMBERS_(TextBlock, PDTTextBlock)
};
 
class CharIterator : public detail::RefCountedHandle<PDTCharIterator> {
public:
    CharIterator GetBlockBegin() const;
 
    CharIterator GetBlockEnd() const;
 
    CharIterator GetParaBegin() const;
 
    CharIterator GetParaEnd() const;
 
    CharIterator GetLineBegin() const;
 
    CharIterator GetLineEnd() const;
 
    CharIterator GetWordBegin() const;
 
    CharIterator GetWordEnd() const;
 
    CharIterator GetSpanBegin() const;
 
    CharIterator GetSpanEnd() const;
 
    CharIterator GetAbove() const;
 
    CharIterator GetAboveAtPage(const Layout& prev_page_text_layout) const;
 
    CharIterator GetBelow() const;
 
    CharIterator GetBelowAtPage(const Layout& next_page_text_layout) const;
 
    CharIterator Copy() const;
 
    void MoveNext();
 
    void MovePrev();
 
    void Move(int n);
 
    int Distance(const CharIterator& that) const;
 
    bool Less(const CharIterator& that) const;
 
    bool Equal(const CharIterator& that) const;
 
    std::wstring GetUnicodeChar() const;
 
    size_t GetPageIndex() const;
 
    Quad GetQuad() const;
 
    Quad GetOutlineQuad() const;
 
    TextBlock GetTextBlock() const;
 
    PDTFontAttrs GetFontAttrs() const;
 
    PDTParaAttrs GetParaAttrs() const;
 
    PDTListAttrs GetListAttrs() const;
 
    Matrix GetTransform() const;
 
    TextRun GetTextRun() const;
 
    PDF_CXX_CORE_WRAPPER_DEFINE_MEMBERS_(CharIterator, PDTCharIterator)
};
 
class TextCommand : public detail::RefCountedHandle<PDTTextCommand> {
public:
    static TextCommand DeleteText(Document doc, CharIterator beg, CharIterator end);
 
    static TextCommand InsertText(Document doc, CharIterator pos, const PDTFontAttrs& font_attrs, const std::wstring& chars);
 
    static TextCommand ReplaceText(Document doc, CharIterator beg, CharIterator end, const PDTFontAttrs& font_attrs, const std::wstring& chars);
 
    static TextCommand ChangeFont(Document doc, CharIterator beg, CharIterator end, PDAtom font_family, PDAtom font_format);
 
    static TextCommand ChangeFontStyle(Document doc, CharIterator beg, CharIterator end, PDFontStyle font_style);
 
    static TextCommand ChangeFontSize(Document doc, CharIterator beg, CharIterator end, float font_size);
 
    static TextCommand ChangeFontColor(Document doc, CharIterator beg, CharIterator end, PDColorValue font_color);
 
    static TextCommand ChangeEscapement(Document doc, CharIterator begin, CharIterator end, PDTEscapement escapment);
 
    static TextCommand ChangeHorzScaling(Document doc, CharIterator begin, CharIterator end, float horz_scaling);
 
    static TextCommand ChangeCharSpacing(Document doc, CharIterator begin, CharIterator end, float char_spacing);
 
    static TextCommand ChangeParaAttrs(Document doc, CharIterator iter, const PDTParaAttrs& para_attrs);
 
    static TextCommand NewTextBlock(Document doc, Layout layout, const PointF& page_point, const PDTFontAttrs& font_attrs, const PDTParaAttrs& para_attrs);
 
    static TextCommand DeleteTextBlock(Document doc, Layout layout, const TextBlock& block);
 
    static TextCommand MergeTextBlocks(Document doc, CharIterator begin, CharIterator end);
 
    static TextCommand UpdateTextBlocks(Document doc, Layout layout);
 
    static TextCommand MoveTextBlock(Document doc, Layout layout, size_t block_index, const PointF& pos);
 
    static TextCommand RotateTextBlock(Document doc, Layout layout, size_t block_index, float radians);
 
    static TextCommand ScaleTextBlock(Document doc, Layout layout, size_t block_index, const SizeF& size);
 
    static TextCommand ResizeTextBlock(Document doc, Layout layout, size_t block_index, const SizeF& size);
 
    static TextCommand SyncWithContent(Document doc, Layout layout, size_t block_index, bool on_top);
 
    static TextCommand ChangeListStyle(Document doc, CharIterator begin, CharIterator end, const PDTListLevelStyle& style);
 
    static TextCommand ChangeListLevel(Document doc, CharIterator begin, CharIterator end, int change);
 
    void Redo();
 
    void Undo();
 
    bool IsFontSubstituted() const;
 
    PDF_CXX_CORE_WRAPPER_DEFINE_MEMBERS_(TextCommand, PDTTextCommand)
};
 
inline Layout Layout::BuildForPage(const Page& page) {
    Layout text_layout;
    PDF_CHECK_SUCCESS_X(PDPageBuildTextLayout(page.get(), &text_layout));
    return text_layout;
}
 
inline Layout Layout::BuildForFormXObject(const Document& doc, const XObject& xform) {
    Layout text_layout;
    PDF_CHECK_SUCCESS_X(PDEFormXObjectBuildTextLayout(doc.get(), xform.get(), &text_layout));
    return text_layout;
}
 
inline TextBlock Layout::NewTextBlock(size_t index) {
    TextBlock text_block;
    PDF_CHECK_SUCCESS_X(PDTLayoutNewTextBlock(m_handle, index, &text_block));
    return text_block;
}
 
inline void Layout::InsertTextBlock(size_t index, const TextBlock& text_block) {
    PDF_CHECK_SUCCESS_X(PDTLayoutInsertTextBlock(m_handle, index, text_block.get()));
}
 
inline void Layout::RemoveTextBlock(size_t index) {
    PDF_CHECK_SUCCESS_X(PDTLayoutRemoveTextBlock(m_handle, index));
}
 
inline size_t Layout::GetNumTextBlocks() const {
    size_t num_blocks = 0;
    PDF_CHECK_SUCCESS_X(PDTLayoutGetNumTextBlocks(m_handle, &num_blocks));
    return num_blocks;
}
 
inline TextBlock Layout::GetTextBlock(size_t index) const {
    TextBlock text_block;
    PDF_CHECK_SUCCESS_X(PDTLayoutGetTextBlock(m_handle, index, &text_block));
    return text_block;
}
 
inline size_t Layout::FindTextBlockIndex(const TextBlock& text_block) const {
    size_t index = kPDPageIndexNull;
    PDF_CHECK_SUCCESS_X(PDTLayoutGetTextBlockIndex(m_handle, text_block.get(), &index));
    return index;
}
 
inline CharIterator Layout::GetCharsBegin() const {
    CharIterator char_begin;
    PDF_CHECK_SUCCESS_X(PDTCharIteratorAtBeginPage(m_handle, &char_begin));
    return char_begin;
}
 
inline CharIterator Layout::GetCharsEnd() const {
    CharIterator char_end;
    PDF_CHECK_SUCCESS_X(PDTCharIteratorAtEndPage(m_handle, &char_end));
    return char_end;
}
 
inline CharIterator Layout::GetCharIterAtPoint(const PointF& point) const {
    CharIterator char_iter;
    PDF_CHECK_SUCCESS_X(PDTCharIteratorAtPoint(m_handle, &point, &char_iter));
    return char_iter;
}
 
inline CharIterator Layout::GetCharIterForItem(const TextRun& text_run, size_t char_index) const {
    CharIterator char_iter;
    PDF_CHECK_SUCCESS_X(PDTCharIteratorForItem(m_handle, text_run.get(), char_index, &char_iter));
    return char_iter;
}
 
inline CharIterator Layout::GetCharIterForItemAtPoint(const TextRun& text_run, const PointF& point) const {
    CharIterator char_iter;
    PDF_CHECK_SUCCESS_X(PDTCharIteratorForItemAtPoint(m_handle, text_run.get(), &point, &char_iter));
    return char_iter;
}
 
inline bool TextBlock::Equals(const TextBlock& that) const {
    return PDTTextBlockEqual(m_handle, that.get());
}
 
inline PointF TextBlock::GetPosition() const {
    PointF position;
    PDF_CHECK_SUCCESS_X(PDTTextBlockGetPosition(m_handle, &position));
    return position;
}
 
inline SizeF TextBlock::GetSize() const {
    SizeF size;
    PDF_CHECK_SUCCESS_X(PDTTextBlockGetSize(m_handle, &size));
    return size;
}
 
inline float TextBlock::GetRotation() const {
    float rotation = 0.f;
    PDF_CHECK_SUCCESS_X(PDTTextBlockGetRotate(m_handle, &rotation));
    return rotation;
}
 
inline bool TextBlock::IsReflected() const {
    bool reflected = false;
    PDF_CHECK_SUCCESS_X(PDTTextBlockIsReflected(m_handle, &reflected));
    return reflected;
}
 
inline RectF TextBlock::GetBBox() const {
    RectF bbox;
    PDF_CHECK_SUCCESS_X(PDTTextBlockGetBBox(m_handle, &bbox));
    return bbox;
}
 
inline CharIterator TextBlock::GetCharBegin(const Layout& text_layout) const {
    CharIterator char_begin;
    PDF_CHECK_SUCCESS_X(PDTTextBlockGetCharBegin(text_layout.get(), m_handle, &char_begin));
    return char_begin;
}
 
inline CharIterator TextBlock::GetCharEnd(const Layout& text_layout) const {
    CharIterator char_end;
    PDF_CHECK_SUCCESS_X(PDTTextBlockGetCharEnd(text_layout.get(), m_handle, &char_end));
    return char_end;
}
 
inline Element TextBlock::CreateTextElement() const {
    Element text_object;
    PDF_CHECK_SUCCESS_X(PDTTextBlockCreateTextElement(m_handle, &text_object));
    return text_object;
}
 
inline bool TextBlock::IsExplicitWidth() const {
    bool value = false;
    PDF_CHECK_SUCCESS_X(PDTTextBlockIsExplicitWidth(m_handle, &value));
    return value;
}
 
inline void TextBlock::SetExplicitWidth(bool value) {
    PDF_CHECK_SUCCESS_X(PDTTextBlockSetExplicitWidth(m_handle, value));
}
 
inline CharIterator CharIterator::GetBlockBegin() const {
    CharIterator char_iter;
    PDF_CHECK_SUCCESS_X(PDTCharIteratorGetBlockBegin(m_handle, &char_iter));
    return char_iter;
}
 
inline CharIterator CharIterator::GetBlockEnd() const {
    CharIterator char_iter;
    PDF_CHECK_SUCCESS_X(PDTCharIteratorGetBlockEnd(m_handle, &char_iter));
    return char_iter;
}
 
inline CharIterator CharIterator::GetParaBegin() const {
    CharIterator char_iter;
    PDF_CHECK_SUCCESS_X(PDTCharIteratorGetParaBegin(m_handle, &char_iter));
    return char_iter;
}
 
inline CharIterator CharIterator::GetParaEnd() const {
    CharIterator char_iter;
    PDF_CHECK_SUCCESS_X(PDTCharIteratorGetParaEnd(m_handle, &char_iter));
    return char_iter;
}
 
inline CharIterator CharIterator::GetLineBegin() const {
    CharIterator char_iter;
    PDF_CHECK_SUCCESS_X(PDTCharIteratorGetLineBegin(m_handle, &char_iter));
    return char_iter;
}
 
inline CharIterator CharIterator::GetLineEnd() const {
    CharIterator char_iter;
    PDF_CHECK_SUCCESS_X(PDTCharIteratorGetLineEnd(m_handle, &char_iter));
    return char_iter;
}
 
inline CharIterator CharIterator::GetWordBegin() const {
    CharIterator char_iter;
    PDF_CHECK_SUCCESS_X(PDTCharIteratorGetWordBegin(m_handle, &char_iter));
    return char_iter;
}
 
inline CharIterator CharIterator::GetWordEnd() const {
    CharIterator char_iter;
    PDF_CHECK_SUCCESS_X(PDTCharIteratorGetWordEnd(m_handle, &char_iter));
    return char_iter;
}
 
inline CharIterator CharIterator::GetSpanBegin() const {
    CharIterator char_iter;
    PDF_CHECK_SUCCESS_X(PDTCharIteratorGetSpanBegin(m_handle, &char_iter));
    return char_iter;
}
 
inline CharIterator CharIterator::GetSpanEnd() const {
    CharIterator char_iter;
    PDF_CHECK_SUCCESS_X(PDTCharIteratorGetSpanEnd(m_handle, &char_iter));
    return char_iter;
}
 
inline CharIterator CharIterator::GetAbove() const {
    CharIterator char_iter;
    PDF_CHECK_SUCCESS_X(PDTCharIteratorGetAbove(m_handle, &char_iter));
    return char_iter;
}
 
inline CharIterator CharIterator::GetAboveAtPage(const Layout& prev_page_text_layout) const {
    CharIterator char_iter;
    PDF_CHECK_SUCCESS_X(PDTCharIteratorGetAboveAtPage(m_handle, prev_page_text_layout.get(), &char_iter));
    return char_iter;
}
 
inline CharIterator CharIterator::GetBelow() const {
    CharIterator char_iter;
    PDF_CHECK_SUCCESS_X(PDTCharIteratorGetBelow(m_handle, &char_iter));
    return char_iter;
}
 
inline CharIterator CharIterator::GetBelowAtPage(const Layout& next_page_text_layout) const {
    CharIterator char_iter;
    PDF_CHECK_SUCCESS_X(PDTCharIteratorGetBelowAtPage(m_handle, next_page_text_layout.get(), &char_iter));
    return char_iter;
}
 
inline CharIterator CharIterator::Copy() const {
    CharIterator copy;
    PDF_CHECK_SUCCESS_X(PDTCharIteratorCopy(m_handle, &copy));
    return copy;
}
 
inline void CharIterator::MoveNext() {
    PDF_CHECK_SUCCESS_X(PDTCharIteratorIncrement(m_handle));
}
 
inline void CharIterator::MovePrev() {
    PDF_CHECK_SUCCESS_X(PDTCharIteratorDecrement(m_handle));
}
 
inline void CharIterator::Move(int n) {
    PDF_CHECK_SUCCESS_X(PDTCharIteratorAdvance(m_handle, n));
}
 
inline int CharIterator::Distance(const CharIterator& that) const {
    int dist = 0;
    PDF_CHECK_SUCCESS_X(PDTCharIteratorDistance(m_handle, that.get(), &dist));
    return dist;
}
 
inline bool CharIterator::Less(const CharIterator& that) const {
    bool less = false;
    PDF_CHECK_SUCCESS_X(PDTCharIteratorLess(m_handle, that.get(), &less));
    return less;
}
 
inline bool CharIterator::Equal(const CharIterator& that) const {
    bool equal = false;
    PDF_CHECK_SUCCESS_X(PDTCharIteratorEqual(m_handle, that.get(), &equal));
    return equal;
}
 
inline std::wstring CharIterator::GetUnicodeChar() const {
    return ::PDF::detail::GetWstringProperty(PDTCharIteratorGetUnicode, m_handle);
}
 
inline size_t CharIterator::GetPageIndex() const {
    size_t page_index = kPDPageIndexNull;
    PDF_CHECK_SUCCESS_X(PDTCharIteratorGetPageIndex(m_handle, &page_index));
    return page_index;
}
 
inline Quad CharIterator::GetQuad() const {
    Quad quad;
    PDF_CHECK_SUCCESS_X(PDTCharIteratorGetQuad(m_handle, &quad));
    return quad;
}
 
inline Quad CharIterator::GetOutlineQuad() const {
    Quad quad;
    PDF_CHECK_SUCCESS_X(PDTCharIteratorGetOutlineQuad(m_handle, &quad));
    return quad;
}
 
inline TextBlock CharIterator::GetTextBlock() const {
    TextBlock text_block;
    PDF_CHECK_SUCCESS_X(PDTCharIteratorGetTextBlock(m_handle, &text_block));
    return text_block;
}
 
inline PDTFontAttrs CharIterator::GetFontAttrs() const {
    PDTFontAttrs font_attrs;
    PDF_CHECK_SUCCESS_X(PDTCharIteratorGetFontAttrs(m_handle, &font_attrs));
    return font_attrs;
}
 
inline PDTParaAttrs CharIterator::GetParaAttrs() const {
    PDTParaAttrs para_attrs;
    PDF_CHECK_SUCCESS_X(PDTCharIteratorGetParaAttrs(m_handle, &para_attrs));
    return para_attrs;
}
 
inline PDTListAttrs CharIterator::GetListAttrs() const {
    PDTListAttrs list_attrs;
    PDF_CHECK_SUCCESS_X(PDTCharIteratorGetListAttrs(m_handle, &list_attrs));
    return list_attrs;
}
 
inline Matrix CharIterator::GetTransform() const {
    Matrix matrix;
    PDF_CHECK_SUCCESS_X(PDTCharIteratorGetTransform(m_handle, &matrix));
    return matrix;
}
 
inline TextRun CharIterator::GetTextRun() const {
    TextRun text_run;
    PDF_CHECK_SUCCESS_X(PDTCharIteratorGetTextItem(m_handle, &text_run));
    return text_run;
}
 
inline TextCommand TextCommand::DeleteText(Document doc, CharIterator beg, CharIterator end) {
    TextCommand text_command;
    PDF_CHECK_SUCCESS_X(PDTCreateDeleteTextCommand(doc.get(), beg.get(), end.get(), &text_command));
    return text_command;
}
 
inline TextCommand TextCommand::InsertText(Document doc, CharIterator pos, const PDTFontAttrs& font_attrs, const std::wstring& chars) {
    TextCommand text_command;
    PDF_CHECK_SUCCESS_X(PDTCreateInsertTextCommand(doc.get(), pos.get(), &font_attrs, chars.data(), chars.size(), &text_command));
    return text_command;
}
 
inline TextCommand TextCommand::ReplaceText(Document doc, CharIterator beg, CharIterator end, const PDTFontAttrs& font_attrs, const std::wstring& chars) {
    TextCommand text_command;
    PDF_CHECK_SUCCESS_X(PDTCreateReplaceTextCommand(doc.get(), beg.get(), end.get(), &font_attrs, chars.data(), chars.size(), &text_command));
    return text_command;
}
 
inline TextCommand TextCommand::ChangeFont(Document doc, CharIterator beg, CharIterator end, PDAtom font_family, PDAtom font_format) {
    TextCommand text_command;
    PDF_CHECK_SUCCESS_X(PDTCreateChangeFontCommand(doc.get(), beg.get(), end.get(), font_family, font_format, &text_command));
    return text_command;
}
 
inline TextCommand TextCommand::ChangeFontStyle(Document doc, CharIterator beg, CharIterator end, PDFontStyle font_style) {
    TextCommand text_command;
    PDF_CHECK_SUCCESS_X(PDTCreateChangeFontStyleCommand(doc.get(), beg.get(), end.get(), font_style, &text_command));
    return text_command;
}
 
inline TextCommand TextCommand::ChangeFontSize(Document doc, CharIterator beg, CharIterator end, float font_size) {
    TextCommand text_command;
    PDF_CHECK_SUCCESS_X(PDTCreateChangeFontSizeCommand(doc.get(), beg.get(), end.get(), font_size, &text_command));
    return text_command;
}
 
inline TextCommand TextCommand::ChangeFontColor(Document doc, CharIterator beg, CharIterator end, PDColorValue font_color) {
    TextCommand text_command;
    PDF_CHECK_SUCCESS_X(PDTCreateChangeFontColorCommand(doc.get(), beg.get(), end.get(), font_color, &text_command));
    return text_command;
}
 
inline TextCommand TextCommand::ChangeEscapement(Document doc, CharIterator begin, CharIterator end, PDTEscapement escapment) {
    TextCommand text_command;
    PDF_CHECK_SUCCESS_X(PDTCreateChangeEscapementCommand(doc.get(), begin.get(), end.get(), escapment, &text_command));
    return text_command;
}
 
inline TextCommand TextCommand::ChangeHorzScaling(Document doc, CharIterator begin, CharIterator end, float horz_scaling) {
    TextCommand text_command;
    PDF_CHECK_SUCCESS_X(PDTCreateChangeHorzScalingCommand(doc.get(), begin.get(), end.get(), horz_scaling, &text_command));
    return text_command;
}
 
inline TextCommand TextCommand::ChangeCharSpacing(Document doc, CharIterator begin, CharIterator end, float char_spacing) {
    TextCommand text_command;
    PDF_CHECK_SUCCESS_X(PDTCreateChangeCharSpacingCommand(doc.get(), begin.get(), end.get(), char_spacing, &text_command));
    return text_command;
}
 
inline TextCommand TextCommand::ChangeParaAttrs(Document doc, CharIterator iter, const PDTParaAttrs& para_attrs) {
    TextCommand text_command;
    PDF_CHECK_SUCCESS_X(PDTCreateChangeParaAttrsCommand(doc.get(), iter.get(), &para_attrs, &text_command));
    return text_command;
}
 
inline TextCommand TextCommand::NewTextBlock(Document doc, Layout layout, const PointF& page_point, const PDTFontAttrs& font_attrs, const PDTParaAttrs& para_attrs) {
    TextCommand text_command;
    PDF_CHECK_SUCCESS_X(PDTCreateNewTextBlockCommand(doc.get(), layout.get(), &page_point, &font_attrs, &para_attrs, &text_command));
    return text_command;
}
 
inline TextCommand TextCommand::DeleteTextBlock(Document doc, Layout layout, const TextBlock& block) {
    TextCommand text_command;
    PDF_CHECK_SUCCESS_X(PDTCreateDeleteTextBlockCommand(doc.get(), layout.get(), block.get(), &text_command));
    return text_command;
}
 
inline TextCommand TextCommand::MergeTextBlocks(Document doc, CharIterator begin, CharIterator end) {
    TextCommand text_command;
    PDF_CHECK_SUCCESS_X(PDTCreateMergeTextBlocksCommand(doc.get(), begin.get(), end.get(), &text_command));
    return text_command;
}
 
inline TextCommand TextCommand::UpdateTextBlocks(Document doc, Layout layout) {
    TextCommand text_command;
    PDF_CHECK_SUCCESS_X(PDTCreateUpdateTextBlocksCommand(doc.get(), layout.get(), &text_command));
    return text_command;
}
 
inline TextCommand TextCommand::MoveTextBlock(Document doc, Layout layout, size_t block_index, const PointF& pos) {
    TextCommand text_command;
    PDF_CHECK_SUCCESS_X(PDTCreateMoveTextBlockCommand(doc.get(), layout.get(), block_index, &pos, &text_command));
    return text_command;
}
 
inline TextCommand TextCommand::RotateTextBlock(Document doc, Layout layout, size_t block_index, float radians) {
    TextCommand text_command;
    PDF_CHECK_SUCCESS_X(PDTCreateRotateTextBlockCommand(doc.get(), layout.get(), block_index, radians, &text_command));
    return text_command;
}
 
inline TextCommand TextCommand::ScaleTextBlock(Document doc, Layout layout, size_t block_index, const SizeF& size) {
    TextCommand text_command;
    PDF_CHECK_SUCCESS_X(PDTCreateScaleTextBlockCommand(doc.get(), layout.get(), block_index, &size, &text_command));
    return text_command;
}
 
inline TextCommand TextCommand::ResizeTextBlock(Document doc, Layout layout, size_t block_index, const SizeF& size) {
    TextCommand text_command;
    PDF_CHECK_SUCCESS_X(PDTCreateResizeTextBlockCommand(doc.get(), layout.get(), block_index, &size, &text_command));
    return text_command;
}
 
inline TextCommand TextCommand::SyncWithContent(Document doc, Layout layout, size_t block_index, bool on_top) {
    TextCommand text_command;
    PDF_CHECK_SUCCESS_X(PDTCreateSyncWithContentCommand(doc.get(), layout.get(), block_index, on_top, &text_command));
    return text_command;
}
 
inline TextCommand TextCommand::ChangeListStyle(Document doc, CharIterator begin, CharIterator end, const PDTListLevelStyle& style) {
    TextCommand text_command;
    PDF_CHECK_SUCCESS_X(PDTCreateChangeListStyleCommand(doc.get(), begin.get(), end.get(), &style, &text_command));
    return text_command;
}
 
inline TextCommand TextCommand::ChangeListLevel(Document doc, CharIterator begin, CharIterator end, int change) {
    TextCommand text_command;
    PDF_CHECK_SUCCESS_X(PDTCreateChangeListLevelCommand(doc.get(), begin.get(), end.get(), change, &text_command));
    return text_command;
}
 
inline void TextCommand::Redo() {
    PDF_CHECK_SUCCESS_X(PDTTextCommandDo(m_handle));
}
 
inline void TextCommand::Undo() {
    PDF_CHECK_SUCCESS_X(PDTTextCommandUndo(m_handle));
}
 
inline bool TextCommand::IsFontSubstituted() const {
    bool fontSubstituted = false;
    PDF_CHECK_SUCCESS_X(PDTTextCommandIsFontSubstituted(m_handle, &fontSubstituted));
    return fontSubstituted;
}
 
}  // namespace TextEdit
}  // namespace PDF
 
#endif  // PDFSDK_CXX_TEXT_EDIT_H_INCLUDED_