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

**

** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).

** All rights reserved.

** Contact: Nokia Corporation (qt-info@nokia.com)

**

** This file is part of the Qt Linguist 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$

**

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

/*  TRANSLATOR MessageEditor

  This is the right panel of the main window.

*/

#include "messageeditor.h"

#include "messageeditorwidgets.h"

#include "simtexth.h"

#include "phrasemodel.h"

#include <QApplication>

#include <QBoxLayout>

#include <QClipboard>

#include <QDebug>

#include <QDockWidget>

#include <QHeaderView>

#include <QKeyEvent>

#include <QMainWindow>

#include <QPainter>

#include <QTreeView>

#include <QVBoxLayout>

QT_BEGIN_NAMESPACE

#ifdef NEVER_TRUE

// Allow translators to provide localized names for QLocale::languageToString

// At least the own language should be translated ... This is a "hack" until

// functionality is provided within Qt (see task 196275).

static const char * language_strings[] =

{

    QT_TRANSLATE_NOOP("MessageEditor", "Russian"),

    QT_TRANSLATE_NOOP("MessageEditor", "German"),

    QT_TRANSLATE_NOOP("MessageEditor", "Japanese"),

    QT_TRANSLATE_NOOP("MessageEditor", "French"),

    QT_TRANSLATE_NOOP("MessageEditor", "Polish"),

    QT_TRANSLATE_NOOP("MessageEditor", "Chinese")

};

#endif

/*

   MessageEditor class impl.

   Handles layout of dock windows and the editor page.

*/

MessageEditor::MessageEditor(MultiDataModel *dataModel, QMainWindow *parent)

    : QScrollArea(parent->centralWidget()),

      m_dataModel(dataModel),

      m_currentModel(-1),

      m_currentNumerus(-1),

      m_lengthVariants(false),

      m_undoAvail(false),

      m_redoAvail(false),

      m_cutAvail(false),

      m_copyAvail(false),

      m_selectionHolder(0),

      m_focusWidget(0)

{

    setObjectName(QLatin1String("scroll area"));

    // Use white explicitly as the background color for the editor page.

    QPalette p;

    p.setColor(QPalette::Active,   QPalette::Base,   Qt::white);

    p.setColor(QPalette::Inactive, QPalette::Base,   Qt::white);

    p.setColor(QPalette::Disabled, QPalette::Base,   Qt::white);

    p.setColor(QPalette::Active,   QPalette::Window, Qt::white);

    p.setColor(QPalette::Inactive, QPalette::Window, Qt::white);

    p.setColor(QPalette::Disabled, QPalette::Window, Qt::white);

    setPalette(p);

    setupEditorPage();

    // Signals

    connect(qApp->clipboard(), SIGNAL(dataChanged()),

            SLOT(clipboardChanged()));

    connect(m_dataModel, SIGNAL(modelAppended()),

            SLOT(messageModelAppended()));

    connect(m_dataModel, SIGNAL(modelDeleted(int)),

            SLOT(messageModelDeleted(int)));

    connect(m_dataModel, SIGNAL(allModelsDeleted()),

            SLOT(allModelsDeleted()));

    connect(m_dataModel, SIGNAL(languageChanged(int)),

            SLOT(setTargetLanguage(int)));

    m_tabOrderTimer.setSingleShot(true);

    connect(&m_tabOrderTimer, SIGNAL(timeout()), SLOT(reallyFixTabOrder()));

    clipboardChanged();

    setWhatsThis(tr("This whole panel allows you to view and edit "

                    "the translation of some source text."));

    showNothing();

}

void MessageEditor::setupEditorPage()

