/****************************************************************************
**
** Copyright (C) 2015 The Qt Company Ltd.
** Contact: http://www.qt.io/licensing/
**
** This file is part of the documentation of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:FDL$
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and The Qt Company. For licensing terms
** and conditions see http://www.qt.io/terms-conditions. For further
** information use the contact form at http://www.qt.io/contact-us.
**
** GNU Free Documentation License Usage
** Alternatively, this file may be used under the terms of the GNU Free
** Documentation License version 1.3 as published by the Free Software
** Foundation and appearing in the file included in the packaging of
** this file. Please review the following information to ensure
** the GNU Free Documentation License version 1.3 requirements
** will be met: http://www.gnu.org/copyleft/fdl.html.
** $QT_END_LICENSE$
**
****************************************************************************/

/*!
    \group richtext-processing
    \brief How to use Rich Text Processing APIs.
    \title Rich Text Processing APIs
*/

/*!
    \page richtext.html
    \title Rich Text Processing
    \brief An overview of Qt's rich text processing, editing and display features.

    \ingroup frameworks-technologies
    \ingroup qt-basic-concepts
    \ingroup best-practices

    \nextpage Rich Text Document Structure

    The Scribe framework provides a set of classes for reading and manipulating
    structured rich text documents. Unlike previous rich text support in Qt, the
    new classes are centered around the QTextDocument class rather than raw
    textual information. This enables the developer to create and modify
    structured rich text documents without having to prepare content in an
    intermediate markup format.

    The information within a document can be accessed via two complementary
    interfaces: A cursor-based interface is used for editing, and a read-only
    hierarchical interface provides a high level overview of the document
    structure. The main advantage of the cursor-based interface is that the
    text can be edited using operations that mimic a user's interaction with
    an editor, without losing the underlying structure of the document. The
    read-only hierarchical interface is most useful when performing operations
    such as searching and document export.

    This document is divided up into chapters for convenient reference:

    \list
    \li \l{Rich Text Document Structure} outlines
       the different kinds of elements in a QTextDocument, and describes how
       they are arranged in a document structure.
    \li \l{The QTextCursor Interface} explains how rich
       text documents can be edited using the cursor-based interface.
    \li \l{Document Layouts} briefly explains the role of document layouts.
    \li \l{Common Rich Text Editing Tasks} examines some
       common tasks that involve reading or manipulating rich text documents.
    \li \l{Advanced Rich Text Processing} examines advanced rich text editing tasks.
    \li \l{Supported HTML Subset} lists the HTML tags supported by QTextDocument.
    \endlist

    \section1 Rich Text Processing APIs

    Qt provides an extensive collection of classes for parsing, rendering
    manipulating and editing rich text.

    \annotatedlist richtext-processing
*/

