Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with
or
.
Download ZIP
tree: ba582c232f
Fetching contributors…

Cannot retrieve contributors at this time

490 lines (431 sloc) 16.332 kB
//=============================================================================
// MuseScore
// Music Composition & Notation
//
// Copyright (C) 2002-2011 Werner Schweer
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License version 2
// as published by the Free Software Foundation and appearing in
// the file LICENCE.GPL
//=============================================================================
#include "pluginCreator.h"
#include "musescore.h"
#include "plugins.h"
#include "icons.h"
#include "helpBrowser.h"
extern bool useFactorySettings;
//static const char* states[] = {
// "S_INIT", "S_EMPTY", "S_CLEAN", "S_DIRTY"
// };
//---------------------------------------------------------
// PluginCreator
//---------------------------------------------------------
PluginCreator::PluginCreator(QWidget* parent)
: QMainWindow(parent)
{
state = S_INIT;
item = 0;
view = 0;
dock = 0;
manualDock = 0;
helpBrowser = 0;
setupUi(this);
QToolBar* fileTools = addToolBar(tr("File Operations"));
fileTools->setObjectName("FileOperations");
actionNew->setIcon(*icons[fileNew_ICON]);
actionNew->setShortcut(QKeySequence(QKeySequence::New));
fileTools->addAction(actionNew);
actionOpen->setIcon(*icons[fileOpen_ICON]);
actionOpen->setShortcut(QKeySequence(QKeySequence::Open));
fileTools->addAction(actionOpen);
actionSave->setIcon(*icons[fileSave_ICON]);
actionSave->setShortcut(QKeySequence(QKeySequence::Save));
fileTools->addAction(actionSave);
actionQuit->setShortcut(QKeySequence(QKeySequence::Quit));
actionManual->setIcon(QIcon(":/data/help.png"));
actionManual->setShortcut(QKeySequence(QKeySequence::HelpContents));
fileTools->addAction(actionManual);
QToolBar* editTools = addToolBar(tr("Edit Operations"));
editTools->setObjectName("EditOperations");
actionUndo->setIcon(*icons[undo_ICON]);
actionUndo->setShortcut(QKeySequence(QKeySequence::Undo));
editTools->addAction(actionUndo);
actionRedo->setIcon(*icons[redo_ICON]);
actionRedo->setShortcut(QKeySequence(QKeySequence::Redo));
editTools->addAction(actionRedo);
actionUndo->setEnabled(false);
actionRedo->setEnabled(false);
log->setReadOnly(true);
log->setMaximumBlockCount(1000);
readSettings();
setState(S_EMPTY);
connect(run, SIGNAL(clicked()), SLOT(runClicked()));
connect(stop, SIGNAL(clicked()), SLOT(stopClicked()));
connect(actionOpen, SIGNAL(triggered()), SLOT(loadPlugin()));
connect(actionSave, SIGNAL(triggered()), SLOT(savePlugin()));
connect(actionNew, SIGNAL(triggered()), SLOT(newPlugin()));
connect(actionQuit, SIGNAL(triggered()), SLOT(close()));
connect(actionManual, SIGNAL(triggered()), SLOT(showManual()));
connect(actionUndo, SIGNAL(triggered()), textEdit, SLOT(undo()));
connect(actionRedo, SIGNAL(triggered()), textEdit, SLOT(redo()));
connect(textEdit, SIGNAL(undoAvailable(bool)), actionUndo, SLOT(setEnabled(bool)));
connect(textEdit, SIGNAL(redoAvailable(bool)), actionRedo, SLOT(setEnabled(bool)));
connect(textEdit, SIGNAL(textChanged()), SLOT(textChanged()));
}
//---------------------------------------------------------
// manualPath
//---------------------------------------------------------
QString PluginCreator::manualPath()
{
QString path = mscoreGlobalShare;
path += "/manual/plugins/plugins.html";
return path;
}
//---------------------------------------------------------
// setState
//---------------------------------------------------------
void PluginCreator::setState(PCState newState)
{
if (state == newState)
return;
switch(state) {
case S_INIT:
switch(newState) {
case S_INIT:
break;
case S_EMPTY:
setTitle("");
actionSave->setEnabled(false);
run->setEnabled(false);
stop->setEnabled(false);
textEdit->setEnabled(false);
break;
case S_CLEAN:
case S_DIRTY:
break;
}
break;
case S_EMPTY:
switch(newState) {
case S_INIT:
case S_EMPTY:
break;
case S_CLEAN:
setTitle(path);
run->setEnabled(true);
textEdit->setEnabled(true);
break;
case S_DIRTY:
return;
}
break;
case S_CLEAN:
switch(newState) {
case S_INIT:
case S_EMPTY:
case S_CLEAN:
break;
case S_DIRTY:
actionSave->setEnabled(true);
break;
}
break;
case S_DIRTY:
switch(newState) {
case S_INIT:
case S_EMPTY:
case S_CLEAN:
actionSave->setEnabled(false);
case S_DIRTY:
break;
}
break;
}
state = newState;
}
//---------------------------------------------------------
// setTitle
//---------------------------------------------------------
void PluginCreator::setTitle(const QString& s)
{
QString t(tr("MuseScore Plugin Editor"));
if (s.isEmpty())
setWindowTitle(t);
else
setWindowTitle(t + " - " + s);
}
//---------------------------------------------------------
// writeSettings
//---------------------------------------------------------
void PluginCreator::writeSettings()
{
QSettings settings;
settings.beginGroup("PluginCreator");
settings.setValue("geometry", saveGeometry());
settings.setValue("windowState", saveState());
settings.setValue("splitter", splitter->saveState());
settings.endGroup();
}
//---------------------------------------------------------
// readSettings
//---------------------------------------------------------
void PluginCreator::readSettings()
{
if (!useFactorySettings) {
QSettings settings;
settings.beginGroup("PluginCreator");
splitter->restoreState(settings.value("splitter").toByteArray());
restoreGeometry(settings.value("geometry").toByteArray());
restoreState(settings.value("windowState").toByteArray());
settings.endGroup();
}
}
//---------------------------------------------------------
// closeEvent
//---------------------------------------------------------
void PluginCreator::closeEvent(QCloseEvent* ev)
{
if (state == S_DIRTY) {
QMessageBox::StandardButton n = QMessageBox::warning(this, tr("MuseScore"),
tr("Plugin \"%1\" has changes\n"
"save before closing?").arg(path),
QMessageBox::Save | QMessageBox::Discard | QMessageBox::Cancel,
QMessageBox::Save);
if (n == QMessageBox::Save)
savePlugin();
else if (n == QMessageBox::Cancel) {
ev->ignore();
return;
}
}
emit closed();
QWidget::closeEvent(ev);
}
//---------------------------------------------------------
// qmlMsgHandler
//---------------------------------------------------------
static void qmlMsgHandler(QtMsgType type, const char* msg)
{
QString s;
switch(type) {
case QtDebugMsg:
s = QString("Debug: %1\n").arg(msg);
break;
case QtWarningMsg:
s = QString("Warning: %1\n").arg(msg);
break;
case QtCriticalMsg:
s = QString("Critical: %1\n").arg(msg);
break;
case QtFatalMsg:
s = QString("Fatal: %1\n").arg(msg);
break;
}
mscore->getPluginCreator()->msg(s);
}
//---------------------------------------------------------
// runClicked
//---------------------------------------------------------
void PluginCreator::runClicked()
{
log->clear();
QDeclarativeEngine* qml = mscore->qml();
connect(qml, SIGNAL(warnings(const QList<QDeclarativeError>&)),
SLOT(qmlWarnings(const QList<QDeclarativeError>&)));
item = 0;
QDeclarativeComponent component(qml);
component.setData(textEdit->toPlainText().toUtf8(), QUrl());
QObject* obj = component.create();
if (obj == 0) {
msg("creating component failed\n");
foreach(QDeclarativeError e, component.errors())
msg(QString(" line %1: %2\n").arg(e.line()).arg(e.description()));
stop->setEnabled(false);
return;
}
qInstallMsgHandler(qmlMsgHandler);
stop->setEnabled(true);
run->setEnabled(false);
item = qobject_cast<QmlPlugin*>(obj);
view = new QDeclarativeView;
view->setResizeMode(QDeclarativeView::SizeViewToRootObject);
// view->setResizeMode(QDeclarativeView::SizeRootObjectToView);
QGraphicsObject* go = qobject_cast<QGraphicsObject*>(item);
view->scene()->addItem(go);
view->show();
if (item->pluginType() == "dock") {
dock = new QDockWidget("Plugin", 0);
dock->setAttribute(Qt::WA_DeleteOnClose);
dock->setWidget(view);
Qt::DockWidgetArea area = Qt::RightDockWidgetArea;
if (item->dockArea() == "left")
area = Qt::LeftDockWidgetArea;
else if (item->dockArea() == "top")
area = Qt::TopDockWidgetArea;
else if (item->dockArea() == "bottom")
area = Qt::BottomDockWidgetArea;
addDockWidget(area, dock);
}
view->raise();
view->setAttribute(Qt::WA_DeleteOnClose);
connect(qml, SIGNAL(quit()), SLOT(closePlugin()));
connect(view, SIGNAL(destroyed()), SLOT(closePlugin()));
if (dock)
connect(dock, SIGNAL(destroyed()), SLOT(closePlugin()));
if (mscore->currentScore())
mscore->currentScore()->startCmd();
item->runPlugin();
if (mscore->currentScore())
mscore->currentScore()->endCmd();
mscore->endCmd();
}
//---------------------------------------------------------
// closePlugin
//---------------------------------------------------------
void PluginCreator::closePlugin()
{
stop->setEnabled(false);
run->setEnabled(true);
if (view)
view->close();
if (dock)
dock->close();
qInstallMsgHandler(0);
}
//---------------------------------------------------------
// stopClicked
//---------------------------------------------------------
void PluginCreator::stopClicked()
{
closePlugin();
}
//---------------------------------------------------------
// loadPlugin
//---------------------------------------------------------
void PluginCreator::loadPlugin()
{
if (state == S_DIRTY) {
QMessageBox::StandardButton n = QMessageBox::warning(this, tr("MuseScore"),
tr("Plugin \"%1\" has changes\n"
"save before closing?").arg(path),
QMessageBox::Save | QMessageBox::Discard | QMessageBox::Cancel,
QMessageBox::Save);
if (n == QMessageBox::Save)
savePlugin();
else if (n == QMessageBox::Cancel)
return;
}
path = mscore->getPluginFilename(true);
if (path.isEmpty())
return;
QFile f(path);
if (f.open(QIODevice::ReadOnly)) {
textEdit->setPlainText(f.readAll());
run->setEnabled(true);
f.close();
}
else {
path = QString();
}
created = false;
setTitle(path);
setState(S_CLEAN);
raise();
}
//---------------------------------------------------------
// savePlugin
//---------------------------------------------------------
void PluginCreator::savePlugin()
{
if (created) {
path = mscore->getPluginFilename(false);
if (path.isEmpty())
return;
}
QFile f(path);
if (f.open(QIODevice::WriteOnly)) {
f.write(textEdit->toPlainText().toUtf8());
f.close();
textEdit->document()->setModified(false);
created = false;
setState(S_CLEAN);
}
else {
// TODO
}
raise();
}
//---------------------------------------------------------
// newPlugin
//---------------------------------------------------------
void PluginCreator::newPlugin()
{
if (state == S_DIRTY) {
QMessageBox::StandardButton n = QMessageBox::warning(this, tr("MuseScore"),
tr("Plugin \"%1\" has changes\n"
"save before closing?").arg(path),
QMessageBox::Save | QMessageBox::Discard | QMessageBox::Cancel,
QMessageBox::Save);
if (n == QMessageBox::Save)
savePlugin();
else if (n == QMessageBox::Cancel)
return;
}
path = tr("untitled");
created = true;
QString s(
"import QtQuick 1.0\n"
"import MuseScore 1.0\n"
"\n"
"MuseScore {\n"
" menuPath: \"Plugins.pluginName\"\n"
" onRun: {\n"
" console.log(\"hello world\")\n"
" Qt.quit()\n"
" }\n"
" }\n");
textEdit->setPlainText(s);
setState(S_CLEAN);
raise();
}
//---------------------------------------------------------
// textChanged
//---------------------------------------------------------
void PluginCreator::textChanged()
{
actionSave->setEnabled(textEdit->document()->isModified());
setState(S_DIRTY);
}
//---------------------------------------------------------
// qmlWarnings
//---------------------------------------------------------
void PluginCreator::qmlWarnings(const QList<QDeclarativeError>& el)
{
foreach(const QDeclarativeError& e, el)
msg(QString("%1:%2: %3\n").arg(e.line()).arg(e.column()).arg(e.description()));
}
//---------------------------------------------------------
// msg
//---------------------------------------------------------
void PluginCreator::msg(const QString& s)
{
log->moveCursor(QTextCursor::End);
log->textCursor().insertText(s);
}
//---------------------------------------------------------
// showManual
//---------------------------------------------------------
void PluginCreator::showManual()
{
if (helpBrowser == 0) {
helpBrowser = new HelpBrowser;
manualDock = new QDockWidget(tr("Manual"), 0);
manualDock->setObjectName("Manual");
manualDock->setWidget(helpBrowser);
Qt::DockWidgetArea area = Qt::RightDockWidgetArea;
addDockWidget(area, manualDock);
helpBrowser->setContent(manualPath());
}
manualDock->setVisible(!manualDock->isVisible());
}
Jump to Line
Something went wrong with that request. Please try again.