{

    QFrame *editorPage = new QFrame;

    editorPage->setObjectName(QLatin1String("editorPage"));

    editorPage->setStyleSheet(QLatin1String(

            "QFrame#editorPage { border-image: url(:/images/transbox.png) 12 16 16 12 repeat;"

            "                    border-width: 12px 16px 16px 12px; }"

            "QFrame#editorPage { background-color: white; }"

            "QLabel { font-weight: bold; }"

            ));

    editorPage->setSizePolicy(QSizePolicy(QSizePolicy::Expanding, QSizePolicy::Fixed));

    m_source = new FormWidget(tr("Source text"), false);

    m_source->setHideWhenEmpty(true);

    m_source->setWhatsThis(tr("This area shows the source text."));

    connect(m_source, SIGNAL(selectionChanged(QTextEdit *)),

            SLOT(selectionChanged(QTextEdit *)));

    m_pluralSource = new FormWidget(tr("Source text (Plural)"), false);

    m_pluralSource->setHideWhenEmpty(true);

    m_pluralSource->setWhatsThis(tr("This area shows the plural form of the source text."));

    connect(m_pluralSource, SIGNAL(selectionChanged(QTextEdit *)),

            SLOT(selectionChanged(QTextEdit *)));

    m_commentText = new FormWidget(tr("Developer comments"), false);

    m_commentText->setHideWhenEmpty(true);

    m_commentText->setObjectName(QLatin1String("comment/context view"));

    m_commentText->setWhatsThis(tr("This area shows a comment that"

                        " may guide you, and the context in which the text"

                        " occurs.") );

    QBoxLayout *subLayout = new QVBoxLayout;

    subLayout->setMargin(5);

    subLayout->addWidget(m_source);

    subLayout->addWidget(m_pluralSource);

    subLayout->addWidget(m_commentText);

    m_layout = new QVBoxLayout;

    m_layout->setSpacing(2);

    m_layout->setMargin(2);

    m_layout->addLayout(subLayout);

    m_layout->addStretch(1);

    editorPage->setLayout(m_layout);

    setWidget(editorPage);

    setWidgetResizable(true);

}

QPalette MessageEditor::paletteForModel(int model) const

{

    QBrush brush = m_dataModel->brushForModel(model);

    QPalette pal;

    if (m_dataModel->isModelWritable(model)) {

        pal.setBrush(QPalette::Window, brush);

    } else {

        QPixmap pm(brush.texture().size());

        pm.fill();

        QPainter p(&pm);

        p.fillRect(brush.texture().rect(), brush);

        pal.setBrush(QPalette::Window, pm);

    }

    return pal;

}

void MessageEditor::messageModelAppended()

{

    int model = m_editors.size();

    m_editors.append(MessageEditorData());

    MessageEditorData &ed = m_editors.last();

    ed.pluralEditMode = false;

    ed.fontSize = font().pointSize();

    ed.container = new QWidget;

    if (model > 0) {

        ed.container->setPalette(paletteForModel(model));

        ed.container->setAutoFillBackground(true);

        if (model == 1) {

            m_editors[0].container->setPalette(paletteForModel(0));

            m_editors[0].container->setAutoFillBackground(true);

        }

    }

    bool writable = m_dataModel->isModelWritable(model);

    ed.transCommentText = new FormWidget(QString(), true);

    ed.transCommentText->setEditingEnabled(writable);

    ed.transCommentText->setHideWhenEmpty(!writable);

    ed.transCommentText->setWhatsThis(tr("Here you can enter comments for your own use."

                        " They have no effect on the translated applications.") );

    ed.transCommentText->getEditor()->installEventFilter(this);

    connect(ed.transCommentText, SIGNAL(selectionChanged(QTextEdit *)),

            SLOT(selectionChanged(QTextEdit *)));

    connect(ed.transCommentText, SIGNAL(textChanged(QTextEdit *)),

            SLOT(emitTranslatorCommentChanged(QTextEdit *)));

    connect(ed.transCommentText, SIGNAL(textChanged(QTextEdit *)), SLOT(resetHoverSelection()));

    connect(ed.transCommentText, SIGNAL(cursorPositionChanged()), SLOT(resetHoverSelection()));

    fixTabOrder();

    QBoxLayout *box = new QVBoxLayout(ed.container);

    box->setMargin(5);

    box->addWidget(ed.transCommentText);

    box->addSpacing(ed.transCommentText->getEditor()->fontMetrics().height() / 2);

    m_layout->addWidget(ed.container);

    setTargetLanguage(model);

}

void MessageEditor::allModelsDeleted()

{

    foreach (const MessageEditorData &med, m_editors)

        med.container->deleteLater();

    m_editors.clear();

    m_currentModel = -1;

    // Do not emit activeModelChanged() - the main window will refresh anyway

    m_currentNumerus = -1;

    showNothing();

}

void MessageEditor::messageModelDeleted(int model)

{

    m_editors[model].container->deleteLater();

    m_editors.removeAt(model);

    if (model <= m_currentModel) {

        if (model < m_currentModel || m_currentModel == m_editors.size())

            --m_currentModel;

        // Do not emit activeModelChanged() - the main window will refresh anyway

        if (m_currentModel >= 0) {

            if (m_currentNumerus >= m_editors[m_currentModel].transTexts.size())

                m_currentNumerus = m_editors[m_currentModel].transTexts.size() - 1;

            activeEditor()->setFocus();

        } else {

            m_currentNumerus = -1;

        }

    }

    if (m_editors.size() == 1) {

        m_editors[0].container->setAutoFillBackground(false);

    } else {

        for (int i = model; i < m_editors.size(); ++i)

            m_editors[i].container->setPalette(paletteForModel(i));

    }

}

