mainwindow.cpp

Go to the documentation of this file.

#include "mainwindow.h"

#include "../Dialogs/newprojectwizard.h"
#include "../Dialogs/newdocumentdialog.h"
#include "../Dialogs/projectinformationdialog.h"
#include "../Dialogs/aboutdialog.h"
#include "../Dialogs/owncapitalcalculationdialog.h"
#include "../Dialogs/settingsdialog.h"
#include "../Dialogs/updaterdialog.h"
#include "../Dialogs/documentchooser.h"
#include "../Dialogs/manageprojectdialog.h"
#include "../Dialogs/bugreportdialog.h"

#include "../Printing/printpreview.h"

#include "../Models/abstractmodel.h"
#include "../Models/documentchoosermodel.h"

#include "../Data/datadefinitions.h"
#include "../Data/project.h"
#include "../Data/aboutdata.h"

#include "../IO/projectfile.h"

#include "../Childwindows/childwindow.h"
#include "../Childwindows/costtypechild.h"
#include "../Childwindows/costcentrechild.h"
#include "../Childwindows/costunitchild.h"
#include "../Childwindows/pricecomparisonchild.h"

#include "actionstab.h"
#include "costtypetab.h"
#include "costcentretab.h"
#include "costunittab.h"
#include "pricecomparisontab.h"

#include "../Updater/manifestdata.h"

MainWindow::MainWindow(QMainWindow *parent) : QMainWindow(parent)
{
    setupUi(this);

    // load settings from previous session (window size, ...)
    settings.setMainWindow(this);
    settings.read();                                        //project history submenus, all settings from settingsdialog

    // UTF-8 encoding for all platforms/files/...
    setEncoding();

    init();
    applyQtHacks();
    applyApplicationName();

    // check for updates (manifest from server), notify the user if updates are available
    initUpdateControls();
    checkForUpdates();
}

void MainWindow::init()
{
    modelListModel = new DocumentChooserModel();
    treeViewDocuments->setModel(modelListModel);

    createActions();
    createSideBar();
    createMdiArea();
    initializePrinter();
    connect(menuWindowList, SIGNAL(aboutToShow()), this, SLOT(updateWindowMenu()));
    updateMenus();

    changeEntryStates(false);                               //no project open
}

void MainWindow::applyQtHacks()
{
    // setContensMargins of QDockWidget is broken before Qt 4.5.1 (not released yet) -- hopefully fixed with 4.5.1
    // see qt bugreport: http://www.qtsoftware.com/developer/task-tracker/index_html?method=entry&id=231085
    // see kde bugreport: https://bugs.kde.org/show_bug.cgi?id=173469
    // ifdef to stay compatible to at least 4.5.0 (assuming we don't use any other features of 4.5)
    #if QT_VERSION < 0x040501
        actionSidebar->setContentsMargins(0,0,0,0);
    #endif
}

void MainWindow::applyApplicationName()
{
    QCoreApplication::setApplicationName("Allevo");
    QCoreApplication::setApplicationVersion("1.9.0.0");
    QCoreApplication::setOrganizationName("FrieSoft");
    QCoreApplication::setOrganizationDomain("I");

    aboutData = new AboutData("Allevo I", "Allevo I", "Allevo I", QCoreApplication::applicationVersion().toAscii(), "Opensource Kostenrechnungsprogramm für Kleinunternehmer", "Copyleft (c) 2009 FrieSoft", "Allevo I ist Teil einer Rechnungswesen Suite, wobei der 1te Teil ein Kostenrechnungsprogramm für den Einsatz in Unternehmen darstellt. Allevo II ist ein Programm zur Erlernung der doppelten Buchhaltung.", "http://allevo.sourceforge.net", "allevo.bugs@gmx.at");

    aboutData->addAuthor("Bernhard Friedreich", "Projektgründer und Entwicklungsleiter", "friesoft@gmail.com", "http://friesoft.wordpress.com");
    aboutData->addAuthor("Richard Lagler", "Projektleiter und Entwickler", "richard.lagler@gmx.at", "");
    aboutData->addAuthor("Christian Fleck", "Entwickler", "chr.off50@gmx.net", "");
    aboutData->addAuthor("Peter Nirschl", "Entwickler", "peter.nirschl@gmail.com", "");
    aboutData->addAuthor("David Madl", "Entwickler", "david@madlnet.net", "");
    aboutData->addAuthor("Oliver Elias", "Dokumentation", "olli.elias@gmail.com", "");

    QList<AboutPerson> people = aboutData->authors();
    aboutData->addCredit("HTBLVA Spengergasse", "Inspiration und Coaching");
    aboutData->addCredit("Sourceforge", "Hosting (Homepage, Source, Mailinglists, ...)", "", "http://sourceforge.net");
    aboutData->addCredit("KDE", "Code/Coding styles/Philosophie/Inspiration, ...", "", "http://kde.org");
    aboutData->addCredit("Subversion", "Versionsverwaltung", "", "http://subversion.tigris.org");
    aboutData->addCredit("Qt-forum.de/org", "Qt Forum", "", "http://qt-forum.de");
    aboutData->addCredit("#qt", "Qt IRC Channel");
    aboutData->addCredit("qt-interest mailing list", "", "qt-interest@trolltech.com");
    aboutData->addCredit("Qt Creator", "Großartige IDE + Code Inspiration");
    aboutData->addCredit("Qt Software/Trolls", "Nur ein Wort: DANKE!");

    setWindowTitle();
}

