FilterGroup.cpp

#include "IsisDebug.h"

#include "FilterGroup.h"

#include <QButtonGroup>
#include <QGroupBox>
#include <QPushButton>
#include <QHBoxLayout>
#include <QIcon>
#include <QLabel>
#include <QRadioButton>
#include <QString>
#include <QVBoxLayout>

#include "IException.h"
#include "IString.h"
#include "FileName.h"

#include "AbstractFilterSelector.h"
#include "ImageImageFilterSelector.h"
#include "PointMeasureFilterSelector.h"
#include "ImagePointFilterSelector.h"


using std::nothrow;
using std::swap;

namespace Isis {
  FilterGroup::FilterGroup(QString type) {
    nullify();

    m_filterType = new QString(type);

    init();
    addSelector();
  }


  FilterGroup::FilterGroup(const FilterGroup &other) {
    nullify();

    m_filterType = new QString(*other.m_filterType);

    init();

    foreach (AbstractFilterSelector * selector, *other.m_selectors) {
      AbstractFilterSelector *newSelector = NULL;
      if (*m_filterType == "Points and Measures") {
        newSelector = new PointMeasureFilterSelector(
          *((PointMeasureFilterSelector *) selector));
      }
      else {
        if (*m_filterType == "Images and Points") {
          newSelector = new ImagePointFilterSelector(
            *((ImagePointFilterSelector *) selector));
        }
        else {
          if (*m_filterType == "Connections") {
            newSelector = new ImageImageFilterSelector(
              *((ImageImageFilterSelector *) selector));
          }
        }
      }

      addSelector(newSelector);
    }

    m_buttonGroup->button(other.m_buttonGroup->checkedId())->click();
  }


  FilterGroup::~FilterGroup() {
    if (m_buttonGroup) {
      delete m_buttonGroup;
      m_buttonGroup = NULL;
    }

    if (m_selectors) {
      delete m_selectors;
      m_selectors = NULL;
    }

    if (m_filterType) {
      delete m_filterType;
      m_filterType = NULL;
    }
  }


  bool FilterGroup::hasFilter(bool (AbstractFilter::*meth)() const) const {
    bool found = false;

    for (int i = 0; !found && i < m_selectors->size(); i++)
      if (meth)
        found = m_selectors->at(i)->hasFilter(meth);
      else
        found = m_selectors->at(i)->hasFilter();

    return found;
  }


  void FilterGroup::nullify() {
    m_buttonGroup = NULL;
    m_closeButton = NULL;
    m_groupBoxLayout = NULL;
    m_selectors = NULL;
  }


  void FilterGroup::init() {
    m_selectors = new QList< AbstractFilterSelector * >;

    QLabel *descriptionLabel = new QLabel("Combine filters using logic "
        "type: ");
    QFont descriptionFont("SansSerif", 11);
    descriptionLabel->setFont(descriptionFont);
    QFont logicTypeFont("SansSerif", 12, QFont::Bold);
    QRadioButton *andButton = new QRadioButton("and");
    andButton->setFont(logicTypeFont);
    QRadioButton *orButton = new QRadioButton("or");
    orButton->setFont(logicTypeFont);
    m_buttonGroup = new QButtonGroup;
    m_buttonGroup->addButton(andButton, 0);
    m_buttonGroup->addButton(orButton, 1);
    connect(m_buttonGroup, SIGNAL(buttonClicked(int)), this,
        SLOT(changeFilterCombinationLogic(int)));

    // FIXME: this should be controlled by QSettings
    andButton->click();

    QHBoxLayout *logicLayout = new QHBoxLayout;
    QMargins margins = logicLayout->contentsMargins();
    margins.setBottom(4);
    logicLayout->setContentsMargins(margins);
    logicLayout->addStretch();
    logicLayout->addWidget(descriptionLabel);
    logicLayout->addWidget(andButton);
    logicLayout->addWidget(orButton);
    logicLayout->addStretch();
    m_logicWidget = new QWidget;
    m_logicWidget->setLayout(logicLayout);

    m_newSelectorButton = new QPushButton;
    m_newSelectorButton->setIcon(QIcon(FileName("$base/icons/add.png").expanded()));
    QString newSelectorTooltip = "Add new filter";
    m_newSelectorButton->setToolTip(newSelectorTooltip);
    m_newSelectorButton->setStatusTip(newSelectorTooltip);

    connect(m_newSelectorButton, SIGNAL(clicked()), this, SLOT(addSelector()));
    QHBoxLayout *newSelectorLayout = new QHBoxLayout;
    newSelectorLayout->addWidget(m_newSelectorButton);
    newSelectorLayout->addStretch();

    m_groupBoxLayout = new QVBoxLayout;
    m_groupBoxLayout->addWidget(m_logicWidget);
    m_groupBoxLayout->addLayout(newSelectorLayout);
    QGroupBox *groupBox = new QGroupBox;
    groupBox->setLayout(m_groupBoxLayout);

    QVBoxLayout *mainLayout = new QVBoxLayout;
    margins = mainLayout->contentsMargins();
    margins.setTop(2);
    margins.setBottom(2);
    mainLayout->setContentsMargins(margins);
    mainLayout->addWidget(groupBox);

    setLayout(mainLayout);
  }


