TOPPASScene.h

Go to the documentation of this file.

// --------------------------------------------------------------------------
//                   OpenMS -- Open-Source Mass Spectrometry
// --------------------------------------------------------------------------
// Copyright The OpenMS Team -- Eberhard Karls University Tuebingen,
// ETH Zurich, and Freie Universitaet Berlin 2002-2021.
//
// This software is released under a three-clause BSD license:
//  * Redistributions of source code must retain the above copyright
//    notice, this list of conditions and the following disclaimer.
//  * Redistributions in binary form must reproduce the above copyright
//    notice, this list of conditions and the following disclaimer in the
//    documentation and/or other materials provided with the distribution.
//  * Neither the name of any author or any participating institution
//    may be used to endorse or promote products derived from this software
//    without specific prior written permission.
// For a full list of authors, refer to the file AUTHORS.
// --------------------------------------------------------------------------
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE DISCLAIMED. IN NO EVENT SHALL ANY OF THE AUTHORS OR THE CONTRIBUTING
// INSTITUTIONS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
// OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
// WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
// OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
// ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
// --------------------------------------------------------------------------
// $Maintainer: Johannes Veit $
// $Authors: Johannes Junker, Chris Bielow $
// --------------------------------------------------------------------------
 
#pragma once
 
// OpenMS_GUI config
#include <OpenMS/VISUAL/OpenMS_GUIConfig.h>
 
#include <OpenMS/VISUAL/TOPPASEdge.h>
#include <OpenMS/DATASTRUCTURES/String.h>
#include <OpenMS/VISUAL/TOPPASToolVertex.h>
 
#include <QtWidgets/QGraphicsScene>
#include <QtCore/QProcess>
 
namespace OpenMS
{
  class TOPPASVertex;
  class TOPPASToolVertex;
  class TOPPASMergerVertex;
  class TOPPASOutputFileListVertex;
  class TOPPASEdge;
  class TOPPASResources;
 
  class FakeProcess :
    public QProcess
  {
    Q_OBJECT
 
public:
    virtual void start(const QString & program, const QStringList & arguments, OpenMode mode = ReadWrite);
  };
 
