editors/sc-ide/core/sc_process.hpp

   1 /*
   2     SuperCollider Qt IDE
   3     Copyright (c) 2012 Jakob Leben & Tim Blechmann
   4     http://www.audiosynth.com
   5
   6     This program is free software; you can redistribute it and/or modify
   7     it under the terms of the GNU General Public License as published by
   8     the Free Software Foundation; either version 2 of the License, or
   9     (at your option) any later version.
  10
  11     This program is distributed in the hope that it will be useful,
  12     but WITHOUT ANY WARRANTY; without even the implied warranty of
  13     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14     GNU General Public License for more details.
  15
  16     You should have received a copy of the GNU General Public License
  17     along with this program; if not, write to the Free Software
  18     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
  19 */
  20
  21 #ifndef SCIDE_SC_PROCESS_HPP_INCLUDED
  22 #define SCIDE_SC_PROCESS_HPP_INCLUDED
  23
  24 #include "sc_introspection.hpp"
  25 #include "settings/manager.hpp"
  26
  27 #include <QAction>
  28 #include <QByteArray>
  29 #include <QDebug>
  30 #include <QProcess>
  31 #include <QThread>
  32 #include <QUuid>
  33 #include <QtNetwork/QLocalSocket>
  34 #include <QtNetwork/QLocalServer>
  35
  36 namespace ScIDE {
  37
  38 class Main;
  39 class ScIntrospectionParser;
  40
  41 class SCProcess:
  42     public QProcess
  43 {
  44     Q_OBJECT
  45
  46 public:
  47     SCProcess( Main *, class ScResponder * responder, Settings::Manager * );
  48
  49     enum SCProcessActionRole {
  50         StartSCLang = 0,
  51         RecompileClassLibrary,
  52         StopSCLang,
  53         RestartSCLang,
  54         RunMain,
  55         StopMain,
  56
  57         SCProcessActionCount
  58     };
  59
  60     const ScLanguage::Introspection & introspection() { return mIntrospection; }
  61
  62     void sendRequest( const QString &id, const QString &command, const QString &data )
  63     {
  64         QString cmd = QString("ScIDE.request(\"%1\",'%2',\"%3\")")
  65             .arg(id)
  66             .arg(command)
  67             .arg(data);
  68
  69         evaluateCode(cmd, true);
  70     }
  71
  72     void setActiveDocument(class Document *);
  73     void sendActiveDocument();
  74
  75     QAction *action(SCProcessActionRole role)
  76     {
  77         return mActions[role];
  78     }
  79
  80     void emitClassLibraryRecompiled()
  81     {
  82         emit classLibraryRecompiled();
  83     }
  84
  85 Q_SIGNALS:
  86     void scPost(QString const &);
  87     void statusMessage(const QString &);
  88     void response(const QString & id, const QString & data);
  89     void classLibraryRecompiled();
  90
  91 public slots:
  92     void recompileClassLibrary (void);
  93     void runMain(void)  { evaluateCode("thisProcess.run", false); }
  94     void stopMain(void) { evaluateCode("thisProcess.stop", false); }
  95     void startLanguage (void);
  96     void stopLanguage (void);
  97     void restartLanguage (void);
  98     void onReadyRead(void);
  99     void evaluateCode(QString const & commandString, bool silent = false);
 100
 101     void swapIntrospection (ScLanguage::Introspection *newIntrospection)
 102     {
 103         // LATER: use c++11/std::move
 104         mIntrospection = *newIntrospection;
 105         delete newIntrospection;
 106     }
 107
 108 private slots:
 109     void onNewIpcConnection();
 110     void onIpcData();
 111     void finalizeConnection();
 112
 113 private:
 114     void onSclangStart();
 115
 116     void prepareActions(Settings::Manager * settings);
 117
 118     QAction * mActions[SCProcessActionCount];
 119
 120     ScLanguage::Introspection mIntrospection;
 121     ScIntrospectionParser *mIntrospectionParser;
 122
 123     QLocalServer *mIpcServer;
 124     QLocalSocket *mIpcSocket;
 125     QString mIpcServerName;
 126     QByteArray mIpcData;
 127
 128     QString mCurrentDocumentPath;
 129 };
 130
 131 class ScRequest : public QObject
 132 {
 133     Q_OBJECT
 134 public:
 135     ScRequest( SCProcess *sc, QObject * parent = 0 ):
 136         QObject(parent),
 137         mSc(sc)
 138     {
 139         connect(mSc, SIGNAL(response(QString,QString)),
 140                 this, SLOT(onResponse(QString,QString)));
 141
 142         connect(mSc, SIGNAL(classLibraryRecompiled()),
 143                 this, SLOT(onCancelRequest()));
 144     }
 145
 146     void send( const QString & command, const QString & data )
 147     {
 148         mId = QUuid::createUuid();
 149         mCommand = command;
 150         mSc->sendRequest(mId.toString(), command, data);
 151     }
 152
 153     void cancel()
 154     {
 155         mId = QUuid();
 156     }
 157
 158 signals:
 159     void response( const QString & command, const QString & data );
 160     void requestCanceled();
 161
 162 private slots:
 163     void onCancelRequest()
 164     {
 165         cancel();
 166         emit requestCanceled();
 167         deleteLater();
 168     }
 169
 170     void onResponse( const QString & responseId, const QString & responseData )
 171     {
 172         if (responseId == mId.toString())
 173             emit response(mCommand, responseData);
 174     }
 175
 176 private:
 177     QString mCommand;
 178     QUuid mId;
 179     SCProcess *mSc;
 180 };
 181
 182 class ScResponder : public QObject
 183 {
 184     Q_OBJECT
 185
 186 public:
 187     ScResponder( QObject * parent = 0):
 188         QObject(parent)
 189     {}
 190
 191 Q_SIGNALS:
 192     void serverRunningChanged( bool serverRunning, const QString & hostName, int port );
 193     void newIntrospectionData( const QString & yaml );
 194
 195 private Q_SLOTS:
 196     void onResponse( const QString & selector, const QString & data );
 197
 198 private:
 199     void handleOpenFile( const QString & data ) const;
 200     void handleServerRunningChanged( const QString & data );
 201 };
 202
 203 class ScIntrospectionParserWorker : public QObject
 204 {
 205     Q_OBJECT
 206 signals:
 207     void done( ScLanguage::Introspection * output );
 208 private slots:
 209     void process( const QString & input )
 210     {
 211         try {
 212             ScLanguage::Introspection *introspection = new ScLanguage::Introspection (input);
 213             emit done(introspection);
 214         } catch (std::exception & e) {
 215             // LATER: show message in status bar
 216             qDebug() << e.what();
 217         }
 218     }
 219     void quit()
 220     {
 221         thread()->quit();
 222     }
 223 };
 224
 225 class ScIntrospectionParser : public QThread
 226 {
 227     Q_OBJECT
 228 public:
 229     ScIntrospectionParser( ScResponder * responder, QObject * parent = 0 ):
 230         QThread(parent)
 231     {
 232         connect(responder, SIGNAL(newIntrospectionData(QString)),
 233                 &mWorker, SLOT(process(QString)), Qt::QueuedConnection);
 234         connect(&mWorker, SIGNAL(done(ScLanguage::Introspection*)),
 235                 this, SIGNAL(done(ScLanguage::Introspection*)), Qt::QueuedConnection);
 236         mWorker.moveToThread(this);
 237     }
 238     ~ScIntrospectionParser()
 239     {
 240         QMetaObject::invokeMethod(&mWorker, "quit");
 241         wait();
 242     }
 243
 244 signals:
 245     void done( ScLanguage::Introspection * );
 246
 247 private:
 248     ScIntrospectionParserWorker mWorker;
 249 };
 250
 251 }
 252
 253 #endif