void MainWindow::setWindowTitle()
{
    QString title = QCoreApplication::organizationName() + " " + QCoreApplication::applicationName() + " " + QCoreApplication::organizationDomain() + " - Kostenrechnung - " + QCoreApplication::applicationVersion();
    if(Project::name() != "")
    {
        title += " - " + Project::name();
    }
    QMainWindow::setWindowTitle(title);
}

void MainWindow::restoreLastGemoetry(QByteArray geo)
{
    restoreGeometry(geo);
}

QList<QDomElement> MainWindow::documentNodes()
{
    QList<QDomElement> documentList;

    DocumentItem *item = modelListModel->rootItem();
    for(int i = 0; i < item->childCount(); i++)
    {
        DocumentItem *documentType = item->child(i);
        for(int documents = 0; documents < documentType->childCount(); documents++)
        {
            DocumentItem *document = documentType->child(documents);
            QDomElement doc = document->model()->documentNode();

            if(!doc.isNull())
            {
                documentList << doc;
            }
        }
    }

    return documentList;
}

QDomElement MainWindow::categoryNodes()
{
    return costtypetab->userCategories();
}

void MainWindow::initializePrinter()
{
    printer = new QPrinter(QPrinter::HighResolution);
}

void MainWindow::createMdiArea()
{
    windowMapper = new QSignalMapper(this);
    connect(mdiArea, SIGNAL(subWindowActivated(QMdiSubWindow *)), this, SLOT(updateMenus()));
    connect(windowMapper, SIGNAL(mapped(QWidget *)),this, SLOT(setActiveSubWindow(QWidget *)));
}

void MainWindow::setEncoding()
{
    QTextCodec::setCodecForTr(QTextCodec::codecForName("UTF-8"));
    QTextCodec::setCodecForLocale(QTextCodec::codecForName("UTF-8"));
    QTextCodec::setCodecForCStrings(QTextCodec::codecForName("UTF-8"));
}

void MainWindow::closeEvent(QCloseEvent *event)
{
    closeProject();
    if(currentWindow())
    {
        event->ignore();
    }
    else
    {
        settings.write();
        event->accept();
    }
}

void MainWindow::createNewDocument(WindowType::Type type, QString name)
{
    int fileid = Project::highestFileID();
    fileid++;
    Project::setHighestFileID(fileid);

    switch(type)
    {
        case WindowType::CostType:
        {
            newCostTypeFile(fileid, name);
            break;
        }
        case WindowType::CostCentre:
        {
            newCostCentreFile(fileid, name);
            break;
        }
        case WindowType::CostUnit:
        {
            newCostUnitFile(fileid, name);
            break;
        }
        case WindowType::PriceComparison:
        {
            newPriceComparisonFile(fileid, name);
            break;
        }
    default:
        {
            QMessageBox::critical(this, tr("Fehler"), tr("Es trat ein Fehler beim erstellen des Dokuments auf! Der Dateityp ist nicht gültig!"));
            break;
        }
    }
}

void MainWindow::newCostTypeFile(int id, QString name, QDomElement file)
{
    CostTypeModel *model = new CostTypeModel((uint)id, (uint)WindowType::CostType, name, this);
    modelListModel->addDocument(model);

    openCostTypeFile(model, file);
}

void MainWindow::openCostTypeFile(CostTypeModel *model, QDomElement file)
{
    CostTypeChild *child = createCostTypeChild();
    child->setModel(model);
    child->newFile();
    if(file.childNodes().count() != 0)
    {
        child->loadDocument(file);
    }
    child->show();
    connect(child, SIGNAL(destroyed(QObject*)), this, SLOT(cleanUpSidebar()));
    connect(child, SIGNAL(editInformationAvailable(const CostTypeModel *, const QModelIndexList)), costtypetab, SLOT(enterEditPositionInformation(const CostTypeModel*, const QModelIndexList)));
    connect(child, SIGNAL(setMdiAreaEnabled(bool)), mdiArea, SLOT(setEnabled(bool)));
    connect(child->ownCapitalDialog, SIGNAL(sendingData(QString)), costtypetab->groupBoxCompleteCosts->textOperatingAssets, SLOT(setText(QString)));
}

void MainWindow::newCostCentreFile(int id, QString name, QDomElement file)
{
    DocumentChooser *chooser = new DocumentChooser(WindowType::CostType, id, name, file, modelListModel, this);
    chooser->show();
    connect(chooser, SIGNAL(documentSelected(DocumentItem, int, QString, QDomElement)), this, SLOT(openCostCentreModel(DocumentItem, int, QString, QDomElement)));
}