  class OPENMS_GUI_DLLAPI TOPPASScene :
    public QGraphicsScene
  {
    Q_OBJECT
 
public:
 
    struct TOPPProcess
    {
      TOPPProcess(QProcess * p, const QString & cmd, const QStringList & arg, TOPPASToolVertex * const tool) :
        proc(p),
        command(cmd),
        args(arg),
        tv(tool)
      {
      }
 
      QProcess * proc;
      QString command;
      QStringList args;
      TOPPASToolVertex * tv;
    };
 
    enum ActionMode
    {
      AM_NEW_EDGE,
      AM_MOVE
    };
 
 
    enum RefreshStatus
    {
      ST_REFRESH_NOCHANGE,        
      ST_REFRESH_CHANGED,         
      ST_REFRESH_CHANGEINVALID,   
      ST_REFRESH_REMAINSINVALID   
    };
 
 
    typedef QList<TOPPASEdge *> EdgeContainer;
    typedef EdgeContainer::iterator EdgeIterator;
    typedef EdgeContainer::const_iterator ConstEdgeIterator;
    typedef QList<TOPPASVertex *> VertexContainer;
    typedef VertexContainer::iterator VertexIterator;
    typedef VertexContainer::const_iterator ConstVertexIterator;
 
    TOPPASScene(QObject * parent, const QString & tmp_path, bool gui = true);
 
    ~TOPPASScene() override;
 
    void addVertex(TOPPASVertex * tv);
    void addEdge(TOPPASEdge * te);
    void setActionMode(ActionMode mode);
    ActionMode getActionMode();
    VertexIterator verticesBegin();
    VertexIterator verticesEnd();
    EdgeIterator edgesBegin();
    EdgeIterator edgesEnd();
    void copySelected();
    void paste(QPointF pos = QPointF());
    void removeSelected();
    void unselectAll();
    void updateEdgeColors();
    void resetDownstream(TOPPASVertex * vertex);
    void runPipeline();
    bool store(const String & file);
    void load(const String & file);
    void include(TOPPASScene * new_scene, QPointF pos = QPointF());
    const String & getSaveFileName();
    void setSaveFileName(const String & name);
    void topoSort(bool resort_all = true);
    const QString & getOutDir() const;
    const QString & getTempDir() const;
    void setOutDir(const QString & dir);
    bool saveIfChanged();
    void setChanged(bool b);
    bool isPipelineRunning() const;
    bool askForOutputDir(bool always_ask = true);
    void enqueueProcess(const TOPPProcess & process);
    void runNextProcess();
    void resetProcessesQueue();
    void setClipboard(TOPPASScene * clipboard);
    void connectVertexSignals(TOPPASVertex * tv);
    void connectToolVertexSignals(TOPPASToolVertex * ttv);
    void connectOutputVertexSignals(TOPPASOutputFileListVertex * oflv);
    void connectMergerVertexSignals(TOPPASMergerVertex * tmv);
    void connectEdgeSignals(TOPPASEdge * e);
    void loadResources(const TOPPASResources & resources);
    void createResources(TOPPASResources & resources);
    bool wasChanged() const;
    RefreshStatus refreshParameters();
    
    bool isGUIMode() const;
 
    bool isDryRun() const;
    QString getDescription() const;
    void setDescription(const QString & desc);
    void setAllowedThreads(int num_threads);
    TOPPASEdge* getHoveringEdge();
    void checkIfWeAreDone();
 
 
public slots:
 
    void abortPipeline();
    void itemClicked();
    void itemReleased();
    void updateHoveringEdgePos(const QPointF & new_pos);
    void addHoveringEdge(const QPointF & pos);
    void finishHoveringEdge();
    void pipelineErrorSlot(const QString msg = "");
    void moveSelectedItems(qreal dx, qreal dy);
    void snapToGrid();
    void setPipelineRunning(bool b = true);
    void changedParameter(const bool invalidates_running_pipeline);
    void changedOutputFolder();
    void processFinished();
    void quitWithError();
 
 
 
    void logTOPPOutput(const QString & out);
    void logToolStarted();
    void logToolFinished();
    void logToolFailed();
    void logToolCrashed();
    void logOutputFileWritten(const String & file);
 
signals:
 
    void entirePipelineFinished();
    void pipelineExecutionFailed();
    void saveMe();
    void terminateCurrentPipeline();
    void selectionCopied(TOPPASScene * ts);
    void requestClipboardContent();
    void mainWindowNeedsUpdate();
    void openInTOPPView(QStringList all_files);
    void dryRunFinished(int, QProcess::ExitStatus);
    void messageReady(const QString & msg);
 
 
protected:
 
    ActionMode action_mode_;
    VertexContainer vertices_;
    EdgeContainer edges_;
    TOPPASEdge * hover_edge_;
    TOPPASVertex * potential_target_;
    String file_name_;
    QString tmp_path_;
    bool gui_;
    QString out_dir_;
    bool changed_;
    bool running_;
    bool error_occured_;
    bool user_specified_out_dir_;
    QList<TOPPProcess> topp_processes_queue_;
    TOPPASScene * clipboard_;
    bool dry_run_;
    int threads_active_;
    QString description_text_;
    int allowed_threads_;
    TOPPASToolVertex* resume_source_;
 
    TOPPASVertex * getVertexAt_(const QPointF & pos);
    bool isEdgeAllowed_(TOPPASVertex * u, TOPPASVertex * v);
    bool dfsVisit_(TOPPASVertex * vertex);
    bool sanityCheck_(bool allowUserOverride);
 
 
    void contextMenuEvent(QGraphicsSceneContextMenuEvent * event) override;
 
    void writeToLogFile_(const QString & text);
  };
 
}