main_controller.h

#ifndef GUI_GRAPH_CONTROLLER_H_
#define GUI_GRAPH_CONTROLLER_H_

// Qt-imports
#include <QStringList>
#include <QString>
#include <QObject>
#include <QStandardItemModel>


// General imports
#include <algorithm>
#include <assert.h>
#include <sstream>
#include <unistd.h>
#include <map>
#include <string>

// Local includes
#include "linkler.h"
#include "linkler_diff.h"
#include "xmlparser.h"
#include "filterparser.h"
#include "graph_exporter.h"
#include "swu.h"
#include "module.h"
#include "hide_action.h"
#include "edge_type_filter.h"
#include "dependency_degree_filter.h"
#include "run_block_filter.h"
#include "noop_action.h"
#include "graph_filter.h"
#include "node_exclusion_filter.h"
#include "diff_filter.h"
#include "regex_filter.h"
#include "graph_filter_list.h"
#include "set_property_action.h"
#include "swu_graph_builder.h"
#include "module_graph_builder.h"
#include "graph_model.h"
#include "module_graph_model.h"
#include "swu_graph_model.h"
#include "filter_model.h"
#include "mem_type.h"


class MainController : public QObject {
  Q_OBJECT

  public:

    MainController();

    virtual ~MainController();

    typedef SWUGraphBuilder GraphBuilder;
    typedef SWUGraphModel GraphModel;
    typedef GraphBuilder::GraphType GraphType;

    std::vector<std::string> excluded_nodes();

    QStringList get_run_blocks();

    bool was_any_node_focused();

    void reinclude_excluded_node(std::string name);

    void reinclude_all_excluded_nodes();

    void undo_focused();

    void add_to_focused(std::string name);

    void load_from_xml(std::string file_name);

    void load_diff_from_xml(std::string file_name);

    bool save_to_graphviz(std::string file_name);

    GraphModel* graphModel();

    GraphModel* treeModel(bool dependents, bool dependencies);


    GraphModel* emptyModel();

    GraphModel* fullModel();

    bool is_expanded(std::string item_name);

    bool has_item(std::string item_name);

    bool has_pre_layout_filters();

    bool has_post_layout_filters();

    void set_linkler(Linkler* linkler, bool free = true);

    unsigned int num_nodes();

    GraphType::node_value_type item(std::string name);

    std::string focus_item() const;

    int graph_width() const;

    int graph_height() const;

    void set_dependents(bool dependents);

    void set_dependencies(bool dependencies);

    void set_layout_type(std::string layout_type, bool relayout = true);

    void import_filters(std::string file_path, bool clear = true);

    void export_filters(std::string file_path);

    void import_conditional_formattings(std::string file_path, bool clear = true);

    void export_conditional_formattings(std::string file_path);

    GraphFilterList<GraphType>& pre_filters() { return pre_filters_; }

    GraphFilterList<GraphType>& post_filters() { return post_filters_; }

    
    QStandardItemModel* post_filter_model();

    QStandardItemModel* pre_filter_model();

     
  private: // private methods
    void rebuild_graph(bool lay = true);

    void layout();

    void graph_item(std::pair<std::string, bool> node);

    QStandardItemModel* filter_model(GraphFilterList<GraphType>& list, bool formatting_options);

    void remove_filter(std::string filter_name, GraphFilterList<GraphType>& filters);
    
    void insert_filter(std::string name,
                            std::string type,
                            bool hide,
                            bool inverted_b,
                            bool enabled,
                            std::string color,
                            std::string opacity,
                            std::map<std::string, std::string> params,
                            GraphFilterList<GraphType>& filters);

    void update_filters();  

    bool contract_recursively(std::string item_name, std::string search_name);


  public slots:
    void search(std::string search_term, std::string search_type);

    bool expand_item(std::string expand_item_, bool last, bool emit = true, bool update_focus = false, bool recursively = false);

    bool contract_item(std::string item_name, bool last, bool emit = true);

    void focus_item(std::string item_name);

    void exclude_item(std::string item_name, bool last);

    void remove_pre_filter(std::string filter_name, bool last = true);
    
    void remove_post_filter(std::string filter_name, bool last = true);

    void insert_pre_filter(
                            std::string name,
                            std::string type,
                            bool hide,
                            bool inverted_b,
                            bool enabled,
                            std::string color,
                            std::string opacity,
                            std::map<std::string,std::string> params,
                            bool last);

    void insert_post_filter(
                            std::string name,
                            std::string type,
                            bool hide,
                            bool inverted_b,
                            bool enabled,
                            std::string color,
                            std::string opacity,
                            std::map<std::string,std::string> params,
                            bool last);
    void update_pre_filter(
                            std::string name,
                            std::string type,
                            bool hide,
                            bool inverted_b,
                            bool enabled,
                            std::string color,
                            std::string opacity,
                            std::map<std::string,std::string> params,
                            bool last);
    void update_post_filter(
                            std::string name,
                            std::string type,
                            bool hide,
                            bool inverted_b,
                            bool enabled,
                            std::string color,
                            std::string opacity,
                            std::map<std::string,std::string> params,
                            bool last);

    void reset_all_pre_filters();

    void reset_all_post_filters();

 signals:
    void graphChanged(std::string focus_node = "", bool reset_zoom = false);

    void unknownItem(std::string item_name);
    
    void graphEmpty();
    
    void duplicateFilterName(std::string filter_name);
    void invalidFilterName(std::string filter_name);
    void postFilterModelChanged();
    void preFilterModelChanged();

  private:
    Linkler* linkler_;
    
    GraphType emptyGraph;

    GraphBuilder current_graph_builder_;

    GraphBuilder full_graph_builder_;

    std::string focus_item_;

    std::set< std::pair<std::string, bool> > expanded_items_;

    // Should dependents be included
    bool dependents_;

    // Should dependencies be included
    bool dependencies_;

    // Layout type
    std::string layout_type_;

    GraphFilterList<GraphType> pre_filters_;

    GraphFilterList<GraphType> post_filters_;

    LinklerDiff* linklerDiff_;

    // Graph height
    int graph_height_;

    // Graph width
    int graph_width_;

    std::vector<std::string> previously_focused_items_;

    GraphProperties<GraphType> properties_;
    
    bool property_lock_;
  
};

#endif