void MainWindow::openCostCentreFromProjectFile(int id, QString name, QDomElement file)
{
    CostCentreModel *model = new CostCentreModel((uint)id, (uint)WindowType::CostCentre, name, this);
    modelListModel->addDocument(model);

    openCostCentreFile(model, NULL, id, name, file);
}

void MainWindow::openCostCentreModel(DocumentItem callByValueItem, int id, QString name, QDomElement file)
{
    DocumentItem *item = referenceFromItem(callByValueItem);
    if(item != NULL)
    {
        qDebug()<<"FIXME: check should be added here if conversion is valid";
        openCostCentreFile(NULL, (CostTypeModel*)item->model(), id, name, file);
    }
}

void MainWindow::openCostCentreFile(CostCentreModel *model, CostTypeModel *costtype, int id, QString name, QDomElement file)     //file = document from file, costcentremodel = document from documentchooser
{
    if(!model)
    {
        model = new CostCentreModel((uint)id, (uint)WindowType::CostCentre, name, this);
        modelListModel->addDocument(model);
    }

    CostCentreChild *child = createCostCentreChild();

    child->setModel(model);

    child->newFile();
    if(file.childNodes().count() != 0)
    {
        child->loadDocument(file);
    }

    if(costtype != NULL)
    {
        child->setCostTypeModel(costtype);
    }
    else
    {
        int costTypeFileId = child->model()->costTypeFileIdentification();
        CostTypeModel *costtypemodel = modelListModel->costTypeModelById(costTypeFileId);
        child->setCostTypeModel(costtypemodel);
    }

    child->show();
    connect(child, SIGNAL(destroyed(QObject*)), this, SLOT(cleanUpSidebar()));
}

void MainWindow::newCostUnitFile(int id, QString name, QDomElement file)
{
    qDebug()<<"id: " << id << "Costunit: " << WindowType::CostUnit << "Name: " << name;
    CostUnitModel *model = new CostUnitModel(settings, (uint)id, (uint)WindowType::CostUnit, name, this);
    modelListModel->addDocument(model);

    openCostUnitFile(model, file);
}

void MainWindow::openCostUnitFile(CostUnitModel *model, QDomElement file)
{
    CostUnitChild *child = createCostUnitChild();

    child->setModel(model);
    child->newFile();
    if(file.childNodes().count() != 0)
    {
        child->loadDocument(file);
    }
    child->show();

    connect(child, SIGNAL(destroyed(QObject*)), this, SLOT(cleanUpSidebar()));

}

void MainWindow::newPriceComparisonFile(int id, QString name, QDomElement file)
{
    AbstractModel *model = new AbstractModel(id, WindowType::PriceComparison, name);
    modelListModel->addDocument(model);

    openPriceComparisonFile(model, file);
}

void MainWindow::openPriceComparisonFile(AbstractModel *model, QDomElement file)
{
    PriceComparisonChild *child = createPriceComparisonChild();
    child->setDocumentInfoModel(model);
    child->setModelList(modelListModel);

    if(file.childNodes().count() != 0)
    {
        child->loadDocument(file);
    }
    child->show();
}

CostTypeChild* MainWindow::createCostTypeChild()
{
    CostTypeChild *child = new CostTypeChild;
    mdiArea->addSubWindow(child);
    return child;
}

CostCentreChild* MainWindow::createCostCentreChild()
{
    CostCentreChild *child = new CostCentreChild;
    mdiArea->addSubWindow(child);
    return child;
}

CostUnitChild* MainWindow::createCostUnitChild()
{
    CostUnitChild *child = new CostUnitChild(settings);
    mdiArea->addSubWindow(child);
    return child;
}

PriceComparisonChild* MainWindow::createPriceComparisonChild()
{
    PriceComparisonChild *child = new PriceComparisonChild(settings);
    mdiArea->addSubWindow(child);
    return child;
}

DocumentItem* MainWindow::referenceFromItem(DocumentItem callByValueItem)
{
    AbstractModel *model = callByValueItem.model();
    if(model->fileId() != -1 && model->fileName() != "" && model->type() != -1)
    {
        // because the item is a call by value variable we need to find the correct item in the model now
        return modelListModel->documentItem(model->fileId(), model->type());
    }
    else
    {
        return NULL;
    }
}

void MainWindow::openDocument(const QModelIndex &index)
{
    DocumentItem *item = referenceFromItem(index.data(32).value<DocumentItem>());
    if(item != NULL)
    {
        AbstractModel *model = item->model();
        if(!modelIsAlreadyOpened(model))
        {
            qDebug()<<"FIXME: add checks if the documenttype is correct and if the cast will be successful -- otherwise it will crash! -- evaluate QSharedPointer";
            switch(model->type())
            {
                case WindowType::CostType:
                {
                    openCostTypeFile((CostTypeModel*)model);
                    break;
                }
                case WindowType::CostCentre:
                {
                    openCostCentreFile((CostCentreModel*)model);
                    break;
                }
                case WindowType::CostUnit:
                {
                    openCostUnitFile((CostUnitModel*)model);
                    break;
                }
                case WindowType::PriceComparison:
                {
                    openPriceComparisonFile(model);
                    break;
                }
            }
        }
        else
        {
            // model is already opened -- switch to the childwindow
            switchChildWindowByModel(model);
        }
    }
}

