/****************************************************************************

**

** 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 Qt Designer 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$

**

****************************************************************************/

#include "richtexteditor_p.h"

#include "htmlhighlighter_p.h"

#include "iconselector_p.h"

#include "ui_addlinkdialog.h"

#include "abstractsettings_p.h"

#include "iconloader_p.h"

#include <QtDesigner/QDesignerFormEditorInterface>

#include <QtCore/QList>

#include <QtCore/QMap>

#include <QtCore/QPointer>

#include <QtGui/QAction>

#include <QtGui/QColorDialog>

#include <QtGui/QComboBox>

#include <QtGui/QFontDatabase>

#include <QtGui/QTextCursor>

#include <QtGui/QPainter>

#include <QtGui/QIcon>

#include <QtGui/QMenu>

#include <QtGui/QMoveEvent>

#include <QtGui/QTabWidget>

#include <QtGui/QTextDocument>

#include <QtGui/QTextBlock>

#include <QtGui/QToolBar>

#include <QtGui/QToolButton>

#include <QtGui/QVBoxLayout>

#include <QtGui/QHBoxLayout>

#include <QtGui/QPushButton>

#include <QtGui/QDialogButtonBox>

QT_BEGIN_NAMESPACE

static const char *RichTextDialogC = "RichTextDialog";

static const char *Geometry = "Geometry";

namespace qdesigner_internal {

class RichTextEditor : public QTextEdit

{

    Q_OBJECT

public:

    RichTextEditor(QWidget *parent = 0);

    void setDefaultFont(const QFont &font);

    QToolBar *createToolBar(QDesignerFormEditorInterface *core, QWidget *parent = 0);

public slots:

    void setFontBold(bool b);

    void setFontPointSize(double);

    void setText(const QString &text);

    QString text(Qt::TextFormat format) const;

signals:

    void stateChanged();

};

class AddLinkDialog : public QDialog

{

    Q_OBJECT

public:

    AddLinkDialog(RichTextEditor *editor, QWidget *parent = 0);

    ~AddLinkDialog();

    int showDialog();

public slots:

    void accept();

private:

    RichTextEditor *m_editor;

    Ui::AddLinkDialog *m_ui;

};

AddLinkDialog::AddLinkDialog(RichTextEditor *editor, QWidget *parent) :

    QDialog(parent),

    m_ui(new Ui::AddLinkDialog)

{

    m_ui->setupUi(this);

    setWindowFlags(windowFlags() & ~Qt::WindowContextHelpButtonHint);

    m_editor = editor;

}

AddLinkDialog::~AddLinkDialog()

{

    delete m_ui;

}

int AddLinkDialog::showDialog()

{

    // Set initial focus

    const QTextCursor cursor = m_editor->textCursor();

    if (cursor.hasSelection()) {

        m_ui->titleInput->setText(cursor.selectedText());

        m_ui->urlInput->setFocus();

    } else {

        m_ui->titleInput->setFocus();

    }

    return exec();

}

void AddLinkDialog::accept()

{

    const QString title = m_ui->titleInput->text();

    const QString url = m_ui->urlInput->text();

    if (!title.isEmpty()) {

        QString html = QLatin1String("<a href=\"");

        html += url;

        html += QLatin1String("\">");

        html += title;

        html += QLatin1String("</a>");

        m_editor->insertHtml(html);

    }

    m_ui->titleInput->clear();

    m_ui->urlInput->clear();

    QDialog::accept();

}

class HtmlTextEdit : public QTextEdit

{

    Q_OBJECT

public:

    HtmlTextEdit(QWidget *parent = 0)

        : QTextEdit(parent)

    {}

    void contextMenuEvent(QContextMenuEvent *event);

private slots:

    void actionTriggered(QAction *action);

};

void HtmlTextEdit::contextMenuEvent(QContextMenuEvent *event)

{

    QMenu *menu = createStandardContextMenu();

    QMenu *htmlMenu = new QMenu(tr("Insert HTML entity"), menu);

    typedef struct {

        const char *text;

        const char *entity;

    } Entry;

    const Entry entries[] = {

        { "&& (&&)", "&" },

        { "& ", " " },

        { "&&lt; (<)", "&lt;" },

        { "&> (>)", ">" },

        { "&© (Copyright)", "©" },

        { "&® (Trade Mark)", "®" },

    };

    for (int i = 0; i < 6; ++i) {

        QAction *entityAction = new QAction(QLatin1String(entries[i].text),

                                            htmlMenu);

        entityAction->setData(QLatin1String(entries[i].entity));

        htmlMenu->addAction(entityAction);

    }

    menu->addMenu(htmlMenu);

    connect(htmlMenu, SIGNAL(triggered(QAction*)),

                      SLOT(actionTriggered(QAction*)));

    menu->exec(event->globalPos());

    delete menu;

}

void HtmlTextEdit::actionTriggered(QAction *action)

{

    insertPlainText(action->data().toString());

}

class ColorAction : public QAction

{

