TissueGraphicsView.h

Go to the documentation of this file.

#ifndef SIMPT_EDITOR_TISSUE_GRAPHICS_VIEW_H_INCLUDED
#define SIMPT_EDITOR_TISSUE_GRAPHICS_VIEW_H_INCLUDED
/*
 * Copyright 2011-2016 Universiteit Antwerpen
 *
 * Licensed under the EUPL, Version 1.1 or  as soon they will be approved by
 * the European Commission - subsequent versions of the EUPL (the "Licence");
 * You may not use this work except in compliance with the Licence.
 * You may obtain a copy of the Licence at: http://ec.europa.eu/idabc/eupl5
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the Licence is distributed on an "AS IS" basis,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the Licence for the specific language governing
 * permissions and limitations under the Licence.
 */
#include "EditableCellItem.h"
#include "EditableEdgeItem.h"
#include "EditableNodeItem.h"

#include "exporters/BitmapGraphicsExporter.h"
#include "gui/PanAndZoomView.h"

#include "model/ComponentTraits.h"
#include "model/ComponentFactoryProxy.h"

#include <boost/property_tree/ptree.hpp>
#include <QGraphicsScene>
#include <list>
#include <memory>
#include <string>

class QGraphicsPixmapItem;
class QWidget;

namespace SimPT_Editor {

class BackgroundDialog;
class EditableCellItem;
class EditableEdgeItem;
class EditableNodeItem;
class EditControlLogic;
class SelectByIDWidget;
class TissueSlicer;

using namespace SimShell;
using namespace SimShell::Gui;

enum struct Mode {
        DISPLAY,          //mode to display properties of the entities (immutable entities)
        NODE,             //mode to edit nodes
        NODE_COPY,        //submode to copy node attributes
        EDGE,             //mode to edit edges
        EDGE_COPY,        //submode to copy edge attributes
        CELL,             //mode to edit cells
        CELL_COPY,        //submode to copy cell attributes
        CELL_CREATE,      //submode to create a cell
        CELL_SLICE,       //submode to slice a cell
        NONE
};

class TissueGraphicsView : public PanAndZoomView
{
        Q_OBJECT
public:
        TissueGraphicsView(QWidget* parent);

        virtual ~TissueGraphicsView();

        void Initialize(std::shared_ptr<EditControlLogic> tissue, Mode mode = Mode::DISPLAY);

        bool SelectedIsAtBoundary() const;

        bool SelectedIsDeletable() const;

        bool SelectedIsSplitable() const;

        EditableCellItem* AddCell(std::list<EditableNodeItem*> endpoints, std::list<EditableEdgeItem*> edges, SimPT_Sim::Cell* cell);

        EditableEdgeItem* AddEdge(EditableNodeItem* endpoint1, EditableNodeItem* endpoint2);

        EditableNodeItem* AddNode(SimPT_Sim::Node* node);

        Mode GetMode() const;

        SelectByIDWidget* GetSelectByIDWidget() const;

        void SetMode(Mode mode);

        void GenerateRegularPattern();

        void GenerateVoronoiPattern();

        void SetColorComponent(const boost::property_tree::ptree& parameters);

        void Cleanup();

public slots:
        void CancelAction();

        void CopyAttributes();

        void CreateCell();

        void DeleteItem();

        void SplitEdge();

        void SplitCell();

        void UpdateMovedNode();

        void SetBackground();

        void SetDisplayModePreferences();

        void SetTransparentCells(bool transparent);

signals:
        void ModeChanged();

        void ItemsSelected(unsigned int count);

        void StatusInfoChanged(const std::string& info);

private slots:
        void UpdateSelection();

        void FinishSliceAction();

        void SelectItems(const std::list<unsigned int>& ids, bool keepItemsSelected = false);

private:
        void DeleteNode(EditableNodeItem* node);

        void DeleteCell(EditableCellItem* cell);

        void EnsureVisible(const std::vector<QGraphicsItem*>& items);

        EditableNodeItem* GetEditableNode(SimPT_Sim::Node* node) const;

        void SetEditableItemFlags(bool enable = true);

        bool IsConsistent() const;

        virtual void mouseMoveEvent(QMouseEvent* event);

        virtual void mousePressEvent(QMouseEvent* event);

        virtual void mouseReleaseEvent(QMouseEvent* event);

        virtual void mouseDoubleClickEvent(QMouseEvent* event);

private:
        std::shared_ptr<EditControlLogic>      m_tissue;
        std::list<EditableCellItem*>           m_cells;
        std::list<EditableEdgeItem*>           m_edges;
        std::list<EditableNodeItem*>           m_nodes;
        QGraphicsPixmapItem*                   m_background_item;
        QGraphicsScene                         m_scene;
        Mode                                   m_mode;

private:
        bool                                   m_cells_transparent;

private:
        std::shared_ptr<SimPT_Sim::ComponentFactoryProxy>  m_factory;
        boost::property_tree::ptree                        m_ptree;
        QString                                            m_colorizer_pref;

private:
        TissueSlicer*                          m_tissue_slicer;
        BackgroundDialog*                      m_background_dialog;
        SelectByIDWidget*                      m_select_by_id;

private:
        static constexpr double g_node_radius = 1;
};

} // namespace

#endif // end_of_include_guard