void MainWindow::closeDocumentWindow(const QString name)
{
    qDebug()<<"document to close (name): " << name;
    QMdiSubWindow *window = childWindowByName(name);
    qDebug()<<"window to close: " << window;
    if(window != NULL)
    {
        mdiArea->setActiveSubWindow(window);
        mdiArea->closeActiveSubWindow();
    }
}

bool MainWindow::modelIsAlreadyOpened(AbstractModel *model)
{
    if(childWindowByModel(model) == NULL)
    {
        return false;
    }
    else
    {
        return true;
    }
}

QMdiSubWindow* MainWindow::childWindowByName(const QString &name)
{
    DocumentItem *root = modelListModel->rootItem();
    for(int i = 0; i < root->childCount(); i++)
    {
        qDebug()<<"types: " << i;
        DocumentItem *cat = root->child(i);
        for(int j = 0; j < cat->childCount(); j++)
        {
            qDebug()<<"docs: " << j;
            DocumentItem *doc = cat->child(j);
            qDebug()<<"doc->fileName(): " << doc->fileName();
            qDebug()<<"name: " << name;
            if(QString::compare(doc->fileName(), name, Qt::CaseInsensitive) == 0)
            {
                AbstractModel *model = doc->model();
                qDebug()<<"model by name: " << name << " model: " << model;
                if(model != NULL)
                {
                    return childWindowByModel(model);
                }
            }
        }
    }
    return NULL;
}

QMdiSubWindow* MainWindow::childWindowByModel(AbstractModel *model)
{
    qDebug()<<"switchChildWindowByModel";
    QMdiSubWindow *window = NULL;
    foreach(window, mdiArea->subWindowList())
    {
        qDebug()<<"window: " << window;
        qDebug()<<"window->widget(): " << window->widget();
        ChildWindow *child = qobject_cast<ChildWindow*>(window->widget());
        qDebug()<<"child: " << child;
        if(child)
        {
            AbstractModel *childWindowModel = NULL;
            if(child->type() == WindowType::CostType)
            {
                CostTypeChild *cost = qobject_cast<CostTypeChild*>(child);
                childWindowModel = cost->model();
            }
            else if(child->type() == WindowType::CostCentre)
            {
                CostCentreChild *coce = qobject_cast<CostCentreChild*>(child);
                childWindowModel = coce->model();
            }
            else if(child->type() == WindowType::CostUnit)
            {
                CostUnitChild *coun = qobject_cast<CostUnitChild*>(child);
                childWindowModel = coun->model();
            }
            else if(child->type() == WindowType::PriceComparison)
            {
                PriceComparisonChild *prco = qobject_cast<PriceComparisonChild*>(child);
                childWindowModel = prco->model();
            }
            if(childWindowModel != NULL)
            {
                if(QString::compare(model->fileName(), childWindowModel->fileName(), Qt::CaseInsensitive) == 0)
                {
                    return window;
                }
            }
        }
        else
        {
            qDebug()<<"child not valid";
        }
    }
    return NULL;
}

void MainWindow::switchChildWindowByModel(AbstractModel *model)
{
    QMdiSubWindow *window = childWindowByModel(model);
    if(window != NULL)
    {
        mdiArea->setActiveSubWindow(window);
    }
}

void MainWindow::openProject()
{
    QFileDialog dialog(this);
    QString path = dialog.getOpenFileName(this, tr("Projekt öffnen"), settings.workspace().absolutePath(), tr("Allevo I Kostenrechnungs Projekt") + " (*.cst)");
    if(!path.isEmpty() && QFile(path).exists())
    {
        qDebug()<<"openProject: " << path;
        Project::setPath(path);
        openProject(path);
    }
}

void MainWindow::openProject(QString path)              //path = absolute path
{
    ProjectFile *project = new ProjectFile();
    connect(project, SIGNAL(createCostTypeFile(int,QString,QDomElement)), this, SLOT(newCostTypeFile(int, QString, QDomElement)));
    connect(project, SIGNAL(createCostCentreFile(int,QString,QDomElement)), this, SLOT(openCostCentreFromProjectFile(int, QString, QDomElement)));
    connect(project, SIGNAL(createCostUnitFile(int, QString, QDomElement)), this, SLOT(newCostUnitFile(int, QString, QDomElement)));
    connect(project, SIGNAL(loadUserCategory(QDomElement)), costtypetab, SLOT(loadUserCategories(QDomElement)));

    costtypetab->readCostPositions();

    if(!project->readProject() && Project::locked() == 1)
    {
        // e.g.: project is locked -- messagebox get's fired in the projectfile class
        return ;
    }

    setWindowTitle();
    changeEntryStates(true);                            //project open

    Project::setLocked(true);
    saveProject();
}

void MainWindow::openProject(QAction *action)
{
    // this method opens up a project from the recent projects menu -- the action is the project-item beeing clicked in the menu
}

