HistoryTreeWidget.cpp

#include "HistoryTreeWidget.h"

#include <QDateTime>
#include <QDebug>

#include "ProgressBar.h"
#include "Project.h"
#include "WorkOrder.h"

namespace Isis {
  HistoryTreeWidget::HistoryTreeWidget(Project *project, QWidget *parent) : QTreeWidget(parent) {
    m_project = project;

    QStringList headers;
    headers.append("Operation");
    headers.append("Progress");
    headers.append("Time Executed");

    setHeaderLabels(headers);

    connect(m_project, SIGNAL(workOrderStarting(WorkOrder *)),
            this, SLOT(addToHistory(WorkOrder *)));
    connect(m_project, SIGNAL(projectLoaded(Project *)),
            this, SLOT(showHistory()));
    connect(m_project->undoStack(), SIGNAL(indexChanged(int)),
            this, SLOT(handleUndoIndexChanged(int)));

    showHistory();

    refit();
  }



  HistoryTreeWidget::~HistoryTreeWidget() {
    m_project = NULL;
  }


  int HistoryTreeWidget::sizeHintForColumn(int column) const {
    int result = -1;

    QFontMetrics metrics(invisibleRootItem()->font(1));
    int dateTimeColumnWidth = qRound(metrics.width(QDateTime::currentDateTime().toString()) * 1.10);

    int progressBarColumnWidth = 200;

    // The -12 is a guesstimate for not having a horizontal scroll bar. I'm not sure how to
    //   calculate this number correctly. Consequences of it being wrong are minimal. -SL
    int operationColumnWidth = width() - dateTimeColumnWidth - progressBarColumnWidth - 12;

    if (operationColumnWidth > 0) {
      if (column == 0)
        result = operationColumnWidth;
      else if (column == 1)
        result = progressBarColumnWidth;
      else if (column == 2)
        result = dateTimeColumnWidth;
    }

    return result;
  }


  void HistoryTreeWidget::refit() {
    resizeColumnToContents(0);
    resizeColumnToContents(1);
    resizeColumnToContents(2);
  }


  void HistoryTreeWidget::updateStatus(QTreeWidgetItem *treeItem) {
    WorkOrder *workOrder = treeItem->data(0, Qt::UserRole).value<WorkOrder *>();

    if (workOrder)
      updateStatus(workOrder);
  }


  void HistoryTreeWidget::addToHistory(WorkOrder *workOrder) {
    QString data = workOrder->bestText();

    connect(workOrder, SIGNAL(destroyed(QObject *)),
            this, SLOT(removeFromHistory(QObject *)));

    QStringList columnData;
    columnData.append(data);
    columnData.append("");
    columnData.append(workOrder->executionTime().toString());

    QTreeWidgetItem *newItem = new QTreeWidgetItem(columnData);
    newItem->setData(0, Qt::UserRole, qVariantFromValue(workOrder));

    // Do font for save work orders
    if (workOrder->createsCleanState()) {
      QFont saveFont = newItem->font(0);
      saveFont.setBold(true);
      saveFont.setItalic(true);
      newItem->setFont(0, saveFont);
      newItem->setForeground(0, Qt::gray);
    }

    // Do font for progress text
    QFont progressFont = newItem->font(1);
    progressFont.setItalic(true);
    newItem->setFont(1, progressFont);
    newItem->setForeground(1, Qt::gray);

    invisibleRootItem()->addChild(newItem);

    connect(workOrder, SIGNAL(statusChanged(WorkOrder *)),
            this, SLOT(updateStatus(WorkOrder *)));
    connect(workOrder, SIGNAL(creatingProgress(WorkOrder *)),
            this, SLOT(updateProgressWidgets()));
    connect(workOrder, SIGNAL(deletingProgress(WorkOrder *)),
            this, SLOT(updateProgressWidgets()));

    if (workOrder->progressBar()) {
      setItemWidget(newItem, 1, workOrder->progressBar());
    }

    scrollToItem(newItem);
    refit();
  }


  void HistoryTreeWidget::updateProgressWidgets() {
    for (int i = 0; i < invisibleRootItem()->childCount(); i++) {
      QTreeWidgetItem *item = invisibleRootItem()->child(i);
      WorkOrder *workOrder = item->data(0, Qt::UserRole).value<WorkOrder *>();

      if (workOrder && itemWidget(item, 1) != workOrder->progressBar()) {
        setItemWidget(item, 1, workOrder->progressBar());
      }
    }
  }


  void HistoryTreeWidget::markNotUndone(QTreeWidgetItem *treeItem) {
    if (treeItem) {
      treeItem->setForeground(0, Qt::black);
      updateStatus(treeItem);
    }
  }


  void HistoryTreeWidget::markUndone(QTreeWidgetItem *treeItem) {
    if (treeItem) {
      treeItem->setForeground(0, Qt::gray);
      updateStatus(treeItem);
    }
  }


  void HistoryTreeWidget::handleUndoIndexChanged(int newIndex) {
    QTreeWidgetItem *prevItem = undoCommandToTreeItem(
        m_project->undoStack()->command(newIndex - 1));
    markNotUndone(prevItem);

    QTreeWidgetItem *curItem = undoCommandToTreeItem(m_project->undoStack()->command(newIndex));
    markUndone(curItem);

    markUndone(undoCommandToTreeItem(m_project->undoStack()->command(newIndex + 1)));

    scrollToItem(prevItem);
    scrollToItem(curItem);
  }


  void HistoryTreeWidget::removeFromHistory(QObject *deletedObject) {
    QTreeWidgetItem *itemToRemove = undoCommandToTreeItem(
        (QUndoCommand *)((WorkOrder *)deletedObject));

    if (itemToRemove) {
      int indexToDelete = invisibleRootItem()->indexOfChild(itemToRemove);

      if (indexToDelete < invisibleRootItem()->childCount()) {
        // Clear progress bar widget
        setItemWidget(invisibleRootItem()->child(indexToDelete), 1, NULL);

        // Take & delete the tree item
        delete invisibleRootItem()->takeChild(indexToDelete);
      }
    }
  }


  QTreeWidgetItem *HistoryTreeWidget::undoCommandToTreeItem(const QUndoCommand *undoCommand) {
    QTreeWidgetItem *result = NULL;

    if (undoCommand) {
      for (int i = invisibleRootItem()->childCount() - 1; !result && i >= 0; i--) {
        QTreeWidgetItem *item = invisibleRootItem()->child(i);
        WorkOrder *workOrder = item->data(0, Qt::UserRole).value<WorkOrder *>();

        if (undoCommand == workOrder)
          result = item;
      }
    }

    return result;
  }


  void HistoryTreeWidget::showHistory() {
    foreach (QTreeWidgetItem *item, invisibleRootItem()->takeChildren()) {
      delete item;
    }

    foreach (WorkOrder *workOrder, m_project->workOrderHistory()) {
      addToHistory(workOrder);
    }
  }


  void HistoryTreeWidget::updateStatus(WorkOrder *workOrder) {
    undoCommandToTreeItem(workOrder)->setText(1, workOrder->statusText());
  }
}