    Q_OBJECT

public:

    ColorAction(QObject *parent);

    const QColor& color() const { return m_color; }

    void setColor(const QColor &color);

signals:

    void colorChanged(const QColor &color);

private slots:

    void chooseColor();

private:

    QColor m_color;

};

ColorAction::ColorAction(QObject *parent):

    QAction(parent)

{

    setText(tr("Text Color"));

    setColor(Qt::black);

    connect(this, SIGNAL(triggered()), this, SLOT(chooseColor()));

}

void ColorAction::setColor(const QColor &color)

{

    if (color == m_color)

        return;

    m_color = color;

    QPixmap pix(24, 24);

    QPainter painter(&pix);

    painter.setRenderHint(QPainter::Antialiasing, false);

    painter.fillRect(pix.rect(), m_color);

    painter.setPen(m_color.darker());

    painter.drawRect(pix.rect().adjusted(0, 0, -1, -1));

    setIcon(pix);

}

void ColorAction::chooseColor()

{

    const QColor col = QColorDialog::getColor(m_color, 0);

    if (col.isValid() && col != m_color) {

        setColor(col);

        emit colorChanged(m_color);

    }

}

class RichTextEditorToolBar : public QToolBar

{

    Q_OBJECT

public:

    RichTextEditorToolBar(QDesignerFormEditorInterface *core,

                          RichTextEditor *editor,

                          QWidget *parent = 0);

public slots:

    void updateActions();

private slots:

    void alignmentActionTriggered(QAction *action);

    void sizeInputActivated(const QString &size);

    void colorChanged(const QColor &color);

    void setVAlignSuper(bool super);

    void setVAlignSub(bool sub);

    void insertLink();

    void insertImage();

private:

    QAction *m_bold_action;

    QAction *m_italic_action;

    QAction *m_underline_action;

    QAction *m_valign_sup_action;

    QAction *m_valign_sub_action;

    QAction *m_align_left_action;

    QAction *m_align_center_action;

    QAction *m_align_right_action;

    QAction *m_align_justify_action;

    QAction *m_link_action;

    QAction *m_image_action;

    ColorAction *m_color_action;

    QComboBox *m_font_size_input;

    QDesignerFormEditorInterface *m_core;

    QPointer<RichTextEditor> m_editor;

};

static QAction *createCheckableAction(const QIcon &icon, const QString &text,

                                      QObject *receiver, const char *slot,

                                      QObject *parent = 0)

{

    QAction *result = new QAction(parent);

    result->setIcon(icon);

    result->setText(text);

    result->setCheckable(true);

    result->setChecked(false);

    if (slot)

        QObject::connect(result, SIGNAL(triggered(bool)), receiver, slot);

    return result;

}

RichTextEditorToolBar::RichTextEditorToolBar(QDesignerFormEditorInterface *core,

                                             RichTextEditor *editor,

                                             QWidget *parent) :

    QToolBar(parent),

    m_link_action(new QAction(this)),

    m_image_action(new QAction(this)),

    m_color_action(new ColorAction(this)),

    m_font_size_input(new QComboBox),

    m_core(core),