void MessageEditor::addPluralForm(int model, const QString &label, bool writable)

{

    FormMultiWidget *transEditor = new FormMultiWidget(label);

    connect(transEditor, SIGNAL(editorCreated(QTextEdit *)), SLOT(editorCreated(QTextEdit *)));

    transEditor->setEditingEnabled(writable);

    transEditor->setHideWhenEmpty(!writable);

    if (!m_editors[model].transTexts.isEmpty())

        transEditor->setVisible(false);

    transEditor->setMultiEnabled(m_lengthVariants);

    static_cast<QBoxLayout *>(m_editors[model].container->layout())->insertWidget(

        m_editors[model].transTexts.count(), transEditor);

    connect(transEditor, SIGNAL(selectionChanged(QTextEdit *)),

            SLOT(selectionChanged(QTextEdit *)));

    connect(transEditor, SIGNAL(textChanged(QTextEdit *)),

            SLOT(emitTranslationChanged(QTextEdit *)));

    connect(transEditor, SIGNAL(textChanged(QTextEdit *)), SLOT(resetHoverSelection()));

    connect(transEditor, SIGNAL(cursorPositionChanged()), SLOT(resetHoverSelection()));

    m_editors[model].transTexts << transEditor;

}

void MessageEditor::editorCreated(QTextEdit *te)

{

    FormMultiWidget *snd = static_cast<FormMultiWidget *>(sender());

    for (int model = 0; ; ++model) {

        MessageEditorData med = m_editors.at(model);

        if (med.transTexts.contains(snd)) {

            QFont font;

            font.setPointSize(static_cast<int>(med.fontSize));

            te->setFont(font);

            te->installEventFilter(this);

            fixTabOrder();

            return;

        }

    }

}

void MessageEditor::fixTabOrder()

{

    m_tabOrderTimer.start(0);

}

void MessageEditor::reallyFixTabOrder()

{

    QWidget *prev = this;

    foreach (const MessageEditorData &med, m_editors) {

        foreach (FormMultiWidget *fmw, med.transTexts)

            foreach (QTextEdit *te, fmw->getEditors()) {

                setTabOrder(prev, te);

                prev = te;

            }

        QTextEdit *te = med.transCommentText->getEditor();

        setTabOrder(prev, te);

        prev = te;

    }

}

/*! internal

    Returns all translations for an item.

    The number of translations is dependent on if we have a plural form or not.

    If we don't have a plural form, then this should only contain one item.

    Otherwise it will contain the number of numerus forms for the particular language.

*/

QStringList MessageEditor::translations(int model) const

{

    QStringList translations;

    for (int i = 0; i < m_editors[model].transTexts.count() &&

                    m_editors[model].transTexts.at(i)->isVisible(); ++i)

        translations << m_editors[model].transTexts[i]->getTranslation();

    return translations;

}

static void clearSelection(QTextEdit *t)

{

    bool oldBlockState = t->blockSignals(true);

    QTextCursor c = t->textCursor();

    c.clearSelection();

    t->setTextCursor(c);

    t->blockSignals(oldBlockState);

}

void MessageEditor::selectionChanged(QTextEdit *te)

{

    if (te != m_selectionHolder) {

        if (m_selectionHolder)

            clearSelection(m_selectionHolder);

        m_selectionHolder = (te->textCursor().hasSelection() ? te : 0);

        updateCanCutCopy();

    }

}

void MessageEditor::resetHoverSelection()

{

    if (m_selectionHolder &&

        (m_selectionHolder == m_source->getEditor()

         || m_selectionHolder == m_pluralSource->getEditor()))

        resetSelection();

}

void MessageEditor::resetSelection()

{

    if (m_selectionHolder) {

        clearSelection(m_selectionHolder);

        m_selectionHolder = 0;

        updateCanCutCopy();

    }

}

void MessageEditor::activeModelAndNumerus(int *model, int *numerus) const

{

    for (int j = 0; j < m_editors.count(); ++j) {

        for (int i = 0; i < m_editors[j].transTexts.count(); ++i)

            foreach (QTextEdit *te, m_editors[j].transTexts[i]->getEditors())

                if (m_focusWidget == te) {

                    *model = j;

                    *numerus = i;

                    return;

                }

        if (m_focusWidget == m_editors[j].transCommentText->getEditor()) {

            *model = j;

            *numerus = -1;

            return;

        }

    }

    *model = -1;

    *numerus = -1;

}

