graph_model_item.h

#ifndef GUI_GRAPH_MODEL_ITEM_H_
#define GUI_GRAPH_MODEL_ITEM_H_

#include <QVariant>
#include <QList>
#include <QColor>
#include <QDebug>

#include <vector>

class GraphModelItem {
    public:
    enum column_index { NAME,
                DEPENDENCIES,
                  DEPENDENTS,
                     MODULES,
                       FILES,
                      DEGREE,
                    CIRCULAR,
                    SELF_REF,
                        XPOS,
                        YPOS,
                    ABSOLUTE,
                                        IN_RUN_BLOCK,
                    MEM_TYPE, //Only when this item represents an edge(dependency). a dependency_type enum value
                       COLOR,
                     OPACITY,
                  EDGE_COLOR,
                  EDGE_OPACITY,
                    NUM_COLS };

        GraphModelItem(GraphModelItem* parent = 0);
      virtual ~GraphModelItem();

        void appendChild(GraphModelItem* child);
        GraphModelItem* child(int row);
        GraphModelItem* parent();   
    int childCount() const;

    int columnCount() const;

        int row() const;

        virtual QVariant data(int column) const;

    void set_xy(int x, int y);

    void set_circular(bool circular);

    bool circular() const;

    void set_num_of_modules(uint);
    
    void set_degree(uint);

    void set_num_of_files(uint);

    // Set the opactiy
    void set_opacity(int opacity);
    
    // Set the color
    void set_color(QColor color);

    void set_edge_opacity(int opacity);
    void set_edge_color(QColor color);

    void set_mem_type(std::string type);

  protected:
        /* Tree mode specific member */
    GraphModelItem* parent_item_;

    private:
        /* Tree mode specific members */
    // Hierarchical data ie. with regards to the tree
        QList<GraphModelItem*> child_items_;

    /* General members */
    bool circular_;
    int x_;
    int y_;
    uint num_of_modules_;
    uint degree_;
    uint num_of_files_;
    int opacity_;
    QColor color_;
    int edge_opacity_;    
    QColor edge_color_;
    

    // If this item is an edge, this variable states
    // which type of dependency it represents (check Dependency::DependencyType enum)
    std::string mem_type_;
};

template<typename NodeType, typename EdgeType> class GenericGraphModelItem : public GraphModelItem {
  public:
        GenericGraphModelItem(NodeType* node, std::vector<EdgeType*>* edges, std::vector<EdgeType*>* incoming_edges, GraphModelItem* parent = 0, EdgeType* parent_edge = 0)
            : GraphModelItem(parent), edges_(edges), incoming_edges_(incoming_edges) {
        parent_edge_ = parent_edge;
      node_ = node;
    }

    ~GenericGraphModelItem() {
      delete edges_;
      delete incoming_edges_;
    }

        NodeType* node() {
        return node_;
    }

    std::vector<EdgeType*>* edges() {
      return edges_;
    }

    std::vector<EdgeType*>* incoming_edges() {
      return incoming_edges_;
    }

    bool self_referential() const {
      GenericGraphModelItem<NodeType,EdgeType>* p = 
          dynamic_cast<GenericGraphModelItem<NodeType,EdgeType>*>(parent_item_);

      if(p == NULL) return false;

      return (p ->node_ == node_);
    }

    // referential or not.
        virtual QVariant data(int column) const {
      switch(column) {
        case SELF_REF:
          return self_referential();
        default:
          return GraphModelItem::data(column);
      }
    }

  protected:
    NodeType* node_;
    EdgeType* parent_edge_; 
    std::vector<EdgeType*>* edges_;
    std::vector<EdgeType*>* incoming_edges_;
};

#endif