PointTableModel.cpp

#include "IsisDebug.h"

#include "PointTableModel.h"

#include <iostream>

#include <QDebug>
#include <QList>
#include <QMessageBox>
#include <QStringList>
#include <QVariant>

#include "ControlMeasure.h"
#include "ControlPoint.h"
#include "Distance.h"
#include "IException.h"
#include "IString.h"
#include "Latitude.h"
#include "Longitude.h"
#include "SpecialPixel.h"

#include "AbstractTableDelegate.h"
#include "AbstractPointItem.h"
#include "TableColumn.h"
#include "TableColumnList.h"
#include "PointTableDelegate.h"
#include "AbstractTreeModel.h"


namespace Isis {
  namespace CnetViz {
    PointTableModel::PointTableModel(AbstractTreeModel *model) :
      AbstractTableModel(model, new PointTableDelegate) {
      connect(model, SIGNAL(filterCountsChanged(int, int)),
          this, SIGNAL(filterCountsChanged(int, int)));
      connect(model,
          SIGNAL(treeSelectionChanged(QList< AbstractTreeItem * >)),
          this,
          SLOT(handleTreeSelectionChanged(QList< AbstractTreeItem * >)));
    }


    PointTableModel::~PointTableModel() {
    }


    QList< AbstractTreeItem * > PointTableModel::getItems(
      int start, int end) {
      return getSortedItems(start, end, AbstractTreeModel::PointItems);
    }


    QList< AbstractTreeItem * > PointTableModel::getItems(
      AbstractTreeItem *item1, AbstractTreeItem *item2) {
      return getSortedItems(item1, item2, AbstractTreeModel::PointItems);
    }


    int PointTableModel::getVisibleRowCount() const {
      return getDataModel()->getVisibleItemCount(AbstractTreeModel::PointItems,
          true);
    }


    QList< AbstractTreeItem * > PointTableModel::getSelectedItems() {
      return getDataModel()->getSelectedItems(AbstractTreeModel::PointItems,
          true);
    }


    QString PointTableModel::getWarningMessage(AbstractTreeItem const *row,
        TableColumn const *column, QString valueToSave) const {
      return getPointWarningMessage(row, column, valueToSave);
    }


    void PointTableModel::setGlobalSelection(bool selected) {
      return getDataModel()->setGlobalSelection(selected,
          AbstractTreeModel::AllItems);
    }


    int PointTableModel::indexOfVisibleItem(
      AbstractTreeItem const *item) const {
      return getDataModel()->indexOfVisibleItem(item,
          AbstractTreeModel::PointItems,
          true);
    }


    QString PointTableModel::getPointWarningMessage(
      AbstractTreeItem const *row, TableColumn const *column,
      QString valueToSave) {
      QString colTitle = column->getTitle();
      AbstractPointItem::Column colType =
        AbstractPointItem::getColumn(colTitle);

      QString warningText;

      switch (colType) {
        case AbstractPointItem::EditLock:
          if (valueToSave.toLower() == "no" &&
              row->getFormattedData(colTitle).toLower() == "yes") {
            warningText = "Are you sure you want to unlock control point [" +
                row->getFormattedData() + "] for editing?";
          }
          break;
        case AbstractPointItem::APrioriSPLatSigma:
        case AbstractPointItem::APrioriSPLonSigma:
        case AbstractPointItem::APrioriSPRadiusSigma: {
            ASSERT(row->getPointerType() == AbstractTreeItem::Point);
            ControlPoint *point = (ControlPoint *) row->getPointer();

            // Check to see if any of the sigma values are null.
            bool latSigmaValid = (point->GetAprioriSurfacePoint().
                GetLatSigmaDistance().isValid());
            bool lonSigmaValid = (point->GetAprioriSurfacePoint().
                GetLonSigmaDistance().isValid());
            bool radiusSigmaValid = (point->GetAprioriSurfacePoint().
                GetLocalRadiusSigma().isValid());

            if (!latSigmaValid && !lonSigmaValid && !radiusSigmaValid &&
                valueToSave.toLower() != "null") {
              warningText = "The sigma values are currently null. The other "
                  "sigmas will be set to 10,000, which currently represents "
                  "'free'. Is this okay?";
            }
            break;
          }
        case AbstractPointItem::APrioriSPLat:
        case AbstractPointItem::APrioriSPLon:
        case AbstractPointItem::APrioriSPRadius: {
            ASSERT(row->getPointerType() == AbstractTreeItem::Point);
            ControlPoint *point = (ControlPoint *) row->getPointer();

            // Check to see if any of the surface point values are null.
            bool latValid = (point->GetAprioriSurfacePoint().
                GetLatitude().isValid());
            bool lonValid = (point->GetAprioriSurfacePoint().
                GetLongitude().isValid());
            bool radiusValid = (point->GetAprioriSurfacePoint().
                GetLocalRadius().isValid());

            if (!latValid && !lonValid && !radiusValid &&
                valueToSave.toLower() != "null") {
              warningText = "Some of the a priori surface point values are "
                  "currently null. The surface point lat and lon will be set "
                  "to 0 if they are null, and the radius will be set to "
                  "10,000 if it is null. Is this okay?";
            }
            break;
          }

        default:
          break;
      }

      return warningText;
    }


    void PointTableModel::handleTreeSelectionChanged(
      QList< AbstractTreeItem * > newlySelectedItems) {
      AbstractTableModel::handleTreeSelectionChanged(
        newlySelectedItems, AbstractTreeItem::Point);

      QList<AbstractTreeItem *> measureParentItems;
      foreach (AbstractTreeItem * item, newlySelectedItems) {
        if (item->getPointerType() == AbstractTreeItem::Measure) {
          measureParentItems.append(item->parent());
        }
      }

      if (measureParentItems.size()) {
        AbstractTableModel::handleTreeSelectionChanged(
          measureParentItems, AbstractTreeItem::Point);
      }
    }


    TableColumnList *PointTableModel::createColumns() {
      return AbstractPointItem::createColumns();
    }
  }
}