void MainWindow::changeEntryStates(bool en)
{
    actionCloseProject->setEnabled(en);
    actionNewDocument->setEnabled(en);

    actionstab->setProjectOpen(en);

    actionProjectProperties->setEnabled(en);
    actionSaveProject->setEnabled(en);
    actionManageDocuments->setEnabled(en);
    menuWindowList->setEnabled(en);

    actionOpenProject->setEnabled(!en);
    actionNewProject->setEnabled(!en);
}

void MainWindow::closeProject()
{
    Project::setLocked(false);
    saveProject();
    mdiArea->closeAllSubWindows();

    QList<QMdiSubWindow *> windows = mdiArea->subWindowList();
    if(windows.count() == 0)
    {
        // remove all documents
        modelListModel->clear();

        Project::clear();

        changeEntryStates(false);               //kein projekt offen

        setCurrentSidebarTab(0);
        costtypetab->clearEntries();

        setWindowTitle();

        /*delete costtypetab;
        delete costcentretab;
        delete costunittab;
        delete pricecomparisontab;
        costtypetab = NULL;
        costcentretab = NULL;
        costunittab = NULL;
        pricecomparisontab = NULL;*/
    }
}

void MainWindow::createNewProject()
{
    NewProjectWizard *wizard = new NewProjectWizard(settings);

    connect(wizard, SIGNAL(createdProject()), this, SLOT(openNewProject()));

    wizard->show();
}

void MainWindow::openNewProject()
{
    qDebug()<<"openNewProject: " << Project::path();
    openProject(Project::path());
}

void MainWindow::saveProject()
{
    ProjectFile *project = new ProjectFile();
    qDebug()<<"saveProject: " << Project::path();
    project->writeProject(documentNodes(), categoryNodes());
}

void MainWindow::reportBugs()
{
    BugReportDialog *dialog = new BugReportDialog(settings, &mailerThread, this);
    dialog->show();
}

void MainWindow::bugReportSent()
{
    QMessageBox::information(this, "Fehlerbericht erfolgreich gesendet!", "Vielen Dank, dass Sie Ihren Beitrag dazu geleistet haben Allevo zu verbessern!");
}

void MainWindow::bugReportSendError(QString message)
{
    QMessageBox::critical(this, "Fehler beim Senden", "Leider trat ein Fehler beim Senden des Fehlerberichts auf! Möglicherweise lässt Ihre Firewall keinen SMTP Zugriff zu :-(\r\nMeldung:\r\n" + message);
}

void MainWindow::about()
{
    AboutDialog *about = new AboutDialog(aboutData, this);
    about->show();
}

void MainWindow::updateMenus()
{
    bool hasMdiChild = (currentWindow() != 0);

    // change sidebar to match the childwindow type
    windowChanged();

    actionSaveProject->setEnabled(hasMdiChild);
    actionClose->setEnabled(hasMdiChild);
    actionCloseAll->setEnabled(hasMdiChild);
    actionSplitWindows->setEnabled(hasMdiChild);
    actionAdjustWindowsOnGrid->setEnabled(hasMdiChild);
    actionNextWindow->setEnabled(hasMdiChild);
    actionLastWindow->setEnabled(hasMdiChild);
    actionPrintPreview->setEnabled(hasMdiChild);
    actionPrint->setEnabled(hasMdiChild);

    // do I need to update this now -- seems unnecessary cause it get's updated as soon as it's aboutToShow
    // updateWindowMenu();
}

void MainWindow::updateWindowMenu()
{
    menuWindowList->clear();

    QList<QMdiSubWindow *> windows = mdiArea->subWindowList();

    for (int i = 0; i < windows.size(); ++i)
    {
        ChildWindow *childwindow = qobject_cast<ChildWindow *>(windows.value(i)->widget());
        QString text;
        if(i < 9)
        {
            if(childwindow->type() == WindowType::CostType)
            {
                text = tr("&%1 %2 - Kostenartenrechnung").arg(i + 1).arg(qobject_cast<CostTypeChild *>(childwindow)->windowTitle());
            }
            else if(childwindow->type() == WindowType::CostCentre)
            {
                text = tr("&%1 %2 - Kostenstellenrechnung").arg(i + 1).arg(qobject_cast<CostCentreChild *>(childwindow)->windowTitle());
            }
            else if(childwindow->type() == WindowType::CostUnit)
            {
                text = tr("&%1 %2 - Kostenträgerrechnung").arg(i + 1).arg(qobject_cast<CostUnitChild *>(childwindow)->windowTitle());
            }
            else if(childwindow->type() == WindowType::PriceComparison)
            {
                text = tr("&%1 %2 - Preisvergleich").arg(i + 1).arg(qobject_cast<PriceComparisonChild *>(childwindow)->windowTitle());
            }
        }
        else
        {
            if(childwindow->type() == WindowType::CostType)
            {
                text = tr("%1 %2 - Kostenartenrechnung").arg(i + 1).arg(qobject_cast<CostTypeChild *>(childwindow)->windowTitle());
            }
            else if(childwindow->type() == WindowType::CostCentre)
            {
                text = tr("%1 %2 - Kostenstellenrechnung").arg(i + 1).arg(qobject_cast<CostCentreChild *>(childwindow)->windowTitle());
            }
            else if(childwindow->type() == WindowType::CostUnit)
            {
                text = tr("%1 %2 - Kostenträgerrechnung").arg(i + 1).arg(qobject_cast<CostUnitChild *>(childwindow)->windowTitle());
            }
            else if(childwindow->type() == WindowType::PriceComparison)
            {
                text = tr("%1 %2 - Preisvergleich").arg(i + 1).arg(qobject_cast<PriceComparisonChild *>(childwindow)->windowTitle());
            }
        }
        QAction *action  = menuWindowList->addAction(text);
        action->setCheckable(true);
        action->setChecked(childwindow == currentWindow());
        connect(action, SIGNAL(triggered()), windowMapper, SLOT(map()));
        windowMapper->setMapping(action, windows.value(i));
    }
}