  void FilterGroup::addSelector() {
    AbstractFilterSelector *filterSelector = NULL;
    if (*m_filterType == "Points and Measures")
      filterSelector = new PointMeasureFilterSelector;
    else if (*m_filterType == "Images and Points")
      filterSelector = new ImagePointFilterSelector;
    else if (*m_filterType == "Connections")
      filterSelector = new ImageImageFilterSelector;

    addSelector(filterSelector);
  }


  void FilterGroup::addSelector(AbstractFilterSelector *newSelector) {
    ASSERT(newSelector);

    if (newSelector) {
      connect(newSelector, SIGNAL(close(AbstractFilterSelector *)),
          this, SLOT(deleteSelector(AbstractFilterSelector *)));
      connect(newSelector, SIGNAL(filterChanged()),
          this, SIGNAL(filterChanged()));
      connect(newSelector, SIGNAL(sizeChanged()),
          this, SLOT(sendSizeChanged()));
      m_groupBoxLayout->insertWidget(m_groupBoxLayout->count() - 1, newSelector);
      m_selectors->append(newSelector);
      m_selectors->size() > 1 ? m_logicWidget->show() : m_logicWidget->hide();
    }

    sendSizeChanged();
  }


  void FilterGroup::deleteSelector(AbstractFilterSelector *filterSelector) {
    m_groupBoxLayout->removeWidget(filterSelector);
    delete filterSelector;
    m_selectors->removeOne(filterSelector);

    int m_selectorsSize = m_selectors->size();
    m_selectorsSize > 1 ? m_logicWidget->show() : m_logicWidget->hide();
    if (!m_selectorsSize)
      emit close(this);
    else
      emit filterChanged();
  }


  void FilterGroup::sendClose() {
    emit close(this);
  }


  void FilterGroup::sendSizeChanged() {
    emit sizeChanged(this);
  }


  void FilterGroup::changeFilterCombinationLogic(int button) {
    m_andFiltersTogether = button == 0;
    emit filterChanged();
  }


  bool FilterGroup::filtersAreAndedTogether() const {
    return m_andFiltersTogether;
  }


  FilterGroup &FilterGroup::operator=(FilterGroup other) {
    ASSERT(m_filterType);
    ASSERT(m_selectors);
    ASSERT(m_buttonGroup);

    // create temporary list of new selectors
    QList< AbstractFilterSelector * > newSelectors;
    foreach (AbstractFilterSelector * selector, *other.m_selectors) {
      AbstractFilterSelector *newSelector = NULL;
      if (*m_filterType == "Points and Measures") {
        newSelector = new(nothrow) PointMeasureFilterSelector(
          *((PointMeasureFilterSelector *) selector));
      }
      else {
        if (*m_filterType == "Images and Points") {
          newSelector = new(nothrow) ImagePointFilterSelector(
            *((ImagePointFilterSelector *) selector));
        }
        else {
          if (*m_filterType == "Connections") {
            newSelector = new(nothrow) ImageImageFilterSelector(
              *((ImageImageFilterSelector *) selector));
          }
        }
      }

      if (newSelector) {
        *newSelector = *selector;
        newSelectors.append(newSelector);
      }
    }

    // if all is ok, and it is safe to assign
    if (newSelectors.size() == other.m_selectors->size()) {
      foreach (AbstractFilterSelector * selector, *m_selectors) {
        deleteSelector(selector);
      }

      foreach (AbstractFilterSelector * newSelector, newSelectors) {
        addSelector(newSelector);
      }

      swap(*m_filterType, *other.m_filterType);
      m_buttonGroup->button(other.m_buttonGroup->checkedId())->click();
    }
    else {
      // clean up any temp groups
      foreach (AbstractFilterSelector * newSelector, newSelectors) {
        if (newSelector) {
          delete newSelector;
          newSelector = NULL;
        }
      }

      IString msg = "Assignment of FilterGroup failed";
      throw IException(IException::Programmer, msg, _FILEINFO_);
    }

    return *this;
  }


  QString FilterGroup::getDescription(
    bool (AbstractFilter::*hasFilterMeth)() const,
    QString(AbstractFilter::*descriptionMeth)() const) const {
    QString description;

    ASSERT(m_selectors);

    QList< AbstractFilterSelector * > selectorsWithFilters;
    for (int i = 0; i < m_selectors->size(); i++)
      if (m_selectors->at(i)->hasFilter(hasFilterMeth))
        selectorsWithFilters.append(m_selectors->at(i));

    int numFilters = selectorsWithFilters.size();

    if (numFilters) {
      QString logic = "<b> ";
      if (m_andFiltersTogether)
        logic += "and";
      else
        logic += "or";
      logic += " </b>";

      for (int i = 0; i < numFilters - 1; i++) {
        description += selectorsWithFilters[i]->getDescription(descriptionMeth)
            + logic;
      }

      description += selectorsWithFilters[numFilters - 1]->getDescription(
          descriptionMeth);
    }

    return description;
  }
}