/*!
    \page richtext-structure.html
    \contentspage richtext.html Contents
    \previouspage Rich Text Processing
    \nextpage The QTextCursor Interface

    \title Rich Text Document Structure

    \tableofcontents

    Text documents are represented by the QTextDocument class, which
    contains information about the document's internal representation, its
    structure, and keeps track of modifications to provide undo/redo
    facilities.

    The structured representation of a text document presents its contents as
    a hierarchy of text blocks, frames, tables, and other objects. These provide
    a logical structure to the document and describe how their contents will be
    displayed. Generally, frames and tables are used to group other
    structures while text blocks contain the actual textual information.

    New elements are created and inserted into the document programmatically
    \l{richtext-cursor.html}{with a QTextCursor} or by using an editor
    widget, such as QTextEdit. Elements can be given a particular format when
    they are created; otherwise they take the cursor's current format for the
    element.

    \table
    \row
    \li \inlineimage richtext-document.png
    \li \b{Basic structure}

    The "top level" of a document might be populated in the way shown.
    Each document always contains a root frame, and this always contains
    at least one text block.

    For documents with some textual content, the root
    frame usually contains a sequence of blocks and other elements.

    Sequences of frames and tables are always separated by text blocks in a
    document, even if the text blocks contain no information. This ensures that
    new elements can always be inserted between existing structures.
    \endtable

    In this chapter, we look at each of the structural elements
    used in a rich text document, outline their features and uses, and show
    how to examine their contents. Document editing is described in
    \l{richtext-cursor.html}{The QTextCursor Interface}.

    \section1 Rich Text Documents

    QTextDocument objects contain all the information required to construct
    rich text documents.
    Text documents can be accessed in two complementary ways: as a linear
    buffer for editors to use, and as an object hierarchy that is useful to
    layout engines.
    In the hierarchical document model, objects generally correspond to
    visual elements such as frames, tables, and lists. At a lower level,
    these elements describe properties such as the text style and alignment.
    The linear representation of the document is used for editing and
    manipulation of the document's contents.

    Although QTextEdit makes it easy to display and edit rich text, documents
    can also be used independently of any editor widget, for example:

    \snippet code/doc_src_richtext.cpp 0

    Alternatively, they can be extracted from an existing editor:

    \snippet code/doc_src_richtext.cpp 1

    This flexibility enables applications to handle multiple rich text
    documents without the overhead of multiple editor widgets, or requiring
    documents to be stored in some intermediate format.

    An empty document contains a root frame which itself contains a single
    empty text block. Frames provide logical separation between parts of the document, but
    also have properties that determine how they will appear when rendered.
    A table is a specialized type of frame that consists of a number of
    cells, arranged into rows and columns, each of which can contain
    further structure and text. Tables provide management and layout
    features that allow flexible configurations of cells to be created.

    Text blocks contain text fragments, each of which specifies text and
    character format information. Textual properties are defined both at
    the character level and at the block level. At the character level,
    properties such as font family, text color, and font weight can be
    specified. The block level properties control the higher level
    appearance and behavior of the text, such as the direction of text
    flow, alignment, and background color.

    The document structure is not manipulated directly. Editing is
    performed through a cursor-based interface.
    The \l{richtext-cursor.html}{text cursor interface}
    automatically inserts new document elements into the root frame, and
    ensures that it is padded with empty blocks where necessary.

    We obtain the root frame in the following manner:

    \snippet textdocument-frames/xmlwriter.h 0
    \snippet textdocument-frames/xmlwriter.cpp 0

    When navigating the document structure, it is useful to begin at the
    root frame because it provides access to the entire document structure.


    \section1 Document Elements

    Rich text documents usually consist of common elements such as paragraphs,
    frames, tables, and lists. These are represented in a QTextDocument
    by the QTextBlock, QTextFrame, QTextTable, and QTextList classes.
    Unlike the other elements in a document, images are represented by
    specially formatted text fragments. This enables them to be placed
    formatted inline with the surrounding text.

    The basic structural building blocks in documents are QTextBlock and
    QTextFrame. Blocks themselves contain fragments of rich text
    (QTextFragment), but these do not directly influence the high level
    structure of a document.

    Elements which can group together other document elements are typically
    subclasses of QTextObject, and fall into two categories: Elements that
    group together text blocks are subclasses of QTextBlockGroup, and those
    that group together frames and other elements are subclasses of QTextFrame.

    \section2 Text Blocks

    Text blocks are provided by the QTextBlock class.

    Text blocks group together fragments of text with different character formats,
    and are used to represent paragraphs in the document. Each block
    typically contains a number of text fragments with different styles.
    Fragments are created when text is inserted into the document, and more
    of them are added when the document is edited. The document splits, merges,
    and removes fragments to efficiently represent the different styles
    of text in the block.

    The fragments within a given block can be examined by using a
    QTextBlock::iterator to traverse the block's internal structure:

    \snippet textblock-fragments/xmlwriter.cpp 3
    \snippet textblock-fragments/xmlwriter.cpp 5
    \snippet textblock-fragments/xmlwriter.cpp 6

    Blocks are also used to represent list items. As a result, blocks can
    define their own character formats which contain information about
    block-level decoration, such as the type of bullet points used for
    list items. The formatting for the block itself is described by the
    QTextBlockFormat class, and describes properties such as text alignment,
    indentation, and background color.

    Although a given document may contain complex structures, once we have a
    reference to a valid block in the document, we can navigate between each
    of the text blocks in the order in which they were written:

    \snippet textblock-fragments/xmlwriter.cpp 0
    \snippet textblock-fragments/xmlwriter.cpp 1
    \snippet textblock-fragments/xmlwriter.cpp 2

    This method is useful for when you want to extract just the rich text from a
    document because it ignores frames, tables, and other types of structure.

    QTextBlock provides comparison operators that make it easier to manipulate
    blocks: \l{QTextBlock::operator==()}{operator==()} and
    \l{QTextBlock::operator!=()}{operator!=()} are used to test whether two
    blocks are the same, and \l{QTextBlock::operator<()}{operator<()} is used
    to determine which one occurs first in a document.

    \section2 Frames

    Frames are provided by the QTextFrame class.

    Text frames group together blocks of text and child frames, creating
    document structures that are larger than paragraphs. The format of a frame
    specifies how it is rendered and positioned on the page. Frames are
    either inserted into the text flow, or they float on the left or right
    hand side of the page.
    Each document contains a root frame that contains all the other document
    elements. As a result, all frames except the root frame have a parent
    frame.

    Since text blocks are used to separate other document elements, each
    frame will always contain at least one text block, and zero or more
    child frames. We can inspect the contents of a frame by using a
    QTextFrame::iterator to traverse the frame's child elements:

    \snippet textdocument-frames/xmlwriter.cpp 1
    \snippet textdocument-frames/xmlwriter.cpp 2

    Note that the iterator selects both frames and blocks, so it is necessary
    to check which it is referring to. This allows us to navigate the document
    structure on a frame-by-frame basis yet still access text blocks if
    required. Both the QTextBlock::iterator and QTextFrame::iterator classes
    can be used in complementary ways to extract the required structure from
    a document.

    \section2 Tables

    Tables are provided by the QTextTable class.

    Tables are collections of cells that are arranged in rows and columns.
    Each table cell is a document element with its own character format, but it
    can also contain other elements, such as frames and text blocks. Table cells
    are automatically created when the table is constructed, or when extra rows
    or columns are added. They can also be moved between tables.

    QTextTable is a subclass of QTextFrame, so tables are treated like frames
    in the document structure. For each frame that we encounter in the
    document, we can test whether it represents a table, and deal with it in a
    different way:

    \snippet textdocument-tables/xmlwriter.cpp 0
    \snippet textdocument-tables/xmlwriter.cpp 1

    The cells within an existing table can be examined by iterating through
    the rows and columns.

    \snippet textdocument-tables/mainwindow.cpp 9
    \snippet textdocument-tables/mainwindow.cpp 10
    \snippet textdocument-tables/mainwindow.cpp 11
    \snippet textdocument-tables/mainwindow.cpp 12


    \section2 Lists

    Lists are provided by the QTextList class.

    Lists are sequences of text blocks that are formatted in the usual way, but
    which also provide the standard list decorations such as bullet points and
    enumerated items. Lists can be nested, and will be indented if the list's
    format specifies a non-zero indentation.

    We can refer to each list item by its index in the list:

    \snippet textdocument-listitems/mainwindow.cpp 0
    \snippet textdocument-listitems/mainwindow.cpp 1
    \snippet textdocument-listitems/mainwindow.cpp 2

    Since QTextList is a subclass of QTextBlockGroup, it does not group the
    list items as child elements, but instead provides various functions for
    managing them. This means that any text block we find when traversing a
    document may actually be a list item. We can ensure that list items are
    correctly identified by using the following code:

    \snippet textdocument-listitems/mainwindow.cpp 3
    \snippet textdocument-listitems/mainwindow.cpp 4
    \snippet textdocument-listitems/mainwindow.cpp 5
    \snippet textdocument-listitems/mainwindow.cpp 6
    \snippet textdocument-listitems/mainwindow.cpp 7


    \section2 Images

    Images in QTextDocument are represented by text fragments that reference
    external images via the resource mechanism. Images are created using the
    cursor interface, and can be modified later by changing the character
    format of the image's text fragment:

    \snippet textdocument-imageformat/main.cpp 0
    \snippet textdocument-imageformat/main.cpp 1
    \snippet textdocument-imageformat/main.cpp 2

    The fragment that represents the image can be found by iterating over
    the fragments in the text block that contains the image.
*/

