MainWindow.cpp

Go to the documentation of this file.

/********************************************************************************
 * Copyright (C) 2011 by Stephen Allewell                                       *
 * sallewell@users.sourceforge.net                                              *
 *                                                                              *
 * This program is free software; you can redistribute it and/or modify         *
 * it under the terms of the GNU General Public License as published by         *
 * the Free Software Foundation; either version 2 of the License, or            *
 * (at your option) any later version.                                          *
 ********************************************************************************/


#include "MainWindow.h"

#include <QVBoxLayout>
#include <QListWidgetItem>
#include <QMenu>

#include <KAction>
#include <KActionCollection>
#include <KConfigDialog>
#include <KFileDialog>
#include <KGlobalSettings>
#include <KIO/NetAccess>
#include <KLocale>
#include <KMessageBox>
#include <KRecentFilesAction>
#include <KStatusBar>
#include <KTabWidget>
#include <KUrl>

#include "ConfigurationDialogs.h"
#include "Editor.h"
#include "Exceptions.h"
#include "SymbolListWidget.h"
#include "SymbolLibrary.h"

#include "ui_EditorConfigPage.h"

#include "SymbolEditor.h"


MainWindow::MainWindow()
    :   m_tabWidget(new KTabWidget(this)),
        m_editor(new Editor),
        m_listWidget(new SymbolListWidget(m_tabWidget)),
        m_symbolLibrary(new SymbolLibrary(m_listWidget)),
        m_item(0),
        m_menu(0)
{
    m_listWidget->loadFromLibrary(m_symbolLibrary);
    m_url = KUrl(i18n("Untitled"));

    setObjectName("MainWindow#");

    KActionCollection *actions = actionCollection();

    QVBoxLayout *editorLayout = new QVBoxLayout;
    editorLayout->addWidget(m_editor, 0, Qt::AlignCenter);
    QWidget *layoutWidget = new QWidget;
    layoutWidget->setLayout(editorLayout);

    m_listWidget->setIconSize(48);
    m_listWidget->setContextMenuPolicy(Qt::CustomContextMenu);

    m_tabWidget->addTab(layoutWidget, "Editor");
    m_tabWidget->addTab(m_listWidget, "Symbol Library");

    setCentralWidget(m_tabWidget);

    setupActions();

    m_undoGroup.addStack(m_editor->undoStack());
    m_undoGroup.addStack(m_symbolLibrary->undoStack());
    connect(m_tabWidget, SIGNAL(currentChanged(int)), this, SLOT(currentChanged(int)));
    connect(m_editor, SIGNAL(message(QString)), statusBar(), SLOT(showMessage(QString)));
    connect(m_editor, SIGNAL(minLineWidth(bool)), actions->action("decreaseLineWidth"), SLOT(setDisabled(bool)));
    connect(m_editor, SIGNAL(maxLineWidth(bool)), actions->action("increaseLineWidth"), SLOT(setDisabled(bool)));
    connect(&m_undoGroup, SIGNAL(canUndoChanged(bool)), actions->action("edit_undo"), SLOT(setEnabled(bool)));
    connect(&m_undoGroup, SIGNAL(canRedoChanged(bool)), actions->action("edit_redo"), SLOT(setEnabled(bool)));
    connect(&m_undoGroup, SIGNAL(undoTextChanged(QString)), this, SLOT(undoTextChanged(QString)));
    connect(&m_undoGroup, SIGNAL(redoTextChanged(QString)), this, SLOT(redoTextChanged(QString)));
    connect(&m_undoGroup, SIGNAL(cleanChanged(bool)), this, SLOT(cleanChanged(bool)));
    connect(m_editor->undoStack(), SIGNAL(cleanChanged(bool)), actions->action("saveSymbol"), SLOT(setDisabled(bool)));
    connect(m_editor->undoStack(), SIGNAL(cleanChanged(bool)), actions->action("saveSymbolAsNew"), SLOT(setDisabled(bool)));
    connect(m_symbolLibrary->undoStack(), SIGNAL(cleanChanged(bool)), actions->action("file_save"), SLOT(setDisabled(bool)));
    connect(m_listWidget, SIGNAL(executed(QListWidgetItem*)), this, SLOT(itemSelected(QListWidgetItem*)));
    connect(m_listWidget, SIGNAL(customContextMenuRequested(QPoint)), this, SLOT(listWidgetContextMenuRequested(QPoint)));

    setupGUI(KXmlGuiWindow::Default, "SymbolEditorui.rc");

    m_tabWidget->setCurrentIndex(0);                        // select the editor
    currentChanged(0);                                      // setting current index above doesn't trigger the signal
    actions->action("moveTo")->trigger();                   // select draw tool
    actions->action("enableSnap")->setChecked(true);        // enable snap
    actions->action("file_save")->setEnabled(false);        // nothing to save yet
    actions->action("saveSymbol")->setEnabled(false);       // nothing to save yet
    actions->action("saveSymbolAsNew")->setEnabled(false);  // nothing to save yet
    actions->action("help_contents")->setVisible(false);    // hide the handbook action from the help menu
    setActionsFromSymbol(m_editor->symbol().second);        // set the actions that depend on the current empty symbol, i.e. the defaults
}


