filter_model.h

#ifndef FILTER_MODEL_H
#define FILTER_MODEL_H

#include <QList>
#include <QStandardItem>
#include <string>
#include "module.h"
#include "dependency.h"
#include "mem_type.h"

class FilterModel {
  public:

  static QList<QStandardItem*> rootNode(std::string name, std::string type, bool enabled, bool inverted) {
        QList<QStandardItem*> item;
        item << new QStandardItem(QString::fromStdString(name))
               << new QStandardItem(QString::fromStdString(type))
               << new QStandardItem((inverted ? "Exclude" : "Include"));
        item[0]->setCheckable(true);
        item[0]->setCheckState((enabled ? Qt::Checked : Qt::Unchecked));
        item[0]->setEditable(false);
        item[1]->setEditable(false);
        item[2]->setEditable(false);

        return item;
  }

  static void empty_filter(QStandardItem& parent, std::string type) {
    if(type.compare("regex") == 0) {
      FilterModel::regex(parent);
    } else if(type.compare("dependency_degree") == 0) {
      FilterModel::dependency_degree(parent);
    } else if(type.compare("run_block") == 0) {
      FilterModel::run_block(parent);
    } else if(type.compare("lpm_ldm") == 0) {
      FilterModel::lpm_ldm(parent, 0);
    } else if(type.compare("diff") == 0){
      FilterModel::diff(parent);
    }
  } 

  static void diff(QStandardItem& parent, std::string type = ""){
    QList<QStandardItem*> keyValue;
    keyValue << new QStandardItem("Difference")
                 << new QStandardItem(QString::fromStdString(type));

    keyValue.first()->setEditable(false);
    keyValue[0]->setSelectable(false);
    keyValue[1]->setSelectable(false);
    parent.appendRow(keyValue);
  }

  static void regex(QStandardItem& parent, std::string pattern="") {
     QList<QStandardItem*> keyValue;
     keyValue << new QStandardItem("Regular Expression")
                   << new QStandardItem(QString::fromStdString(pattern));

      keyValue.first()->setEditable(false);
      keyValue[0]->setSelectable(false);
      keyValue[1]->setSelectable(false);
      parent.appendRow(keyValue);
  }

  static void dependency_degree(QStandardItem& parent, int min_degree=-1, int max_degree=-1) {
          QList<QStandardItem*> minValue;
          minValue << new QStandardItem("Min Degree") 
                   << new QStandardItem(QString::number(min_degree));
          minValue.first()->setEditable(false);
          minValue[0]->setSelectable(false);
          minValue[1]->setSelectable(false);
          parent.appendRow(minValue);

          QList<QStandardItem*> maxValue;
          maxValue << new QStandardItem("Max Degree") 
                   << new QStandardItem(QString::number(max_degree));
          maxValue.first()->setEditable(false);
          maxValue[0]->setSelectable(false);
          maxValue[1]->setSelectable(false);
          parent.appendRow(maxValue);
  }

  template<typename DepType>
  static void lpm_ldm(QStandardItem& parent, DepType dep_type = GraphTool::UNDEFINED) {
         QList<QStandardItem*> keyValue;
          keyValue << new QStandardItem("Type");
          if(dep_type == GraphTool::LPM) {
            keyValue << new QStandardItem("LPM");
          }
          else if(dep_type == GraphTool::LDM) {
            keyValue << new QStandardItem("LDM");
          }
          else if(dep_type == GraphTool::LDM_LPM) {
            keyValue << new QStandardItem("Both");
          }
          else {
            keyValue << new QStandardItem("Undefined");
          }

          keyValue.first()->setEditable(false);
          keyValue[0]->setSelectable(false);
          keyValue[1]->setSelectable(false);
          parent.appendRow(keyValue);
  }

  static void run_block(QStandardItem& parent, std::string query_string="") {
          QList<QStandardItem*> keyValue;
          keyValue << new QStandardItem("Query String")
                   << new QStandardItem(QString::fromStdString(query_string));

          keyValue.first()->setEditable(false);
          keyValue[0]->setSelectable(false);
          keyValue[1]->setSelectable(false);
          parent.appendRow(keyValue);
  }
  
  static void formatting_properties(QStandardItem& parent, std::string opacityStr="255", std::string colorStr="red", bool hide=false) {
          QList<QStandardItem*> opacity;
          opacity << new QStandardItem("Opacity")
                  << new QStandardItem(QString::fromStdString(opacityStr)); 
          opacity.first()->setEditable(false);
          opacity[0]->setSelectable(false);
          opacity[1]->setSelectable(false);
          parent.appendRow(opacity);
          
          QList<QStandardItem*> color;
          color << new QStandardItem("Color")
                  << new QStandardItem(QString::fromStdString(colorStr)); 
          color.first()->setEditable(false);
          color[0]->setSelectable(false);
          color[1]->setSelectable(false);
          parent.appendRow(color);
        
          QList<QStandardItem*> hidden;
          hidden << new QStandardItem("Hide");
          if(hide)
            hidden << new QStandardItem("Yes");
          else
            hidden << new QStandardItem("No");
          hidden.first()->setEditable(false);
          hidden[0]->setSelectable(false);
          hidden[1]->setSelectable(false);
          parent.appendRow(hidden);
    }

    static std::map<std::string, std::string> filter_types() {
      std::map<std::string, std::string> ret;
      ret["Dependency Degree"] = "dependency_degree";
      ret["LPM/LDM"] = "lpm_ldm";
      ret["Run block"] = "run_block";
      ret["Regular Expression"] = "regex";
      ret["Difference"] = "diff";
      return ret;
    }
};

#endif