/*!
    \page richtext-cursor.html
    \contentspage richtext.html Contents
    \previouspage Rich Text Document Structure
    \nextpage Document Layouts

    \title The QTextCursor Interface

    \tableofcontents

    Documents can be edited via the interface provided by the QTextCursor
    class; cursors are either created using a constructor or obtained from
    an editor widget. The cursor is used to perform editing operations that
    correspond exactly to those the user is able to make themselves in an
    editor. As a result, information about the document structure is also
    available through the cursor, and this allows the structure to be
    modified. The use of a cursor-oriented interface for editing makes the
    process of writing a custom editor simpler for developers, since the
    editing operations can be easily visualized.

    The QTextCursor class also maintains information about any text it
    has selected in the document, again following a model that is
    conceptually similar to the actions made by the user to select text
    in an editor.

    Rich text documents can have multiple cursors
    associated with them, and each of these contains information about their
    position in the document and any selections that they may hold. This
    cursor-based paradigm makes common operations, such as cutting and pasting
    text, simple to implement programmatically, yet it also allows more complex
    editing operations to be performed on the document.

    This chapter describes most of the common editing operations that you
    will need to perform using a cursor, from basic insertion of text and
    document elements to more complex manipulation of document structures.

    \section1 Cursor-Based Editing

    At the simplest level, text documents are made up of a string of characters,
    marked up in some way to represent the block structure of the text within the
    document. QTextCursor provides a cursor-based interface that allows the
    contents of a QTextDocument to be manipulated at the character level. Since
    the elements (blocks, frames, tables, etc.) are also encoded in the character
    stream, the document structure can itself be changed by the cursor.

    The cursor keeps track of its location within its parent document, and can
    report information about the surrounding structure, such as the enclosing
    text block, frame, table, or list. The formats of the enclosing structures
    can also be directly obtained through the cursor.

    \section2 Using a Cursor

    The main use of a cursor is to insert or modify text within a block.
    We can use a text editor's cursor to do this:

    \snippet textblock-formats/main.cpp 0

    Alternatively, we can obtain a cursor directly from a document:

    \snippet textdocument-images/main.cpp 0

    The cursor is positioned at the start of the document so that we can write
    into the first (empty) block in the document.

    \section2 Grouping Cursor Operations

    A series of editing operations can be packaged together so that they can
    be replayed, or undone together in a single action. This is achieved by
    using the \c beginEditBlock() and \c endEditBlock() functions in the
    following way, as in the following example where we select the word that
    contains the cursor:

    \snippet textdocument-selections/mainwindow.cpp 0

    If editing operations are not grouped, the document automatically records
    the individual operations so that they can be undone later. Grouping
    operations into larger packages can make editing more efficient both for
    the user and for the application, but care has to be taken not to group too
    many operations together as the user may want find-grained control over the
    undo process.

    \section2 Multiple Cursors

    Multiple cursors can be used to simultaneously edit the same document,
    although only one will be visible to the user in a QTextEdit widget.
    The QTextDocument ensures that each cursor writes text correctly and
    does not interfere with any of the others.

    \omit
    \snippet textdocument-cursors/main.cpp 0
    \snippet textdocument-cursors/main.cpp 1
    \endomit

    \section1 Inserting Document Elements

    QTextCursor provides several functions that can be used to change the
    structure of a rich text document. Generally, these functions allow
    document elements to be created with relevant formatting information,
    and they are inserted into the document at the cursor's position.

    The first group of functions insert block-level elements, and update the
    cursor position, but they do not return the element that was inserted:

    \list
    \li \l{QTextCursor::insertBlock()}{insertBlock()} inserts a new text block
       (paragraph) into a document at the cursor's position, and moves the
       cursor to the start of the new block.
    \li \l{QTextCursor::insertFragment()}{insertFragment()} inserts an existing
       text fragment into a document at the cursor's position.
    \li \l{QTextCursor::insertImage()}{insertImage()} inserts an image into a
       document at the cursor's position.
    \li \l{QTextCursor::insertText()}{insertText()} inserts text into the
       document at the cursor's position.
    \endlist

    You can examine the contents of the element that was inserted through the
    cursor interface.

    The second group of functions insert elements that provide structure to
    the document, and return the structure that was inserted:

    \list
    \li \l{QTextCursor::insertFrame()}{insertFrame()} inserts a frame into the
       document \e after the cursor's current block, and moves the cursor to
       the start of the empty block in the new frame.
    \li \l{QTextCursor::insertList()}{insertList()} inserts a list into the
       document at the cursor's position, and moves the cursor to the start
       of the first item in the list.
    \li \l{QTextCursor::insertTable()}{insertTable()} inserts a table into
       the document \e after the cursor's current block, and moves the cursor
       to the start of the block following the table.
    \endlist

    These elements either contain or group together other elements in the
    document.

    \section2 Text and Text Fragments

    Text can be inserted into the current block in the current character
    format, or in a custom format that is specified with the text:

    \snippet textdocument-charformats/main.cpp 0

    Once the character format has been used with a cursor, that format becomes
    the default format for any text inserted with that cursor until another
    character format is specified.

    If a cursor is used to insert text without specifying a character format,
    the text will be given the character format used at that position in the
    document.

    \section2 Blocks

    Text blocks are inserted into the document with the
    \l{QTextCursor::insertBlock()}{insertBlock()} function.

    \snippet textblock-formats/main.cpp 1

    The cursor is positioned at the start of the new block.

    \section2 Frames

    Frames are inserted into a document using the cursor, and will be placed
    within the cursor's current frame \e after the current block.
    The following code shows how a frame can be inserted between two text
    blocks in a document's root frame. We begin by finding the cursor's
    current frame:

    \snippet textdocument-frames/mainwindow.cpp 0

    We insert some text in this frame then set up a frame format for the
    child frame:

    \snippet textdocument-frames/mainwindow.cpp 1

    The frame format will give the frame an external margin of 32 pixels,
    internal padding of 8 pixels, and a border that is 4 pixels wide.
    See the QTextFrameFormat documentation for more information about
    frame formats.

    The frame is inserted into the document after the preceding text:

    \snippet textdocument-frames/mainwindow.cpp 2

    We add some text to the document immediately after we insert the frame.
    Since the text cursor is positioned \e{inside the frame} when it is inserted
    into the document, this text will also be inserted inside the frame.

    Finally, we position the cursor outside the frame by taking the last
    available cursor position inside the frame we recorded earlier:

    \snippet textdocument-frames/mainwindow.cpp 3

    The text that we add last is inserted after the child frame in the
    document. Since each frame is padded with text blocks, this ensures that
    more elements can always be inserted with a cursor.

    \section2 Tables

    Tables are inserted into the document using the cursor, and will be
    placed within the cursor's current frame \e after the current block:

    \snippet textdocument-tables/mainwindow.cpp 0
    \snippet textdocument-tables/mainwindow.cpp 3

    Tables can be created with a specific format that defines the overall
    properties of the table, such as its alignment, background color, and
    the cell spacing used. It can also determine the constraints on each
    column, allowing each of them to have a fixed width, or resize according
    to the available space.

    \snippet textdocument-tables/mainwindow.cpp 2

    The columns in the table created above will each take up a certain
    percentage of the available width. Note that the table format is
    optional; if you insert a table without a format, some sensible
    default values will be used for the table's properties.

    Since cells can contain other document elements, they too can be
    formatted and styled as necessary.

    Text can be added to the table by navigating to each cell with the cursor
    and inserting text.

    \snippet textdocument-tables/mainwindow.cpp 4

    We can create a simple timetable by following this approach:

    \snippet textdocument-tables/mainwindow.cpp 5
    \snippet textdocument-tables/mainwindow.cpp 6
    \snippet textdocument-tables/mainwindow.cpp 7
    \snippet textdocument-tables/mainwindow.cpp 8

    \section2 Lists

    Lists of block elements can be automatically created and inserted into the
    document at the current cursor position. Each list that is created in this
    way requires a list format to be specified:

    \snippet textdocument-lists/mainwindow.cpp 0

    The above code first checks whether the cursor is within an existing list
    and, if so, gives the list format for the new list a suitable level of
    indentation. This allows nested lists to be created with increasing
    levels of indentation. A more sophisticated implementation would also use
    different kinds of symbol for the bullet points in each level of the list.

    \section2 Images

    Inline images are added to documents through the cursor in the usual manner.
    Unlike many other elements, all of the image properties are specified by the
    image's format. This means that a QTextImageFormat object has to be
    created before an image can be inserted:

    \snippet textdocument-images/main.cpp 1

    The image name refers to an entry in the application's resource file.
    The method used to derive this name is described in
    \l{resources.html}{The Qt Resource System}.

    \section1 Examples

    Rich text is stored in text documents that can either be created by
    importing HTML from an external source, or generated using a QTextCursor.

    \section2 Manipulating Rich Text

    The easiest way to use a rich text document is through
    the QTextEdit class, providing an editable view onto a document. The code
    below imports HTML into a document, and displays the document using a
    text edit widget.

    \snippet scribe-overview/main.cpp 1

    You can retrieve the document from the text edit using the
    document() function. The document can then be edited programmatically
    using the QTextCursor class. This class is modeled after a screen
    cursor, and editing operations follow the same semantics. The following
    code changes the first line of the document to a bold font, leaving all
    other font properties untouched. The editor will be automatically
    updated to reflect the changes made to the underlying document data.

    \snippet scribe-overview/main.cpp 0

    Note that the cursor was moved from the start of the first line to the
    end, but that it retained an anchor at the start of the line. This
    demonstrates the cursor-based selection facilities of the
    QTextCursor class.

    \section2 Generating a Calendar

    Rich text can be generated very quickly using the cursor-based
    approach. The following example shows a simple calendar in a
    QTextEdit widget with bold headers for the days of the week:

    \snippet textdocument-blocks/mainwindow.cpp 0
    \codeline
    \snippet textdocument-blocks/mainwindow.cpp 1
    \snippet textdocument-blocks/mainwindow.cpp 2
    \snippet textdocument-blocks/mainwindow.cpp 3

    The above example demonstrates how simple it is to quickly generate new
    rich text documents using a minimum amount of code. Although we have
    generated a crude fixed-pitch calendar to avoid quoting too much code,
    Scribe provides much more sophisticated layout and formatting features.
*/