void MainWindow::createSideBar()
{
    actionstab = new ActionsTab();
    costtypetab = new CostTypeTab(mdiArea);
    costcentretab = new CostCentreTab(settings, mdiArea);
    costunittab = new CostUnitTab();
    pricecomparisontab = new PriceComparisonTab();

    sidebarTabWidget->clear();
    sidebarTabWidget->addTab(actionstab, tr("Allgemein"));
    actionSidebar->setWidget(sidebarTabWidget);

    connect(actionstab, SIGNAL(createProject()), this, SLOT(createNewProject()));
    connect(actionstab, SIGNAL(openProject()), this, SLOT(openProject()));
    connect(actionstab, SIGNAL(closeProject()), this, SLOT(closeProject()));
    connect(actionstab, SIGNAL(newDocument()), this, SLOT(newDocumentDialog()));
    connect(actionstab, SIGNAL(importDocuments()), this, SLOT(importFile()));
}

void MainWindow::setCurrentSidebarTab(int index)
{
    sidebarTabWidget->setCurrentIndex(index);
}

void MainWindow::cleanUpSidebar()
{
    sidebarTabWidget->clear();
    sidebarTabWidget->addTab(actionstab, tr("Allgemein"));
}

void MainWindow::changeCurrentDocumentSidebarTab(ChildWindow *child, int type)
{
    cleanUpSidebar();

    switch(type)
    {
        case WindowType::CostType:
        {
            sidebarTabWidget->addTab(costtypetab, tr("Kostenartenrechnung"));

            CostTypeChild *costtypechild = qobject_cast<CostTypeChild*>(child);
            OwnCapitalCalculationDialog *ownCapitalDialog = costtypechild->ownCapitalDialog;
            costtypechild->model()->setOwnCapitalModel(costtypechild->ownCapitalDialog->model);

            // disconnect ALL slots connected to the sidebar
            disconnect(costtypetab->groupBoxCompleteCosts, 0, 0, 0);

            connect(costtypetab->groupBoxCompleteCosts, SIGNAL(showOwnCapitalCalculationDialog()), ownCapitalDialog, SLOT(show()));
            break;
        }
        case WindowType::CostCentre:
        {
            sidebarTabWidget->addTab(costcentretab, tr("Kostenstellenrechnung"));
            costcentretab->setModel(((CostCentreChild*)currentWindow())->costTypeModel());

            break;
        }
        case WindowType::CostUnit:
        {
            sidebarTabWidget->addTab(costunittab, tr("Kostenträgerrechnung"));

            CostUnitChild *tempChild = qobject_cast<CostUnitChild*>(child);

            // disconnect ALL slots connected to the sidebar
            disconnect(costunittab, 0, 0, 0);

            connect(costunittab, SIGNAL(additionalChargesChangedCostUnit(QList<int>)), tempChild, SLOT(setAdditionalCharges(QList<int>)));
            connect(costunittab, SIGNAL(addProductCostUnit(QString, QString, QString, QString, QString, QString, QString)), tempChild, SLOT(setProduct(QString, QString, QString, QString, QString, QString, QString)));
            break;
        }
        case WindowType::PriceComparison:
        {
            PriceComparisonChild *price = qobject_cast<PriceComparisonChild*>(child);
            sidebarTabWidget->addTab(pricecomparisontab, tr("Preisvergleich"));
            break;
        }
        default:
        {
            break;
        }
    }
    if(sidebarTabWidget->count() > 1)
    {
        sidebarTabWidget->setCurrentIndex(1);
    }
    else
    {
        sidebarTabWidget->setCurrentIndex(0);
    }
}

void MainWindow::newDocumentDialog()
{
    NewDocumentDialog *dialog = new NewDocumentDialog(modelListModel, this);
    dialog->show();
    connect(dialog, SIGNAL(createDocument(WindowType::Type, QString)), this, SLOT(createNewDocument(WindowType::Type, QString)));
}

