WorkspaceQtModel.h

Go to the documentation of this file.

#ifndef WORKSPACEQTMODEL_H_INCLUDED
#define WORKSPACEQTMODEL_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 "gui/controller/ProjectController.h"
#include "workspace/IWorkspace.h"
#include "workspace/IProject.h"

#include <QAbstractItemModel>
#include <boost/property_tree/ptree.hpp>
#include <memory>
#include <vector>

namespace SimShell {
namespace Ws {
        class IFile;
}

namespace Gui {

using namespace Ws;
using namespace Ws::Event;

class WorkspaceQtModel : public QAbstractItemModel,
                         public std::enable_shared_from_this<WorkspaceQtModel>
{
        Q_OBJECT
public:
        static std::shared_ptr<WorkspaceQtModel>
        Create(const std::shared_ptr<IWorkspace>&,
               Controller::ProjectController* c,
               QObject* parent = 0);

        virtual ~WorkspaceQtModel();

        // Implementation of QAbstractItemModel methods.
        virtual int columnCount(QModelIndex const& parent = QModelIndex()) const;
        virtual QVariant data(QModelIndex const& index, int role = Qt::DisplayRole) const;
        virtual Qt::ItemFlags flags(QModelIndex const& index) const;
        virtual QVariant headerData(int section, Qt::Orientation, int role) const;
        virtual QModelIndex index(int row, int column, QModelIndex const& parent = QModelIndex()) const;
        virtual bool insertRow(int row, QModelIndex const& parent = QModelIndex());
        virtual bool insertRows(int row, int count, QModelIndex const& parent = QModelIndex());
        virtual QModelIndex parent(QModelIndex const& index) const;
        virtual bool removeRow(int row, QModelIndex const& parent = QModelIndex());
        virtual bool removeRows(int row, int count, QModelIndex const& parent = QModelIndex());
        virtual int rowCount(QModelIndex const& parent = QModelIndex()) const;

        enum ItemType { RootType, ProjectType, FileType };

        bool Close();

        bool Close(const QModelIndex& index);

        std::vector<QAction*> GetContextMenuActions(const QModelIndex& index) const;

        const std::string& GetName(QModelIndex const& index) const;

        ItemType GetType(QModelIndex const& index) const;

        bool IsOpened(const QModelIndex& index) const;

        bool Open(const QModelIndex& index);

        std::shared_ptr<IWorkspace> Workspace() { return m_workspace; }

private:
        WorkspaceQtModel(const std::shared_ptr<IWorkspace>&,
                         Controller::ProjectController* c,
                         QObject* parent = 0);

        struct Item
        {
                ItemType  type; 
                int       row;  

                // Various constructors initialize different structs in anonymous union.

                Item()
                        : type(RootType), row(0), workspace() {}

                Item(int r, const std::string& name, const std::shared_ptr<IProject>& obj)
                        : type(ProjectType), row(r), project({name, obj, {}}) {}

                Item(int r, const std::string& name, Item* parent, const std::shared_ptr<IFile>& obj)
                        : type(FileType), row(r), file({name, parent, obj}) {}

                struct WS {
                        std::vector<Item*>         children;
                };
                struct PR {
                        std::string                name;
                        std::shared_ptr<IProject>  obj;
                        std::vector<Item*>         children;
                };
                struct FI {
                        std::string                name;
                        Item*                      parent;
                        std::shared_ptr<IFile>     obj;
                };
                union {
                        WS workspace;
                        PR project;
                        FI file;
                };

                ~Item() {
                        // Destructor deletes item's children.
                        switch (type) {
                        case RootType:
                                for (auto child : workspace.children)
                                        delete child;
                                break;
                        case ProjectType:
                                for (auto child : project.children)
                                        delete child;
                                break;
                        default:
                                break;
                        }
                }
        };


        void ListenWorkspaceEvent(const Ws::Event::WorkspaceChanged&);

        void ListenProjectEvent(Item* project_item, const Ws::Event::ProjectChanged&);

        int FindProjectRow(const std::string& name);
        int FindProjectRowInsert(IWorkspace::ConstProjectIterator);
        int FindFileRow(Item* project_item, const std::string& name);
        int FindFileRowInsert(Item* project_item, IProject::ConstFileIterator);

        Item*                           m_root;
        std::shared_ptr<IWorkspace>     m_workspace;

        Controller::ProjectController*  m_project_controller;
};

} // namespace
} // namespace

#endif // end_of_inclde_guard