/*!
    \page richtext-layouts.html
    \contentspage richtext.html Contents
    \previouspage The QTextCursor Interface
    \nextpage Common Rich Text Editing Tasks

    \title Document Layouts

    \tableofcontents

    The layout of a document is only relevant when it is to be displayed on
    a device, or when some information is requested that requires a visual
    representation of the document. Until this occurs, the document does
    not need to be formatted and prepared for a device.

    \section1 Overview

    Each document's layout is managed by a subclass of the
    QAbstractTextDocumentLayout class. This class provides a common
    interface for layout and rendering engines. The default rendering
    behavior is currently implemented in a private class. This approach
    makes it possible to create custom layouts, and provides the
    mechanism used when preparing pages for printing or exporting to
    Portable Document Format (PDF) files.

    \section1 Example - Shaped Text Layout

    Sometimes it is important to be able to format plain text within an
    irregularly-shaped region, perhaps when rendering a custom widget, for
    example. Scribe provides generic features, such as those provided by
    the QTextLayout class, to help developers perform word-wrapping and
    layout tasks without the need to create a document first.

    \image plaintext-layout.png

    Formatting and drawing a paragraph of plain text is straightforward.
    The example below will lay out a paragraph of text, using a single
    font, around the right hand edge of a circle.

    \snippet plaintextlayout/window.cpp 0

    We create a text layout, specifying the text string we want to display
    and the font to use. We ensure that the text we supplied is formatted
    correctly by obtaining text lines from the text format, and wrapping
    the remaining text using the available space. The lines are positioned
    as we move down the page.

    The formatted text can be drawn onto a paint device; in the above code,
    the text is drawn directly onto a widget.
    */

    /*!
    \page richtext-common-tasks.html
    \contentspage richtext.html Contents
    \previouspage Document Layouts
    \nextpage Advanced Rich Text Processing

    \title Common Rich Text Editing Tasks

    \tableofcontents

    There are a number of tasks that are often performed by developers
    when editing and processing text documents using Qt. These include the use
    of display widgets such as QTextBrowser and QTextEdit, creation of
    documents with QTextDocument, editing using a QTextCursor, and
    exporting the document structure.
    This document outlines some of the more common ways of using the rich
    text classes to perform these tasks, showing convenient patterns that can
    be reused in your own applications.

    \section1 Using QTextEdit

    A text editor widget can be constructed and used to display HTML in the
    following way:

    \snippet code/doc_src_richtext.cpp 2

    By default, the text editor contains a document with a root frame, inside
    which is an empty text block. This document can be obtained so that it can
    be modified directly by the application:

    \snippet code/doc_src_richtext.cpp 3

    The text editor's cursor may also be used to edit a document:

    \snippet code/doc_src_richtext.cpp 4

    Although a document can be edited using many cursors at once, a QTextEdit
    only displays a single cursor at a time. Therefore, if we want to update the
    editor to display a particular cursor or its selection, we need to set the
    editor's cursor after we have modified the document:

    \snippet code/doc_src_richtext.cpp 5

    \section1 Selecting Text

    Text is selected by moving the cursor using operations that are similar to
    those performed by a user in a text editor. To select text between two
    points in the document, we need to position the cursor at the first point
    then move it using a special mode (\l{QTextCursor::MoveMode}) with a
    move operation (\l{QTextCursor::MoveOperation}).
    When we select the text, we leave the selection anchor at the old cursor
    position just as the user might do by holding down the Shift key when
    selecting text:

    \snippet textdocument-selections/mainwindow.cpp 1

    In the above code, a whole word is selected using this method. QTextCursor
    provides a number of common move operations for selecting individual
    characters, words, lines, and whole blocks.

    \section1 Finding Text

    QTextDocument provides a cursor-based interface for searching, making
    it easy to find and modify text in the style of a text editor. The following
    code finds all the instances of a particular word in a document, and changes
    the color of each:

    \snippet textdocument-find/main.cpp 0
    \snippet textdocument-find/main.cpp 1

    Note that the cursor does not have to be moved after each search and replace
    operation; it is always positioned at the end of the word that was just
    replaced.

    \section1 Printing Documents

    QTextEdit is designed for the display of large rich text documents that are
    read on screen, rendering them in the same way as a web browser. As a result,
    it does not automatically break the contents of the document into page-sized
    pieces that are suitable for printing.

    QTextDocument provides a \l{QTextDocument::print()}{print()} function to
    allow documents to be printed using the QPrinter class. The following code
    shows how to prepare a document in a QTextEdit for printing with a QPrinter:

    \snippet textdocument-printing/mainwindow.cpp 0

    The document is obtained from the text editor, and a QPrinter is constructed
    then configured using a QPrintDialog. If the user accepts the printer's
    configuration then the document is formatted and printed using the
    \l{QTextDocument::print()}{print()} function.
*/