void MainWindow::createActions()
{
    connect(actionNewProject, SIGNAL(triggered()), this, SLOT(createNewProject()));
    connect(actionCloseProject, SIGNAL(triggered()), this, SLOT(closeProject()));
    connect(actionNewDocument, SIGNAL(triggered()), this, SLOT(newDocumentDialog()));
    connect(actionOpenProject, SIGNAL(triggered()), this, SLOT(openProject()));
    connect(actionProjectProperties, SIGNAL(triggered()), this, SLOT(showProjectInformation()));
    connect(actionSaveProject, SIGNAL(triggered()), this, SLOT(saveProject()));
    connect(actionExit, SIGNAL(triggered()), qApp, SLOT(closeAllWindows()));
    connect(actionClose, SIGNAL(triggered()), mdiArea, SLOT(closeActiveSubWindow()));
    connect(actionCloseAll, SIGNAL(triggered()), mdiArea, SLOT(closeAllSubWindows()));
    connect(actionPrintPreview, SIGNAL(triggered()), this, SLOT(printPreview()));
    connect(actionPrint, SIGNAL(triggered()), this, SLOT(print()));
    connect(actionAdjustWindowsOnGrid, SIGNAL(triggered()), mdiArea, SLOT(tileSubWindows()));
    connect(actionSplitWindows, SIGNAL(triggered()), mdiArea, SLOT(cascadeSubWindows()));
    connect(actionNextWindow, SIGNAL(triggered()),mdiArea, SLOT(activateNextSubWindow()));
    connect(actionLastWindow, SIGNAL(triggered()),mdiArea, SLOT(activatePreviousSubWindow()));
    connect(actionReportBug, SIGNAL(triggered()), this, SLOT(reportBugs()));
    connect(actionManageDocuments, SIGNAL(triggered()),this, SLOT(manageProject()));
    connect(actionWorkspaceSettings, SIGNAL(triggered()), this, SLOT(openWorkspaceSettings()));
    connect(actionSettings, SIGNAL(triggered()), this, SLOT(showSettingsDialog()));
    connect(actionAboutAllevo, SIGNAL(triggered()), this, SLOT(about()));
    connect(actionAboutQt, SIGNAL(triggered()), qApp, SLOT(aboutQt()));
    connect(actionCheckForUpdates, SIGNAL(triggered()), this, SLOT(checkForUpdates()));
    connect(actionHelp, SIGNAL(triggered()), this, SLOT(openHelpBrowser()));
    connect(treeViewDocuments, SIGNAL(doubleClicked(const QModelIndex)), this, SLOT(openDocument(const QModelIndex)));
    //connect(documentTabs, SIGNAL(currentChanged(int)), this, SLOT(updateActions()));

    connect(&mailerThread, SIGNAL(mailSent()), this, SLOT(bugReportSent()));
    connect(&mailerThread, SIGNAL(sendMailError(QString)), this, SLOT(bugReportSendError(QString)));
}

void MainWindow::manageProject()
{
    ManageProjectDialog *dialog = new ManageProjectDialog(modelListModel, this);
    connect(dialog, SIGNAL(deleteDocumentWindow(const QString)), this, SLOT(closeDocumentWindow(const QString)));
    dialog->show();
}

void MainWindow::openWorkspaceSettings()
{
    showSettingsDialog(1);
}


void MainWindow::initUpdateControls()
{
    updateInfo = new QLabel(" ", this);
    updateInfo->setMinimumWidth(200);

    statusBar()->addWidget(updateInfo);
}

// Called at startup
void MainWindow::checkForUpdates()
{
    if(settings.automaticCheckForUpdates())
    {
        connect(&(this->updaterManifestThread), SIGNAL(manifestReady()), this, SLOT(manifestParsed()));
        connect(&(this->updaterManifestThread), SIGNAL(errorOccured()), this, SLOT(mainfestErrorOccured()));
        this->updaterManifestThread.start();

        // set widgets to show infos about what's going on in the background
        updateInfo->setText("UPDATER: Updates werden gesucht...");
        updateInfo->show();
    }
}

void MainWindow::manifestParsed()
{
    // TODO: fetch data from thread
    // this->updaterManifestThread.getManifestData()
    updateInfo->setText("Update Informationen erfolgreich geholt");
}

void MainWindow::mainfestErrorOccured()
{
    updateInfo->setText("Fehler beim Beziehen der Update Informationen!");
}

void MainWindow::showSettingsDialog()
{
    SettingsDialog *configuration = new SettingsDialog(settings, this);
    configuration->show();
}

void MainWindow::showSettingsDialog(int page)
{
    SettingsDialog *configuration = new SettingsDialog(settings, this);
    configuration->setActivePage(page);
    configuration->show();
}

ChildWindow* MainWindow::currentWindow()
{
    if(QMdiSubWindow *activeSubWindow = mdiArea->activeSubWindow())
    {
        return qobject_cast<ChildWindow*>(activeSubWindow->widget());
    }
    return 0;
}

void MainWindow::windowChanged()
{
    if(QMdiSubWindow *activeSubWindow = mdiArea->activeSubWindow())
    {
        ChildWindow *child = qobject_cast<ChildWindow*>(activeSubWindow->widget());
        if(child != NULL)
        {
            changeCurrentDocumentSidebarTab(child, child->type());
        }
    }
}

