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(Project *project, QWidget *parent) : QTreeWidget(parent) {…}
 

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

  int HistoryTreeWidget::sizeHintForColumn(int column) const {
    int result = -1;
 
    QFontMetrics metrics(invisibleRootItem()->font(1));
    int dateTimeColumnWidth = qRound(metrics.horizontalAdvance(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;
  }
  int HistoryTreeWidget::sizeHintForColumn(int column) const  {…}
 

  void HistoryTreeWidget::refit() {
    resizeColumnToContents(0);
    resizeColumnToContents(1);
    resizeColumnToContents(2);
  }
  void HistoryTreeWidget::refit() {…}
 
 
  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, QVariant::fromValue(workOrder));
 
    // Do font for save work orders or work orders not on QUndoStack
    if (workOrder->createsCleanState() || !workOrder->isUndoable()) {
      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);
 
      this->insertTopLevelItem(0, 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()));
 
 
      //Sometimes the pointer returned by this call is 0 (hence the check).
      //So we are not creating a progress bar for every work order which would
      //include those that do not need it.
 
      if(workOrder->progressBar() )  {
        this->setItemWidget(newItem, 1, workOrder->progressBar() );
      }
      scrollToItem(newItem);
      refit();
  }
  void HistoryTreeWidget::addToHistory(WorkOrder *workOrder) {…}
 

  void HistoryTreeWidget::addToHistory(QString historyEntry) {
 
    QString data = historyEntry;
 
    QStringList columnData;
    columnData.append(data);
 
    QTreeWidgetItem *newItem = new QTreeWidgetItem(columnData);
 
 
    // Do font for progress text
    QFont progressFont = newItem->font(1);
    progressFont.setItalic(true);
    newItem->setFont(1, progressFont);
    newItem->setForeground(1, Qt::gray);
 
    this->insertTopLevelItem(0, newItem);
//      invisibleRootItem()->addChild(newItem);
 
    //Sometimes the pointer returned by this call is 0 (hence the check).
    //So we are not creating a progress bar for every work order which would
    //include those that do not need it.
 
//    if(workOrder->progressBar() )  {
//      setItemWidget(newItem, 1, new ProgressBar);
//    }
    scrollToItem(newItem);
    refit();
  }
  void HistoryTreeWidget::addToHistory(QString historyEntry) {…}
 

  void HistoryTreeWidget::updateProgressWidgets() {
    if( !m_project->clearing() ){
      for (int i = 0; i < invisibleRootItem()->childCount(); i++) {
        QTreeWidgetItem *item = invisibleRootItem()->child(i);
        if (item->data(0, Qt::UserRole).toString() != "") {
          WorkOrder *workOrder = item->data(0, Qt::UserRole).value<WorkOrder *>();
          if (workOrder && itemWidget(item, 1) != workOrder->progressBar()) {
            setItemWidget(item, 1, workOrder->progressBar());
          }
        }
      }
    }
  }
  void HistoryTreeWidget::updateProgressWidgets() {…}
 

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

  void HistoryTreeWidget::markUndone(QTreeWidgetItem *treeItem) {
    if (treeItem) {
      treeItem->setForeground(0, Qt::gray);
      updateStatus(treeItem);
    }
  }
  void HistoryTreeWidget::markUndone(QTreeWidgetItem *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::handleUndoIndexChanged(int newIndex) {…}
 

  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);
      }
    }
  }
  void HistoryTreeWidget::removeFromHistory(QObject *deletedObject) {…}
 

  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);
        if (item->data(0, Qt::UserRole).toString() != "" ) {
          WorkOrder *workOrder = item->data(0, Qt::UserRole).value<WorkOrder *>();
 
          if (undoCommand == workOrder)
            result = item;
        }
      }
    }
    return result;
  }
  QTreeWidgetItem *HistoryTreeWidget::undoCommandToTreeItem(const QUndoCommand *undoCommand) {…}
 

  void HistoryTreeWidget::showHistory() {
    foreach (QTreeWidgetItem *item, invisibleRootItem()->takeChildren()) {
      delete item;
    }
 
    foreach (WorkOrder *workOrder, m_project->workOrderHistory()) {
      addToHistory(workOrder);
    }
  }
  void HistoryTreeWidget::showHistory() {…}
 
 
  void HistoryTreeWidget::updateStatus(WorkOrder *workOrder) {
    if (undoCommandToTreeItem(workOrder)) {
      undoCommandToTreeItem(workOrder)->setText(1, workOrder->statusText());
    }
 
  }
}