/*!
    \page richtext-advanced-processing.html
    \contentspage richtext.html Contents
    \previouspage Common Rich Text Editing Tasks
    \nextpage Supported HTML Subset

    \title Advanced Rich Text Processing

    \section1 Handling Large Files

    Qt does not limit the size of files that are used for text
    processing.  In most cases, this will not present a problem. For
    especially large files, however, you might experience that your
    application will become unresponsive or that you will run out of
    memory. The size of the files you can load depends on your
    hardware and on Qt's and your own application's implementation.

    If you are faced with this problem, we recommend that you address the
    following issues:

    \list
        \li You should consider breaking up large paragraphs into smaller
           ones as Qt handles small paragraphs better. You could also
           insert line breaks at regular intervals, which will look the
           same as one large paragraph in a QTextEdit.
        \li You can reduce the amount of blocks in a QTextDocument with
           \l{QTextDocument::}{maximumBlockCount()}. The document is only
           as large as the number of blocks as far as QTextEdit is concerned.
        \li When adding text to a text edit, it is an advantage to add it
           in an edit block (see example below). The result is that the
           text edit does not need to build the entire document structure at once.
    \endlist

    We give an example of the latter technique from the list. We assume that
    the text edit is visible.

    \snippet code/doc_src_richtext.cpp 6

    \omit
    Ideas for other sections:

     * Hiding QTextBlock elements.
     * Changing the word wrapping mode in QTextEdit. Custom word wrapping?
    \endomit
*/

