/****************************************************************************
**
** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
** All rights reserved.
** Contact: Nokia Corporation (qt-info@nokia.com)
**
** This file is part of the documentation of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:LGPL$
** No Commercial Usage
** This file contains pre-release code and may not be distributed.
** You may use this file in accordance with the terms and conditions
** contained in the Technology Preview License Agreement accompanying
** this package.
**
** GNU Lesser General Public License Usage
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 2.1 as published by the Free Software
** Foundation and appearing in the file LICENSE.LGPL included in the
** packaging of this file.  Please review the following information to
** ensure the GNU Lesser General Public License version 2.1 requirements
** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
**
** In addition, as a special exception, Nokia gives you certain additional
** rights.  These rights are described in the Nokia Qt LGPL Exception
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
**
** If you have questions regarding the use of this file, please contact
** Nokia at qt-info@nokia.com.
**
**
**
**
**
**
**
**
** $QT_END_LICENSE$
**
****************************************************************************/

/*!
    \example richtext/syntaxhighlighter
    \title Syntax Highlighter Example

    The Syntax Highlighter example shows how to perform simple syntax
    highlighting by subclassing the QSyntaxHighlighter class.

    \image syntaxhighlighter-example.png

    The Syntax Highlighter application displays C++ files with custom
    syntax highlighting.

    The example consists of two classes:

    \list
        \o The \c Highlighter class defines and applies the
           highlighting rules.
        \o The \c MainWindow widget is the application's main window.
    \endlist

    We will first review the \c Highlighter class to see how you can
    customize the QSyntaxHighlighter class to fit your preferences,
    then we will take a look at the relevant parts of the \c
    MainWindow class to see how you can use your custom highlighter
    class in an application.

    \section1 Highlighter Class Definition

    \snippet examples/richtext/syntaxhighlighter/highlighter.h 0

    To provide your own syntax highlighting, you must subclass
    QSyntaxHighlighter, reimplement the \l
    {QSyntaxHighlighter::highlightBlock()}{highlightBlock()} function,
    and define your own highlighting rules.

    We have chosen to store our highlighting rules using a private
    struct: A rule consists of a QRegExp pattern and a QTextCharFormat
    instance. The various rules are then stored using a QVector.

    The QTextCharFormat class provides formatting information for
    characters in a QTextDocument specifying the visual properties of
    the text, as well as information about its role in a hypertext
    document. In this example, we will only define the font weight and
    color using the QTextCharFormat::setFontWeight() and
    QTextCharFormat::setForeground() functions.

    \section1 Highlighter Class Implementation

    When subclassing the QSyntaxHighlighter class you must pass the
    parent parameter to the base class constructor. The parent is the
    text document upon which the syntax highligning will be
    applied. In this example, we have also chosen to define our
    highlighting rules in the constructor:

    \snippet examples/richtext/syntaxhighlighter/highlighter.cpp 0
    \snippet examples/richtext/syntaxhighlighter/highlighter.cpp 1

    First we define a keyword rule which recognizes the most common
    C++ keywords. We give the \c keywordFormat a bold, dark blue
    font. For each keyword, we assign the keyword and the specified
    format to a HighlightingRule object and append the object to our
    list of rules.

    \snippet examples/richtext/syntaxhighlighter/highlighter.cpp 2
    \codeline
    \snippet examples/richtext/syntaxhighlighter/highlighter.cpp 4
    \codeline
    \snippet examples/richtext/syntaxhighlighter/highlighter.cpp 5

    Then we create a format that we will apply to Qt class names. The
    class names will be rendered with a dark magenta color and a bold
    style. We specify a string pattern that is actually a regular
    expression capturing all Qt class names. Then we assign the
    regular expression and the specified format to a HighlightingRule
    object and append the object to our list of rules.

    We also define highlighting rules for quotations and functions
    using the same approach: The patterns have the form of regular
    expressions and are stored in HighlightingRule objects with the
    associated format.

    \snippet examples/richtext/syntaxhighlighter/highlighter.cpp 3
    \codeline
    \snippet examples/richtext/syntaxhighlighter/highlighter.cpp 6

    The C++ language has two variations of comments: The single line
    comment (\c //) and the multiline comment (\c{/*...}\starslash). The single
    line comment can easily be defined through a highlighting rule
    similar to the previous ones. But the multiline comment needs
    special care due to the design of the QSyntaxHighlighter class.

    After a QSyntaxHighlighter object is created, its \l
    {QSyntaxHighlighter::highlightBlock()}{highlightBlock()} function
    will be called automatically whenever it is necessary by the rich
    text engine, highlighting the given text block. The problem
    appears when a comment spans several text blocks. We will take a
    closer look at how this problem can be solved when reviewing the
    implementation of the \c Highlighter::highlightBlock()
    function. At this point we only specify the multiline comment's
    color.

    \snippet examples/richtext/syntaxhighlighter/highlighter.cpp 7

    The highlightBlock() function is called automatically whenever it
    is necessary by the rich text engine, i.e. when there are text
    blocks that have changed.

    First we apply the syntax highlighting rules that we stored in the
    \c highlightingRules vector. For each rule (i.e. for each
    HighlightingRule object) we search for the pattern in the given
    textblock using the QString::indexOf() function. When the first
    occurrence of the pattern is found, we use the
    QRegExp::matchedLength() function to determine the string that
    will be formatted. QRegExp::matchedLength() returns the length of
    the last matched string, or -1 if there was no match.

    To perform the actual formatting the QSyntaxHighlighter class
    provides the \l {QSyntaxHighlighter::setFormat()}{setFormat()}
    function. This function operates on the text block that is passed
    as argument to the \c highlightBlock() function. The specified
    format is applied to the text from the given start position for
    the given length. The formatting properties set in the given
    format are merged at display time with the formatting information
    stored directly in the document. Note that the document itself
    remains unmodified by the format set through this function.

    This process is repeated until the last occurrence of the pattern
    in the current text block is found.

    \snippet examples/richtext/syntaxhighlighter/highlighter.cpp 8

    To deal with constructs that can span several text blocks (like
    the C++ multiline comment), it is necessary to know the end state
    of the previous text block (e.g. "in comment"). Inside your \c
    highlightBlock() implementation you can query the end state of the
    previous text block using the
    QSyntaxHighlighter::previousBlockState() function. After parsing
    the block you can save the last state using
    QSyntaxHighlighter::setCurrentBlockState().

    The \l
    {QSyntaxHighlighter::previousBlockState()}{previousBlockState()}
    function return an int value. If no state is set, the returned
    value is -1. You can designate any other value to identify any
    given state using the \l
    {QSyntaxHighlighter::setCurrentBlockState()}{setCurrentBlockState()}
    function. Once the state is set, the QTextBlock keeps that value
    until it is set again or until the corresponding paragraph of text
    is deleted.

    In this example we have chosen to use 0 to represent the "not in
    comment" state, and 1 for the "in comment" state. When the stored
    syntax highlighting rules are applied we initialize the current
    block state to 0.

    \snippet examples/richtext/syntaxhighlighter/highlighter.cpp 9

    If the previous block state was "in comment" (\c
    {previousBlockState() == 1}), we start the search for an end
    expression at the beginning of the text block. If the
    previousBlockState() returns 0, we start the search at the
    location of the first occurrence of a start expression.

    \snippet examples/richtext/syntaxhighlighter/highlighter.cpp 10
    \snippet examples/richtext/syntaxhighlighter/highlighter.cpp 11

    When an end expression is found, we calculate the length of the
    comment and apply the multiline comment format. Then we search for
    the next occurrence of the start expression and repeat the
    process.  If no end expression can be found in the current text
    block we set the current block state to 1, i.e. "in comment".

    This completes the \c Highlighter class implementation; it is now
    ready for use.

    \section1 MainWindow Class Definition

    Using a QSyntaxHighlighter subclass is simple; just provide your
    application with an instance of the class and pass it the document
    upon which you want the highlighting to be applied.

    \snippet examples/richtext/syntaxhighlighter/mainwindow.h 0

    In this example we declare a pointer to a \c Highlighter instance
    which we later will initialize in the private \c setupEditor()
    function.

    \section1 MainWindow Class Implementation

    The constructor of the main window is straight forward. We first
    set up the menus, then we initialize the editor and make it the
    central widget of the application. Finally we set the main
    window's title.

    \snippet examples/richtext/syntaxhighlighter/mainwindow.cpp 0

    We initialize and install the \c Highlighter object in the private
    setupEditor() convenience function:

    \snippet examples/richtext/syntaxhighlighter/mainwindow.cpp 1

    First we create the font we want to use in the editor, then we
    create the editor itself which is an instance of the QTextEdit
    class. Before we initialize the editor with the \c MainWindow
    class definition file, we create a \c Highlighter instance passing
    the editor's document as argument. This is the document that the
    highlighting will be applied to. Then we are done.

    A QSyntaxHighlighter object can only be installed on one document
    at the time, but you can easily reinstall the highlighter on
    another document using the QSyntaxHighlighter::setDocument()
    function. The QSyntaxHighlighter class also provides the \l
    {QSyntaxHighlighter::document()}{document()} function which
    returns the currently set document.
*/
