/media/hdb5/canorusNightlyBuildSystem/trunk/src/canorus.cpp

Go to the documentation of this file.

// Python.h needs to be loaded first!
#include "scripting/swigpython.h"
#include "canorus.h"

#include <QFileInfo>
#include <QDir>
#include <QCoreApplication>
#include <QTranslator>
#include <QLocale>

#include "interface/rtmididevice.h"
#include "ui/settingsdialog.h"
#include "scripting/swigruby.h"
#include "core/sheet.h"
#include "core/settings.h"
#include "core/undo.h"

// define private static members
QApplication *CACanorus::_mainApp;
QList<CAMainWin*> CACanorus::_mainWinList;
CASettings *CACanorus::_settings;
QString CACanorus::_settingsPath;
CAAutoRecovery *CACanorus::_autoRecovery;
CAMidiDevice *CACanorus::_midiDevice;
CAUndo *CACanorus::_undo;
QList<QString> CACanorus::_recentDocumentList;

QList<QString> CACanorus::locateResource(const QString fileName) {
        QList<QString> paths;
        QString curPath;
        
        // Try absolute path
        curPath = fileName;
        if (QFileInfo(curPath).exists())
                paths << QFileInfo(curPath).absoluteFilePath();
        
        // Try current working directory
        curPath = QDir::currentPath() + "/" + fileName;
        if (QFileInfo(curPath).exists())
                paths << QFileInfo(curPath).absoluteFilePath();
        
        // Try application exe directory
        curPath = QCoreApplication::applicationDirPath() + "/" + fileName;
        if (QFileInfo(curPath).exists())
                paths << QFileInfo(curPath).absoluteFilePath();
        
#ifdef DEFAULT_DATA_DIR
        // Try compiler defined DEFAULT_DATA_DIR constant (useful on Unix OSes)
        curPath = QString(DEFAULT_DATA_DIR) + "/" + fileName;
        if (QFileInfo(curPath).exists())
                paths << QFileInfo(curPath).absoluteFilePath();
        
#endif
        
        // Try the source ui/ directory (images etc.)
        curPath = QCoreApplication::applicationDirPath() + "/ui/" + fileName;
        if (QFileInfo(curPath).exists())
                        paths << QFileInfo(curPath).absoluteFilePath();
        
        // Remove duplicates. Is there a faster way to do this?
        return paths.toSet().toList();
}

QList<QString> CACanorus::locateResourceDir(const QString fileName) {
        QList<QString> paths = CACanorus::locateResource(fileName);
        for (int i=0; i<paths.size(); i++)
                paths[i] = paths[i].left(paths[i].lastIndexOf("/"));
        
        // Remove duplicates. Is there a faster way to do this?
        return paths.toSet().toList();
}

void CACanorus::initMain( int argc, char *argv[] ) {
        _autoRecovery = 0;
        
        // Init main application properties
        QCoreApplication::setOrganizationName("Canorus");
        QCoreApplication::setOrganizationDomain("canorus.org");
        QCoreApplication::setApplicationName("Canorus");
}

void CACanorus::initCommonGUI() {
        // Initialize main window's load/save/import/export dialogs
        CAMainWin::uiSaveDialog = new QFileDialog(0, QObject::tr("Choose a file to save"), settings()->documentsDirectory().absolutePath());
        CAMainWin::uiSaveDialog->setFileMode(QFileDialog::AnyFile);
        CAMainWin::uiSaveDialog->setAcceptMode( QFileDialog::AcceptSave );
        CAMainWin::uiSaveDialog->setFilters( QStringList() << CAFileFormats::CANORUSML_FILTER );
        CAMainWin::uiSaveDialog->setFilters( CAMainWin::uiSaveDialog->filters() << CAFileFormats::CAN_FILTER );
        CAMainWin::uiSaveDialog->selectFilter( CAFileFormats::getFilter( settings()->defaultSaveFormat() ) );
        
        CAMainWin::uiOpenDialog = new QFileDialog(0, QObject::tr("Choose a file to open"), settings()->documentsDirectory().absolutePath());
        CAMainWin::uiOpenDialog->setFileMode( QFileDialog::ExistingFile );
        CAMainWin::uiOpenDialog->setAcceptMode( QFileDialog::AcceptOpen );
        CAMainWin::uiOpenDialog->setFilters( QStringList() << CAFileFormats::CANORUSML_FILTER ); // clear the * filter
        CAMainWin::uiOpenDialog->setFilters( CAMainWin::uiOpenDialog->filters() << CAFileFormats::CAN_FILTER );
        QString allFilters; // generate list of all files
        for (int i=0; i<CAMainWin::uiOpenDialog->filters().size(); i++) {
                QString curFilter = CAMainWin::uiOpenDialog->filters()[i];
                int left = curFilter.indexOf('(')+1;
                allFilters += curFilter.mid( left, curFilter.size()-left-1 ) + " ";
        }
        allFilters.chop(1);
        CAMainWin::uiOpenDialog->setFilters( QStringList() << QString(QObject::tr("All supported formats (%1)").arg(allFilters)) << CAMainWin::uiOpenDialog->filters() );
        
        CAMainWin::uiExportDialog = new QFileDialog(0, QObject::tr("Choose a file to export"), settings()->documentsDirectory().absolutePath());
        CAMainWin::uiExportDialog->setFileMode(QFileDialog::AnyFile);
        CAMainWin::uiExportDialog->setAcceptMode( QFileDialog::AcceptSave );
        CAMainWin::uiExportDialog->setFilters( QStringList() << CAFileFormats::LILYPOND_FILTER );
        CAMainWin::uiExportDialog->setFilters( CAMainWin::uiExportDialog->filters() << CAFileFormats::MIDI_FILTER );
        
        CAMainWin::uiImportDialog = new QFileDialog(0, QObject::tr("Choose a file to import"), settings()->documentsDirectory().absolutePath());
        CAMainWin::uiImportDialog->setFileMode( QFileDialog::ExistingFile );
        CAMainWin::uiImportDialog->setAcceptMode( QFileDialog::AcceptOpen );
}