/*!
    \page richtext-html-subset.html
    \title Supported HTML Subset
    \brief Describes the support for HTML markup in text widgets.

    \contentspage richtext.html Contents
    \previouspage Common Rich Text Editing Tasks

    Qt's text widgets are able to display rich text, specified using a subset of \l {http://www.w3.org/TR/html401/}{HTML 4}
    markup. Widgets that use QTextDocument, such as QLabel and QTextEdit, are able to display
    rich text specified in this way.

    \tableofcontents

    \section1 Using HTML Markup in Text Widgets

    Widgets automatically detect HTML markup and display rich text accordingly. For example,
    setting a label's \l{QLabel::}{text} property with the string \c{"<b>Hello</b> <i>Qt!</i>"}
    will result in the label displaying text like this: \b{Hello} \e{Qt!}

    When HTML markup is used for text, Qt follows the rules defined by the \l{http://www.w3.org/TR/html401/}{HTML 4}
    specification. This includes default properties for text layout, such as the
    direction of the text flow (left-to-right) which can be changed by applying the
    \l{#Block Attributes}{\c dir} attribute to blocks of text.

    \section1 Supported Tags

    The following table lists the HTML tags supported by Qt's
    \l{Rich Text Processing}{rich text} engine:

    \table 70%
    \header \li Tag
            \li Description
            \li Comment
    \row    \li \c a
            \li Anchor or link
            \li Supports the \c href and \c name attributes.
    \row    \li \c address
            \li Address
            \li
    \row    \li \c b
            \li Bold
            \li
    \row    \li \c big
            \li Larger font
            \li
    \row    \li \c blockquote
            \li Indented paragraph
            \li
    \row    \li \c body
            \li Document body
            \li Supports the \c bgcolor attribute, which
               can be a Qt \l{QColor::setNamedColor()}{color name}
               or a \c #RRGGBB color specification.
    \row    \li \c br
            \li Line break
            \li
    \row    \li \c center
            \li Centered paragraph
            \li
    \row    \li \c cite
            \li Inline citation
            \li Same as \c i.
    \row    \li \c code
            \li Code
            \li Same as \c tt.
    \row    \li \c dd
            \li Definition data
            \li
    \row    \li \c dfn
            \li Definition
            \li Same as \c i.
    \row    \li \c div
            \li Document division
            \li Supports the standard \l{block attributes}.
    \row    \li \c dl
            \li Definition list
            \li Supports the standard \l{block attributes}.
    \row    \li \c dt
            \li Definition term
            \li Supports the standard \l{block attributes}.
    \row    \li \c em
            \li Emphasized
            \li Same as \c i.
    \row    \li \c font
            \li Font size, family, and/or color
            \li Supports the following attributes:
               \c size, \c face, and \c color (Qt
               \l{QColor::setNamedColor()}{color names} or
               \c #RRGGBB).
    \row    \li \c h1
            \li Level 1 heading
            \li Supports the standard \l{block attributes}.
    \row    \li \c h2
            \li Level 2 heading
            \li Supports the standard \l{block attributes}.
    \row    \li \c h3
            \li Level 3 heading
            \li Supports the standard \l{block attributes}.
    \row    \li \c h4
            \li Level 4 heading
            \li Supports the standard \l{block attributes}.
    \row    \li \c h5
            \li Level 5 heading
            \li Supports the standard \l{block attributes}.
    \row    \li \c h6
            \li Level 6 heading
            \li Supports the standard \l{block attributes}.
    \row    \li \c head
            \li Document header
            \li
    \row    \li \c hr
            \li Horizontal line
            \li Supports the \c width attribute, which can
               be specified as an absolute or relative (\c %) value.
    \row    \li \c html
            \li HTML document
            \li
    \row    \li \c i
            \li Italic
            \li
    \row    \li \c img
            \li Image
            \li Supports the \c src, \c source
               (for Qt 3 compatibility), \c width, and \c height
               attributes.
    \row    \li \c kbd
            \li User-entered text
            \li
    \row    \li \c meta
            \li Meta-information
            \li If a text encoding is specified using the \c{meta} tag,
               it is picked up by Qt::codecForHtml().
               Likewise, if an encoding is specified to
               QTextDocument::toHtml(), the encoding is stored using
               a \c meta tag, for example:

    \snippet code/doc_src_richtext.qdoc 7

    \row    \li \c li
            \li List item
            \li
    \row    \li \c nobr
            \li Non-breakable text
            \li
    \row    \li \c ol
            \li Ordered list
            \li Supports the standard \l{list attributes}.
    \row    \li \c p
            \li Paragraph
            \li Left-aligned by default. Supports the standard
               \l{block attributes}.
    \row    \li \c pre
            \li Preformated text
            \li
    \row    \li \c qt
            \li Qt rich-text document
            \li Synonym for \c html. Provided for compatibility with
               earlier versions of Qt.
    \row    \li \c s
            \li Strikethrough
            \li
    \row    \li \c samp
            \li Sample code
            \li Same as \c tt.
    \row    \li \c small
            \li Small font
            \li
    \row    \li \c span
            \li Grouped elements
            \li
    \row    \li \c strong
            \li Strong
            \li Same as \c b.
    \row    \li \c sub
            \li Subscript
            \li
    \row    \li \c sup
            \li Superscript
            \li
    \row    \li \c table
            \li Table
            \li Supports the following attributes: \c border,
               \c bgcolor (Qt \l{QColor::setNamedColor()}{color names}
               or \c #RRGGBB), \c cellspacing, \c cellpadding,
               \c width (absolute or relative), and \c height.
    \row    \li \c tbody
            \li Table body
            \li Does nothing.
    \row    \li \c td
            \li Table data cell
            \li Supports the standard \l{table cell attributes}.
    \row    \li \c tfoot
            \li Table footer
            \li Does nothing.
    \row    \li \c th
            \li Table header cell
            \li Supports the standard \l{table cell attributes}.
    \row    \li \c thead
            \li Table header
            \li If the \c thead tag is specified, it is used when printing tables
               that span multiple pages.
    \row    \li \c title
            \li Document title
            \li The value specified using the \c
               title tag is available through
               QTextDocument::metaInformation().
    \row    \li \c tr
            \li Table row
            \li Supports the \c bgcolor attribute, which
               can be a Qt \l{QColor::setNamedColor()}{color name}
               or a \c #RRGGBB color specification.
    \row    \li \c tt
            \li Typewrite font
            \li
    \row    \li \c u
            \li Underlined
            \li
    \row    \li \c ul
            \li Unordered list
            \li Supports the standard \l{list attributes}.
    \row    \li \c var
            \li Variable
            \li Same as \c i.
    \endtable

    \section1 Block Attributes

    The following attributes are supported by the \c div, \c dl, \c
    dt, \c h1, \c h2, \c h3, \c h4, \c h5, \c h6, \c p tags:

    \list
    \li \c align (\c left, \c right, \c center, \c justify)
    \li \c dir (\c ltr, \c rtl)
    \endlist

    \section1 List Attributes

    The following attribute is supported by the \c ol and \c ul tags:

    \list
    \li \c type (\c 1, \c a, \c A, \c square, \c disc, \c circle)
    \endlist

    \section1 Table Cell Attributes

    The following attributes are supported by the \c td and \c th
    tags:

    \list
    \li \c width (absolute, relative, or no-value)
    \li \c bgcolor (Qt \l{QColor::setNamedColor()}{color names} or \c #RRGGBB)
    \li \c colspan
    \li \c rowspan
    \li \c align (\c left, \c right, \c center, \c justify)
    \li \c valign (\c top, \c middle, \c bottom)
    \endlist

    \section1 CSS Properties
    The following table lists the CSS properties supported by Qt's
    \l{Rich Text Processing}{rich text} engine:

    \table
    \header \li Property
            \li Values
            \li Description
    \row
            \li \c background-color
            \li <color>
            \li Background color for elements
    \row
            \li \c background-image
            \li <uri>
            \li Background image for elements
    \row    \li \c color
            \li <color>
            \li Text foreground color
    \row    \li \c font-family
            \li <family name>
            \li Font family name
    \row    \li \c font-size
            \li [ small | medium | large | x-large | xx-large ] | <size>pt | <size>px
            \li Font size relative to the document font, or specified in points or pixels
    \row    \li \c font-style
            \li [ normal | italic | oblique ]
            \li
    \row    \li \c font-weight
            \li [ normal | bold | 100 | 200 | 300 | 400 | 500 | 600 | 700 | 800 | 900 ]
            \li Specifies the font weight used for text, where \c normal and \c bold
               are mapped to the corresponding QFont weights. Numeric values are
               8 times the equivalent QFont weight values.
    \row    \li \c text-decoration
            \li none | [ underline || overline || line-through ]
            \li Additional text effects
    \row    \li \c font
            \li [ [ <'font-style'> || <'font-weight'> ]? <'font-size'> <'font-family'> ]
            \li Font shorthand property
    \row    \li \c text-indent
            \li <length>px
            \li First line text indentation in pixels
    \row    \li \c white-space
            \li normal | pre | nowrap | pre-wrap
            \li Declares how whitespace in HTML is handled.
    \row    \li \c margin-top
            \li <length>px
            \li Top paragraph margin in pixels
    \row    \li \c margin-bottom
            \li <length>px
            \li Bottom paragraph margin in pixels
    \row    \li \c margin-left
            \li <length>px
            \li Left paragraph margin in pixels
    \row    \li \c margin-right
            \li <length>px
            \li Right paragraph margin in pixels
    \row    \li \c padding-top
            \li <length>px
            \li Top table cell padding in pixels
    \row    \li \c padding-bottom
            \li <length>px
            \li Bottom table cell padding in pixels
    \row    \li \c padding-left
            \li <length>px
            \li Left table cell padding in pixels
    \row    \li \c padding-right
            \li <length>px
            \li Right table cell padding in pixels
    \row    \li \c padding
            \li <length>px
            \li Shorthand for setting all the padding properties at once.
    \row    \li \c vertical-align
            \li baseline | sub | super | middle | top | bottom
            \li Vertical text alignment. For vertical alignment in text table cells only middle, top, and bottom apply.
    \row    \li \c border-color
            \li <color>
            \li Border color for text tables.
    \row    \li \c border-style
            \li none | dotted | dashed | dot-dash | dot-dot-dash | solid | double | groove | ridge | inset | outset
            \li Border style for text tables.
    \row    \li \c background
            \li [ <'background-color'> || <'background-image'> ]
            \li Background shorthand property
    \row    \li \c page-break-before
            \li [ auto | always ]
            \li Make it possible to enforce a page break before the paragraph/table
    \row    \li \c page-break-after
            \li [ auto | always ]
            \li Make it possible to enforce a page break after the paragraph/table
    \row    \li float
            \li [ left | right | none ]
            \li Specifies where an image or a text will be placed in another element. Note that the \c float property is
               only supported for tables and images.
    \row    \li \c text-transform
            \li [ uppercase | lowercase ]
            \li Select the transformation that will be performed on the text prior to displaying it.
    \row    \li \c font-variant
            \li small-caps
            \li Perform the smallcaps transformation on the text prior to displaying it.
    \row    \li \c word-spacing
            \li <width>px
            \li Specifies an alternate spacing between each word.
    \endtable

    \section1 Supported CSS Selectors

    All CSS 2.1 selector classes are supported except pseudo-class selectors such
    as \c{:first-child}, \c{:visited} and \c{:hover}.

*/