QMdiSubWindow *MainWindow::findChild(const QString &fileName)
{
    QString canonicalFilePath = QFileInfo(fileName).canonicalFilePath();

    foreach(QMdiSubWindow *window, mdiArea->subWindowList())
    {
        if((qobject_cast<ChildWindow*>(window->widget()))->type() == WindowType::CostType)
        {
            CostTypeChild *child = qobject_cast<CostTypeChild *>(window->widget());
            if(child->windowTitle() == canonicalFilePath)
            {
                return window;
            }
        }
        else if((qobject_cast<ChildWindow*>(window->widget()))->type() == WindowType::CostCentre)
        {
            CostCentreChild *child = qobject_cast<CostCentreChild *>(window->widget());
            if(child->windowTitle() == canonicalFilePath)
            {
                return window;
            }
        }
        else if((qobject_cast<ChildWindow*>(window->widget()))->type() == WindowType::CostUnit)
        {
            CostUnitChild *child = qobject_cast<CostUnitChild *>(window->widget());
            if(child->windowTitle() == canonicalFilePath)
            {
                return window;
            }
        }
        else if((qobject_cast<ChildWindow*>(window->widget()))->type() == WindowType::PriceComparison)
        {
            PriceComparisonChild *child = qobject_cast<PriceComparisonChild *>(window->widget());
            if(child->windowTitle() == canonicalFilePath)
            {
                return window;
            }
        }
    }
    return 0;
}

void MainWindow::setActiveSubWindow(QWidget *window)
{
    if(!window)
    {
        return;
    }
    mdiArea->setActiveSubWindow(qobject_cast<QMdiSubWindow *>(window));
}

void MainWindow::showProjectInformation()
{
    ProjectInformationDialog *info = new ProjectInformationDialog(this);
    info->show();
}

void MainWindow::openHelpBrowser()
{
    HelpBrowserDialog *browser = new HelpBrowserDialog(aboutData);
    browser->show();
}

void MainWindow::importFile()
{
    qDebug()<<"FIXME: Let the user choose which documents of another project he wants to import";
}

void MainWindow::print()
{
    ChildWindow *child = currentWindow();
    if(child->type() == WindowType::CostType)
    {
        CostTypeChild *koat = qobject_cast<CostTypeChild*>(child);
        PrintPreviewDialog *dialog = new PrintPreviewDialog(koat->windowTitle(), koat->tableViewWidget(), printer, this);
        dialog->print();
        delete dialog;
    }
    else if(child->type() == WindowType::CostCentre)
    {
        CostCentreChild *kost = qobject_cast<CostCentreChild*>(child);
        PrintPreviewDialog *dialog = new PrintPreviewDialog(kost->windowTitle(), kost->tableViewWidget(), printer, this);

        dialog->print();
        delete dialog;
    }
    else if(child->type() == WindowType::CostUnit)
    {
        CostUnitChild *kotr = qobject_cast<CostUnitChild*>(child);
        PrintPreviewDialog *dialog = new PrintPreviewDialog(kotr->windowTitle(), kotr->tableViewWidget(), printer, this);
        dialog->print();
        delete dialog;
    }
    else if(child->type() == WindowType::PriceComparison)
    {
        /*PriceComparisonChild *prco = qobject_cast<PriceComparisonChild*>(child);
        PrintPreviewDialog *dialog = new PrintPreviewDialog(prco->windowTitle(), prco->tableView, printer, this);
        dialog->print();
        delete dialog;*/
    }
}

void MainWindow::printPreview()
{
    ChildWindow *child = currentWindow();

    if(child->type() == WindowType::CostType)
    {
        CostTypeChild *koat = qobject_cast<CostTypeChild*>(child);
        PrintPreviewDialog *dialog = new PrintPreviewDialog(koat->windowTitle(), koat->tableViewWidget(), printer, this);
        dialog->exec();
        delete dialog;
    }
    else if(child->type() == WindowType::CostCentre)
    {
        CostCentreChild *kost = qobject_cast<CostCentreChild*>(child);
        PrintPreviewDialog *dialog = new PrintPreviewDialog(kost->windowTitle(), kost->tableViewWidget(), printer, this);
        dialog->exec();
        delete dialog;
    }
    else if(child->type() == WindowType::CostUnit)
    {
        CostUnitChild *kotr = qobject_cast<CostUnitChild*>(child);
        PrintPreviewDialog *dialog = new PrintPreviewDialog(kotr->windowTitle(), kotr->tableViewWidget(), printer, this);
        dialog->exec();
        delete dialog;
    }
    else if(child->type() == WindowType::PriceComparison)
    {
        /*PriceComparisonChild *prco = qobject_cast<PriceComparisonChild*>(child);
        PrintPreviewDialog *dialog = new PrintPreviewDialog(prco->windowTitle(), prco->tableView, printer, this);
        dialog->exec();
        delete dialog;*/
    }
}

---