void CACanorus::initPlayback() {
        qRegisterMetaType< QVector< unsigned char > >( "QVector< unsigned char >" );
        setMidiDevice( new CARtMidiDevice() );
}

CASettingsDialog::CASettingsPage CACanorus::initSettings() {
#ifdef Q_WS_WIN // M$ is of course an exception
        _settingsPath = QDir::homePath()+"/Application Data/Canorus";
#else   // POSIX systems use the same config file path
        _settingsPath = QDir::homePath()+"/.config/Canorus";
#endif
        
        _settings = new CASettings( settingsPath()+"/canorus.ini", QSettings::IniFormat );
        
        return _settings->readSettings();
}

void CACanorus::initScripting() {
#ifdef USE_RUBY 
        CASwigRuby::init();
#endif
#ifdef USE_PYTHON
        CASwigPython::init();
#endif
}

void CACanorus::initAutoRecovery() {
        _autoRecovery = new CAAutoRecovery();
}

void CACanorus::initUndo() {
        _undo = new CAUndo();
}

void CACanorus::insertRecentDocument( QString filename ) {
        if ( recentDocumentList().contains(filename) )
                removeRecentDocument(filename);
        
        recentDocumentList().prepend(filename);
        
        if ( recentDocumentList().size() > settings()->maxRecentDocuments() )
                recentDocumentList().removeLast();
}

void CACanorus::addRecentDocument( QString filename ) {
        recentDocumentList() << filename;
}

void CACanorus::removeRecentDocument( QString filename ) {
        recentDocumentList().removeAll(filename);
}

void CACanorus::cleanUp()
{
        delete _settings;
        delete CAMainWin::uiSaveDialog;
        delete CAMainWin::uiOpenDialog;
        delete CAMainWin::uiExportDialog;
        delete CAMainWin::uiImportDialog;
        delete _midiDevice;
        autoRecovery()->cleanupRecovery();
        delete _autoRecovery;
        delete _undo;
}

bool CACanorus::parseSettingsArguments(int argc, char *argv[]) {
        for (int i=1; i<argc; i++) {
                if ( QString(argv[i])=="--version" ) {
                        std::cout << "Canorus - The next generation music score editor" << std::endl
                                  << "Version " << CANORUS_VERSION << std::endl;
                        
                        return false;
                }
        }
        
        return true;
}

void CACanorus::parseOpenFileArguments(int argc, char *argv[]) {
        for (int i=1; i<argc; i++) {
                if (argv[i][0]!='-') { // automatically treat any argument which doesn't start with '-' to be a file name - \todo
                        // passed is not the switch but a file name
                        if (!CACanorus::locateResource(argv[i]).size())
                                continue;
                        QString fileName = CACanorus::locateResource(argv[i]).at(0);
                        
                        CAMainWin *mainWin = new CAMainWin();
                        mainWin->openDocument(fileName);
                        mainWin->show();
                }
        }
}

int CACanorus::mainWinCount(CADocument *doc) {
        int count=0;
        for (int i=0; i<_mainWinList.size(); i++)
                if (_mainWinList[i]->document()==doc)
                        count++;
        
        return count;
}

void CACanorus::rebuildUI( CADocument *document, CASheet *sheet ) {
        for (int i=0; i<mainWinCount(); i++)
                if ( mainWinAt(i)->document()==document )
                        mainWinAt(i)->rebuildUI(sheet);
}

void CACanorus::rebuildUI( CADocument *document ) {
        for (int i=0; i<mainWinCount(); i++) {
                if ( document && mainWinAt(i)->document()==document ) {
                        mainWinAt(i)->rebuildUI();
                } else if ( !document )
                        mainWinAt(i)->rebuildUI();
        }
}

QList<CAMainWin*> CACanorus::findMainWin(CADocument *document) {
        QList<CAMainWin*> mainWinList;
        for (int i=0; i<mainWinCount(); i++)
                if (mainWinAt(i)->document()==document)
                        mainWinList << mainWinAt(i);
        
        return mainWinList;
}

---