    m_editor(editor)

{

    // Font size combo box

    m_font_size_input->setEditable(false);

    const QList<int> font_sizes = QFontDatabase::standardSizes();

    foreach (int font_size, font_sizes)

        m_font_size_input->addItem(QString::number(font_size));

    connect(m_font_size_input, SIGNAL(activated(QString)),

            this, SLOT(sizeInputActivated(QString)));

    addWidget(m_font_size_input);

    addSeparator();

    // Bold, italic and underline buttons

    m_bold_action = createCheckableAction(

            createIconSet(QLatin1String("textbold.png")),

            tr("Bold"), editor, SLOT(setFontBold(bool)), this);

    m_bold_action->setShortcut(tr("CTRL+B"));

    addAction(m_bold_action);

    m_italic_action = createCheckableAction(

            createIconSet(QLatin1String("textitalic.png")),

            tr("Italic"), editor, SLOT(setFontItalic(bool)), this);

    m_italic_action->setShortcut(tr("CTRL+I"));

    addAction(m_italic_action);

    m_underline_action = createCheckableAction(

            createIconSet(QLatin1String("textunder.png")),

            tr("Underline"), editor, SLOT(setFontUnderline(bool)), this);

    m_underline_action->setShortcut(tr("CTRL+U"));

    addAction(m_underline_action);

    addSeparator();

    // Left, center, right and justified alignment buttons

    QActionGroup *alignment_group = new QActionGroup(this);

    connect(alignment_group, SIGNAL(triggered(QAction*)),

                             SLOT(alignmentActionTriggered(QAction*)));

    m_align_left_action = createCheckableAction(

            createIconSet(QLatin1String("textleft.png")),

            tr("Left Align"), editor, 0, alignment_group);

    addAction(m_align_left_action);

    m_align_center_action = createCheckableAction(

            createIconSet(QLatin1String("textcenter.png")),

            tr("Center"), editor, 0, alignment_group);

    addAction(m_align_center_action);

    m_align_right_action = createCheckableAction(

            createIconSet(QLatin1String("textright.png")),

            tr("Right Align"), editor, 0, alignment_group);

    addAction(m_align_right_action);

    m_align_justify_action = createCheckableAction(

            createIconSet(QLatin1String("textjustify.png")),

            tr("Justify"), editor, 0, alignment_group);

    addAction(m_align_justify_action);

    addSeparator();

    // Superscript and subscript buttons

    m_valign_sup_action = createCheckableAction(

            createIconSet(QLatin1String("textsuperscript.png")),

            tr("Superscript"),

            this, SLOT(setVAlignSuper(bool)), this);

    addAction(m_valign_sup_action);

    m_valign_sub_action = createCheckableAction(

            createIconSet(QLatin1String("textsubscript.png")),

            tr("Subscript"),

            this, SLOT(setVAlignSub(bool)), this);

    addAction(m_valign_sub_action);

    addSeparator();

    // Insert hyperlink and image buttons

    m_link_action->setIcon(createIconSet(QLatin1String("textanchor.png")));

    m_link_action->setText(tr("Insert &Link"));

    connect(m_link_action, SIGNAL(triggered()), SLOT(insertLink()));

    addAction(m_link_action);

    m_image_action->setIcon(createIconSet(QLatin1String("insertimage.png")));

    m_image_action->setText(tr("Insert &Image"));

    connect(m_image_action, SIGNAL(triggered()), SLOT(insertImage()));

    addAction(m_image_action);

    addSeparator();

    // Text color button

    connect(m_color_action, SIGNAL(colorChanged(QColor)),

            this, SLOT(colorChanged(QColor)));

    addAction(m_color_action);

    connect(editor, SIGNAL(textChanged()), this, SLOT(updateActions()));

    connect(editor, SIGNAL(stateChanged()), this, SLOT(updateActions()));

    updateActions();

}

void RichTextEditorToolBar::alignmentActionTriggered(QAction *action)

{

    Qt::Alignment new_alignment;

    if (action == m_align_left_action) {

        new_alignment = Qt::AlignLeft;

    } else if (action == m_align_center_action) {

        new_alignment = Qt::AlignCenter;

    } else if (action == m_align_right_action) {

        new_alignment = Qt::AlignRight;

    } else {

        new_alignment = Qt::AlignJustify;

    }

    m_editor->setAlignment(new_alignment);

}

void RichTextEditorToolBar::colorChanged(const QColor &color)

{

    m_editor->setTextColor(color);

    m_editor->setFocus();

}

void RichTextEditorToolBar::sizeInputActivated(const QString &size)

{

    bool ok;

    int i = size.toInt(&ok);

    if (!ok)

        return;

    m_editor->setFontPointSize(i);

    m_editor->setFocus();

}

void RichTextEditorToolBar::setVAlignSuper(bool super)

{

    const QTextCharFormat::VerticalAlignment align = super ?

        QTextCharFormat::AlignSuperScript : QTextCharFormat::AlignNormal;

    QTextCharFormat charFormat = m_editor->currentCharFormat();

    charFormat.setVerticalAlignment(align);

    m_editor->setCurrentCharFormat(charFormat);

    m_valign_sub_action->setChecked(false);

}

void RichTextEditorToolBar::setVAlignSub(bool sub)

{

    const QTextCharFormat::VerticalAlignment align = sub ?

        QTextCharFormat::AlignSubScript : QTextCharFormat::AlignNormal;

    QTextCharFormat charFormat = m_editor->currentCharFormat();

    charFormat.setVerticalAlignment(align);

    m_editor->setCurrentCharFormat(charFormat);

    m_valign_sup_action->setChecked(false);

}

void RichTextEditorToolBar::insertLink()

{

    AddLinkDialog linkDialog(m_editor, this);

    linkDialog.showDialog();

    m_editor->setFocus();

}

void RichTextEditorToolBar::insertImage()

{

    const QString path = IconSelector::choosePixmapResource(m_core, m_core->resourceModel(), QString(), this);

    if (!path.isEmpty())

        m_editor->insertHtml(QLatin1String("<img src=\"") + path + QLatin1String("\"/>"));

}

void RichTextEditorToolBar::updateActions()

{

    if (m_editor == 0) {

        setEnabled(false);

        return;

    }

    const Qt::Alignment alignment = m_editor->alignment();

    const QTextCursor cursor = m_editor->textCursor();

    const QTextCharFormat charFormat = cursor.charFormat();

    const QFont font = charFormat.font();

    const QTextCharFormat::VerticalAlignment valign =

        charFormat.verticalAlignment();

    const bool superScript = valign == QTextCharFormat::AlignSuperScript;

    const bool subScript = valign == QTextCharFormat::AlignSubScript;