MainWindow::~MainWindow()
{
    delete m_symbolLibrary;
}


bool MainWindow::queryClose()
{
    return (editorClean() && libraryClean());
}


bool MainWindow::editorClean()
{
    bool clean = m_editor->undoStack()->isClean();

    if (!clean) {
        int messageBoxResult = KMessageBox::warningYesNoCancel(this, i18n("Save changes to the symbol?\nSelecting No discards changes."));

        switch (messageBoxResult) {
        case KMessageBox::Yes:
            saveSymbol();
            save();
            clean = true;
            break;

        case KMessageBox::No:
            clean = true;
            break;

        case KMessageBox::Cancel:
            clean = false;
            break;
        }
    }

    return clean;
}


bool MainWindow::libraryClean()
{
    bool clean = m_symbolLibrary->undoStack()->isClean();

    if (!clean) {
        int messageBoxResult = KMessageBox::warningYesNoCancel(this, i18n("Save changes to the library?\nSelecting No discards changes."));

        switch (messageBoxResult) {
        case KMessageBox::Yes:
            save();
            clean = true;
            break;

        case KMessageBox::No:
            clean = true;
            break;

        case KMessageBox::Cancel:
            clean = false;
            break;
        }
    }

    return clean;
}


bool MainWindow::queryExit()
{
    return true;
}


void MainWindow::fileOpen()
{
    KUrl url = KFileDialog::getOpenUrl(KUrl("kfiledialog:///"), i18n("*.sym|Cross Stitch Symbols"), this);

    if (!url.isEmpty()) {
        fileOpen(url);
    }
}


void MainWindow::fileOpen(const KUrl &url)
{
    if (!editorClean() || !libraryClean()) {
        return;
    }

    m_symbolLibrary->clear();
    m_editor->clear();

    if (url.isValid()) {
        QString src;

        if (KIO::NetAccess::download(url, src, 0)) {
            QFile file(src);

            if (file.open(QIODevice::ReadOnly)) {
                QDataStream stream(&file);

                try {
                    stream >> *m_symbolLibrary;
                    m_url = url;
                    KRecentFilesAction *action = static_cast<KRecentFilesAction *>(actionCollection()->action("file_open_recent"));
                    action->addUrl(url);
                    action->saveEntries(KConfigGroup(KGlobal::config(), "RecentFiles"));
                    m_tabWidget->setCurrentIndex(1);
                } catch (const InvalidFile &e) {
                    KMessageBox::sorry(0, i18n("This doesn't appear to be a valid symbol file"));
                } catch (const InvalidFileVersion &e) {
                    KMessageBox::sorry(0, i18n("Version %1 of the library file is not supported in this version of SymbolEditor", e.version));
                } catch (const InvalidSymbolVersion &e) {
                    KMessageBox::sorry(0, i18n("Version %1 of the symbol is not supported in this version of SymbolEditor", e.version));
                } catch (const FailedReadLibrary &e) {
                    KMessageBox::sorry(0, i18n("Failed to read the library\n%1", e.statusMessage()));
                    m_symbolLibrary->clear();
                }

                file.close();
            } else {
                KMessageBox::sorry(0, i18n("Failed to open the file %1", url.fileName()));
            }
        } else {
            KMessageBox::sorry(0, i18n("Failed to download the file %1", url.fileName()));
        }
    } else {
        KMessageBox::sorry(0, i18n("The url %1 is invalid", url.fileName()));
    }
}


