EditControlLogic.h

Go to the documentation of this file.

#ifndef SIMPT_EDITOR_EDIT_CONTROL_LOGIC_H_INCLUDED
#define SIMPT_EDITOR_EDIT_CONTROL_LOGIC_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 "EditableMesh.h"

#include "bio/Cell.h"
#include "bio/Edge.h"
#include "bio/Mesh.h"
#include "bio/Node.h"
#include "bio/Wall.h"

#include <QObject>
#include <boost/property_tree/ptree_fwd.hpp>
#include <list>
#include <memory>
#include <string>
#include <vector>

class QPointF;
class QPolygonF;

namespace SimPT_Editor {

using namespace SimPT_Sim;

class EditControlLogic : public QObject
{
        Q_OBJECT
public:
        EditControlLogic(unsigned int chemical_count);

        EditControlLogic(const boost::property_tree::ptree& pt);

        virtual ~EditControlLogic();

        void ChangeAttributes(const boost::property_tree::ptree& pt);

        void CopyAttributes(const boost::property_tree::ptree& pt);

        Cell* CreateCell(Node* node1, Node* node2, const QPointF& newPoint);

        bool DeleteCell(Cell* cell);

        void DeleteCells(const std::list<Cell*>& cells);

        bool DeleteNode(Node* node);

        void Deselect();

        const std::vector<Cell*>& GetCells() const {return m_mesh->GetMesh()->GetCells();}

        EditableMesh* GetMesh() {return m_mesh;}

        // Get parameters ptree.
        const boost::property_tree::ptree& GetParameters() const;

        const std::vector<Node*>& GetNodes() const {return m_mesh->GetMesh()->GetNodes();}

        const std::vector<Wall*>& GetWalls() const {return m_mesh->GetMesh()->GetWalls();}

        bool MoveNode(Node* node, double x, double y);

        const boost::property_tree::ptree& ToPTree();

        void ReplaceCell(Cell* cell, std::list<QPolygonF> newCells);

        const std::list<Cell*>& SelectedCells() const {return m_selected_cells;}

        const std::list<Node*>& SelectedNodes() const {return m_selected_nodes;}

        const std::list<Wall*>& SelectedWalls() const {return m_selected_walls;}

        void SelectCells(const std::list<Cell*>& cells);

        void SelectEdges(const std::list<Edge>& edges);

        void SelectNodes(const std::list<Node*>& nodes);

        void SetParameters(const boost::property_tree::ptree&);

        void StopMoveNode();

        std::vector<Cell*> SplitCell(Cell* cell,
                                                Node* node1, Node* node2, bool modified = false);

        std::vector<Cell*> SplitCell(Node* node1, Node* node2);

        Node* SplitEdge(const Edge& edge);

signals:
        void Modified();

        void Moved(Node* node, double x, double y);

        void SelectionChanged();

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

        void StoppedMoving();

private:
        Mesh BuildTwoSquaresMesh(unsigned int chemical_count);

        static boost::property_tree::ptree UpdatePTree(boost::property_tree::ptree pt1, boost::property_tree::ptree pt2);

private:
        EditableMesh*                  m_mesh;
        bool                           m_moving_node;
        boost::property_tree::ptree    m_ptree;
        bool                           m_ptree_dirty;
        std::list<Cell*>               m_selected_cells;
        std::list<Node*>               m_selected_nodes;
        std::list<Wall*>               m_selected_walls;

};

} // namespace

#endif // end_of_include_guard