QTextEdit *MessageEditor::activeTranslation() const

{

    if (m_currentNumerus < 0)

        return 0;

    foreach (QTextEdit *te, m_editors[m_currentModel].transTexts[m_currentNumerus]->getEditors())

        if (te->hasFocus())

            return te;

    return 0; // This cannot happen

}

QTextEdit *MessageEditor::activeOr1stTranslation() const

{

    if (m_currentNumerus < 0) {

        for (int i = 0; i < m_editors.size(); ++i)

            if (m_editors[i].container->isVisible()

                && !m_editors[i].transTexts.first()->getEditors().first()->isReadOnly())

                return m_editors[i].transTexts.first()->getEditors().first();

        return 0;

    }

    return activeTranslation();

}

QTextEdit *MessageEditor::activeTransComment() const

{

    if (m_currentModel < 0 || m_currentNumerus >= 0)

        return 0;

    return m_editors[m_currentModel].transCommentText->getEditor();

}

QTextEdit *MessageEditor::activeEditor() const

{

    if (QTextEdit *te = activeTransComment())

        return te;

    return activeTranslation();

}

QTextEdit *MessageEditor::activeOr1stEditor() const

{

    if (QTextEdit *te = activeTransComment())

        return te;

    return activeOr1stTranslation();

}

void MessageEditor::setTargetLanguage(int model)

{

    const QStringList &numerusForms = m_dataModel->model(model)->numerusForms();

    const QString &langLocalized = m_dataModel->model(model)->localizedLanguage();

    for (int i = 0; i < numerusForms.count(); ++i) {

        const QString &label = tr("%1 translation (%2)").arg(langLocalized, numerusForms[i]);

        if (!i)

            m_editors[model].firstForm = label;

        if (i >= m_editors[model].transTexts.count())

            addPluralForm(model, label, m_dataModel->isModelWritable(model));

        else

            m_editors[model].transTexts[i]->setLabel(label);

        m_editors[model].transTexts[i]->setVisible(!i || m_editors[model].pluralEditMode);

        m_editors[model].transTexts[i]->setWhatsThis(

                tr("This is where you can enter or modify"

                   " the translation of the above source text.") );

    }

    for (int j = m_editors[model].transTexts.count() - numerusForms.count(); j > 0; --j)

        delete m_editors[model].transTexts.takeLast();

    m_editors[model].invariantForm = tr("%1 translation").arg(langLocalized);

    m_editors[model].transCommentText->setLabel(tr("%1 translator comments").arg(langLocalized));

}

MessageEditorData *MessageEditor::modelForWidget(const QObject *o)

{

    for (int j = 0; j < m_editors.count(); ++j) {

        for (int i = 0; i < m_editors[j].transTexts.count(); ++i)

            foreach (QTextEdit *te, m_editors[j].transTexts[i]->getEditors())

                if (te == o)

                    return &m_editors[j];

        if (m_editors[j].transCommentText->getEditor() == o)

            return &m_editors[j];

    }

    return 0;

}

static bool applyFont(MessageEditorData *med)

{

    QFont font;

    font.setPointSize(static_cast<int>(med->fontSize));

    for (int i = 0; i < med->transTexts.count(); ++i)

        foreach (QTextEdit *te, med->transTexts[i]->getEditors())

            te->setFont(font);

    med->transCommentText->getEditor()->setFont(font);

    return true;

}

static bool incFont(MessageEditorData *med)

{

    if (!med || med->fontSize >= 32)

        return true;

    med->fontSize *= 1.2;

    return applyFont(med);

}

static bool decFont(MessageEditorData *med)

{

    if (!med || med->fontSize <= 8)

        return true;

    med->fontSize /= 1.2;

    return applyFont(med);

}

bool MessageEditor::eventFilter(QObject *o, QEvent *e)

{

    // handle copying from the source

    if (e->type() == QEvent::ShortcutOverride) {

        QKeyEvent *ke = static_cast<QKeyEvent *>(e);

        if (ke->modifiers() & Qt::ControlModifier) {

            if (ke->key() == Qt::Key_C) {

                if (m_source->getEditor()->textCursor().hasSelection()) {

                    m_source->getEditor()->copy();

                    return true;

                }

                if (m_pluralSource->getEditor()->textCursor().hasSelection()) {

                    m_pluralSource->getEditor()->copy();

                    return true;

                }

            } else if (ke->key() == Qt::Key_A) {