void MainWindow::save()
{
    if (m_url == KUrl(i18n("Untitled"))) {
        saveAs();
    } else {
        QFile file(m_url.path());

        if (file.open(QIODevice::WriteOnly | QIODevice::Truncate)) {
            QDataStream stream(&file);
            stream.setVersion(QDataStream::Qt_4_0);

            try {
                stream << *m_symbolLibrary;
            } catch (const FailedWriteLibrary &e) {
                KMessageBox::sorry(0, i18n("Failed to write the library\n%1", e.statusMessage()));
            }

            file.close();
            m_symbolLibrary->undoStack()->setClean();
        } else {
            KMessageBox::sorry(0, i18n("Failed to open the file %1\n%2", m_url.fileName(), file.errorString()));
        }
    }
}


void MainWindow::saveAs()
{
    KUrl url = KFileDialog::getSaveUrl(QString("::%1").arg(KGlobalSettings::documentPath()), i18n("*.sym|Cross Stitch Symbols"), this, i18n("Save As"));

    if (url.isValid()) {
        if (KIO::NetAccess::exists(url, false, 0)) {
            if (KMessageBox::warningYesNo(this, i18n("This file already exists\nDo you want to overwrite it?")) == KMessageBox::No) {
                return;
            }
        }

        m_url = url;
        save();
        KRecentFilesAction *action = static_cast<KRecentFilesAction *>(actionCollection()->action("file_open_recent"));
        action->addUrl(url);
        action->saveEntries(KConfigGroup(KGlobal::config(), "RecentFiles"));
    }
}


void MainWindow::newSymbol()
{
    if (editorClean()) {
        m_editor->clear();
        setActionsFromSymbol(m_editor->symbol().second);
        actionCollection()->action("moveTo")->trigger();   // Select move tool
    }
}


void MainWindow::saveSymbol()
{
    QPair<qint16, Symbol> pair = m_editor->symbol();
    m_symbolLibrary->undoStack()->push(new UpdateSymbolCommand(m_symbolLibrary, pair.first, pair.second));
    m_editor->undoStack()->setClean();
}


void MainWindow::saveSymbolAsNew()
{
    QPair<qint16, Symbol> pair = m_editor->symbol();
    pair.first = 0;
    m_symbolLibrary->undoStack()->push(new UpdateSymbolCommand(m_symbolLibrary, pair.first, pair.second));
    m_editor->setSymbol(pair);
}


void MainWindow::importLibrary()
{
    KUrl url = KFileDialog::getOpenUrl(KUrl("kfiledialog:///"), i18n("*.sym|Cross Stitch Symbols"), this);

    if (url.isEmpty()) {
        return;
    }

    if (url.isValid()) {
        QString src;

        if (KIO::NetAccess::download(url, src, 0)) {
            QFile file(src);

            if (file.open(QIODevice::ReadOnly)) {
                SymbolLibrary *lib = new SymbolLibrary;
                QDataStream stream(&file);

                try {
                    stream >> *lib;
                    m_symbolLibrary->undoStack()->push(new ImportLibraryCommand(m_symbolLibrary, lib));
                } catch (const InvalidFile &e) {
                    KMessageBox::sorry(0, i18n("This doesn't appear to be a valid symbol file"));
                } catch (const InvalidFileVersion &e) {
                    KMessageBox::sorry(0, i18n("Version %1 of the library file is not supported in this version of SymbolEditor", e.version));
                }

                file.close();
            } else {
                KMessageBox::sorry(0, i18n("Failed to open the file %1", url.fileName()));
            }
        } else {
            KMessageBox::sorry(0, i18n("Failed to download the file %1", url.fileName()));
        }
    } else {
        KMessageBox::sorry(0, i18n("The url %1 is invalid", url.fileName()));
    }
}


void MainWindow::close()
{
    if (editorClean() && libraryClean()) {
        m_editor->clear();
        m_symbolLibrary->clear();
        m_url = KUrl(i18n("Untitled"));
    }
}


void MainWindow::quit()
{
    KXmlGuiWindow::close();
}


void MainWindow::undo()
{
    m_undoGroup.undo();
}


void MainWindow::redo()
{
    m_undoGroup.redo();
}


void MainWindow::undoTextChanged(const QString &text)
{
    actionCollection()->action("edit_undo")->setText(QString(i18n("Undo %1", text)));
}


void MainWindow::redoTextChanged(const QString &text)
{
    actionCollection()->action("edit_redo")->setText(QString(i18n("Redo %1", text)));
}


void MainWindow::cleanChanged(bool clean)
{
    QString tab = QString("%1 ").arg(m_url.fileName());

    if (m_tabWidget->currentIndex() == 1) {
        tab += QString(i18nc("The Library tab title", "Library"));
    } else {
        tab += QString(i18nc("The Editor tab title", "Editor"));
    }

    setCaption(tab, !clean);
}


void MainWindow::currentChanged(int index)
{
    if (index == 0) { // Editor
        m_undoGroup.setActiveStack(m_editor->undoStack());
    } else if (index == 1) { // QListWidget
        m_undoGroup.setActiveStack(m_symbolLibrary->undoStack());
    }
}


void MainWindow::itemSelected(QListWidgetItem *item)
{
    QPair<qint16, Symbol> pair;

    if (editorClean()) {
        m_editor->clear();
        pair.first = static_cast<qint16>(item->data(Qt::UserRole).toInt());
        pair.second = m_symbolLibrary->symbol(pair.first);
        m_editor->setSymbol(pair);
        setActionsFromSymbol(pair.second);
        m_tabWidget->setCurrentIndex(0);
    }
}


void MainWindow::listWidgetContextMenuRequested(const QPoint &pos)
{
    if (m_item = m_listWidget->itemAt(pos)) {
        if (!m_menu) {
            m_menu = new QMenu;
            m_menu->addAction(i18n("Delete Symbol"), this, SLOT(deleteSymbol()));
        }

        m_menu->popup(QCursor::pos());
    }
}


void MainWindow::deleteSymbol()
{
    m_symbolLibrary->undoStack()->push(new DeleteSymbolCommand(m_symbolLibrary, static_cast<qint16>(m_item->data(Qt::UserRole).toInt())));
}


void MainWindow::preferences()
{
    if (KConfigDialog::showDialog("preferences")) {
        return;
    }

    KConfigDialog *dialog = new KConfigDialog(this, "preferences", Configuration::self());
    dialog->setFaceType(KPageDialog::List);

    dialog->addPage(new EditorConfigPage(0, "EditorConfigPage"), i18nc("The Editor config page", "Editor"), "preferences-desktop");

    connect(dialog, SIGNAL(settingsChanged(QString)), m_editor, SLOT(readSettings()));

    dialog->show();
}


void MainWindow::setupActions()
{
    KAction *action;
    QActionGroup *actionGroup;

    KActionCollection *actions = actionCollection();

    // File menu
    KStandardAction::open(this, SLOT(fileOpen()), actions);
    KStandardAction::openNew(this, SLOT(newSymbol()), actions);
    KStandardAction::openRecent(this, SLOT(fileOpen(KUrl)), actions)->loadEntries(KConfigGroup(KGlobal::config(), "RecentFiles"));
    KStandardAction::save(this, SLOT(save()), actions);
    KStandardAction::saveAs(this, SLOT(saveAs()), actions);

    action = new KAction(this);
    action->setText(i18n("Import Library"));
    connect(action, SIGNAL(triggered()), this, SLOT(importLibrary()));
    actions->addAction("importLibrary", action);

    action = new KAction(this);
    action->setText(i18n("Save Symbol"));
    action->setIcon(KIcon("save-symbol"));
    connect(action, SIGNAL(triggered()), this, SLOT(saveSymbol()));
    actions->addAction("saveSymbol", action);

    action = new KAction(this);
    action->setText(i18n("Save Symbol as New"));
    connect(action, SIGNAL(triggered()), this, SLOT(saveSymbolAsNew()));
    actions->addAction("saveSymbolAsNew", action);

    KStandardAction::close(this, SLOT(close()), actions);
    KStandardAction::quit(this, SLOT(quit()), actions);

    // Edit menu
    KStandardAction::undo(this, SLOT(undo()), actions);
    KStandardAction::redo(this, SLOT(redo()), actions);

    // Rendering menu
    action = new KAction(this);
    action->setText(i18n("Fill Path"));
    action->setIcon(KIcon("rating"));
    action->setCheckable(true);
    connect(action, SIGNAL(triggered(bool)), m_editor, SLOT(selectFilled(bool)));
    actions->addAction("fillPath", action);

    actionGroup = new QActionGroup(this);
    actionGroup->setExclusive(true);

    action = new KAction(this);
    action->setText(i18n("Odd Even Fill"));
    action->setData(Qt::OddEvenFill);
    action->setIcon(KIcon("odd-even-fill"));
    action->setCheckable(true);
    actions->addAction("oddEvenFill", action);
    actionGroup->addAction(action);

    action = new KAction(this);
    action->setText(i18n("Winding Fill"));
    action->setData(Qt::WindingFill);
    action->setIcon(KIcon("winding-fill"));
    action->setCheckable(true);
    actions->addAction("windingFill", action);
    actionGroup->addAction(action);

    connect(actionGroup, SIGNAL(triggered(QAction*)), m_editor, SLOT(selectFillRule(QAction*)));

    actionGroup = new QActionGroup(this);
    actionGroup->setExclusive(true);

    action = new KAction(this);
    action->setText(i18n("Flat Cap"));
    action->setData(Qt::FlatCap);
    action->setIcon(KIcon("flat-cap"));
    action->setCheckable(true);
    actions->addAction("flatCap", action);
    actionGroup->addAction(action);

    action = new KAction(this);
    action->setText(i18n("Square Cap"));
    action->setData(Qt::SquareCap);
    action->setIcon(KIcon("square-cap"));
    action->setCheckable(true);
    actions->addAction("squareCap", action);
    actionGroup->addAction(action);

    action = new KAction(this);
    action->setText(i18n("Round Cap"));
    action->setData(Qt::RoundCap);
    action->setIcon(KIcon("round-cap"));
    action->setCheckable(true);
    actions->addAction("roundCap", action);
    actionGroup->addAction(action);

    connect(actionGroup, SIGNAL(triggered(QAction*)), m_editor, SLOT(selectCapStyle(QAction*)));

    actionGroup = new QActionGroup(this);
    actionGroup->setExclusive(true);

    action = new KAction(this);
    action->setText(i18n("Bevel Join"));
    action->setData(Qt::BevelJoin);
    action->setIcon(KIcon("bevel-join"));
    action->setCheckable(true);
    actions->addAction("bevelJoin", action);
    actionGroup->addAction(action);

    action = new KAction(this);
    action->setText(i18n("Miter Join"));
    action->setData(Qt::MiterJoin);
    action->setIcon(KIcon("miter-join"));
    action->setCheckable(true);
    actions->addAction("miterJoin", action);
    actionGroup->addAction(action);

    action = new KAction(this);
    action->setText(i18n("Round Join"));
    action->setData(Qt::RoundJoin);
    action->setIcon(KIcon("round-join"));
    action->setCheckable(true);
    actions->addAction("roundJoin", action);
    actionGroup->addAction(action);

    connect(actionGroup, SIGNAL(triggered(QAction*)), m_editor, SLOT(selectJoinStyle(QAction*)));

    action = new KAction(this);
    action->setText(i18n("Increase Line Width"));
    action->setIcon(KIcon("increase-line-width"));
    connect(action, SIGNAL(triggered()), m_editor, SLOT(increaseLineWidth()));
    actions->addAction("increaseLineWidth", action);

    action = new KAction(this);
    action->setText(i18n("Decrease Line Width"));
    action->setIcon(KIcon("decrease-line-width"));
    connect(action, SIGNAL(triggered()), m_editor, SLOT(decreaseLineWidth()));
    actions->addAction("decreaseLineWidth", action);

    // Tools Menu
    actionGroup = new QActionGroup(this);
    actionGroup->setExclusive(true);

    action = new KAction(this);
    action->setText(i18n("Move To"));
    action->setData(Editor::MoveTo);
    action->setIcon(KIcon("go-jump"));
    action->setCheckable(true);
    actions->addAction("moveTo", action);
    actionGroup->addAction(action);

    action = new KAction(this);
    action->setText(i18n("Draw To"));
    action->setData(Editor::LineTo);
    action->setIcon(KIcon("draw-line"));
    action->setCheckable(true);
    actions->addAction("lineTo", action);
    actionGroup->addAction(action);

    action = new KAction(this);
    action->setText(i18n("Cubic To"));
    action->setData(Editor::CubicTo);
    action->setIcon(KIcon("draw-bezier-curves"));
    action->setCheckable(true);
    actions->addAction("cubicTo", action);
    actionGroup->addAction(action);

    action = new KAction(this);
    action->setText(i18n("Rectangle"));
    action->setData(Editor::Rectangle);
    action->setIcon(KIcon("draw-rectangle"));
    action->setCheckable(true);
    actions->addAction("rectangle", action);
    actionGroup->addAction(action);

    action = new KAction(this);
    action->setText(i18n("Ellipse"));
    action->setData(Editor::Ellipse);
    action->setIcon(KIcon("draw-ellipse"));
    action->setCheckable(true);
    actions->addAction("ellipse", action);
    actionGroup->addAction(action);

    action = new KAction(this);
    action->setText(i18n("Insert Character"));
    action->setData(Editor::Character);
    action->setIcon(KIcon("character-set"));
    action->setCheckable(true);
    actions->addAction("character", action);
    actionGroup->addAction(action);

    connect(actionGroup, SIGNAL(triggered(QAction*)), m_editor, SLOT(selectTool(QAction*)));

    action = new KAction(this);
    action->setText(i18n("Rotate Left"));
    action->setIcon(KIcon("object-rotate-left"));
    connect(action, SIGNAL(triggered()), m_editor, SLOT(rotateLeft()));
    actions->addAction("rotateLeft", action);

    action = new KAction(this);
    action->setText(i18n("Rotate Right"));
    action->setIcon(KIcon("object-rotate-right"));
    connect(action, SIGNAL(triggered()), m_editor, SLOT(rotateRight()));
    actions->addAction("rotateRight", action);

    action = new KAction(this);
    action->setText(i18n("Flip Horizontal"));
    action->setIcon(KIcon("object-flip-horizontal"));
    connect(action, SIGNAL(triggered()), m_editor, SLOT(flipHorizontal()));
    actions->addAction("flipHorizontal", action);

    action = new KAction(this);
    action->setText(i18n("Flip Vertical"));
    action->setIcon(KIcon("object-flip-vertical"));
    connect(action, SIGNAL(triggered()), m_editor, SLOT(flipVertical()));
    actions->addAction("flipVertical", action);

    action = new KAction(this);
    action->setText(i18n("Scale to Preferred Size"));
    action->setIcon(KIcon("scale-preferred"));
    connect(action, SIGNAL(triggered()), m_editor, SLOT(scalePreferred()));
    actions->addAction("scalePreferred", action);

    action = new KAction(this);
    action->setText(i18n("Enable Snap"));
    action->setIcon(KIcon("snap-to-grid"));
    action->setCheckable(true);
    connect(action, SIGNAL(toggled(bool)), m_editor, SLOT(enableSnap(bool)));
    actions->addAction("enableSnap", action);

    // Settings Menu
    KStandardAction::preferences(this, SLOT(preferences()), actions);
}


void MainWindow::setActionsFromSymbol(const Symbol &symbol)
{
    action("fillPath")->setChecked(symbol.filled());

    switch (symbol.path().fillRule()) {
    case Qt::WindingFill:
        action("windingFill")->setChecked(true);
        break;

    case Qt::OddEvenFill:
        action("oddEvenFill")->setChecked(true);
        break;
    }

    switch (symbol.capStyle()) {
    case Qt::FlatCap:
        action("flatCap")->setChecked(true);
        break;

    case Qt::SquareCap:
        action("squareCap")->setChecked(true);
        break;

    case Qt::RoundCap:
        action("roundCap")->setChecked(true);
        break;
    }

    switch (symbol.joinStyle()) {
    case Qt::BevelJoin:
        action("bevelJoin")->setChecked(true);
        break;

    case Qt::MiterJoin:
        action("miterJoin")->setChecked(true);
        break;

    case Qt::RoundJoin:
        action("roundJoin")->setChecked(true);
        break;
    }

    action("increaseLineWidth")->setDisabled(symbol.lineWidth() == 1.00);
    action("decreaseLineWidth")->setDisabled(symbol.lineWidth() == 0.01);
}