Workspace.cpp

#include "Workspace.h"
 
#include <QMenuBar>
#include <QMessageBox>
#include <QProgressBar>
#include <QStatusBar>
#include <QString>
#include <QToolBar>
#include <QVBoxLayout>
#include <QVector>
#include <QWeakPointer>
 
#include "AdvancedTrackTool.h"
#include "BandTool.h"
#include "BlinkTool.h"
#include "Cube.h"
#include "CubeAttribute.h"
#include "EditTool.h"
#include "FeatureNomenclatureTool.h"
#include "FileName.h"
#include "FileTool.h"
#include "FindTool.h"
#include "HelpTool.h"
#include "HistogramTool.h"
#include "Image.h"
#include "ImageList.h"
#include "IString.h"
#include "MatchTool.h"
#include "MdiCubeViewport.h"
#include "MeasureTool.h"
#include "PanTool.h"
#include "RubberBandTool.h"
#include "QnetFileTool.h"
#include "QnetNavTool.h"
#include "QnetTool.h"
#include "ScatterPlotTool.h"
#include "SpatialPlotTool.h"
#include "SpecialPixelTool.h"
#include "SpectralPlotTool.h"
#include "StatisticsTool.h"
#include "StereoTool.h"
#include "StretchTool.h"
#include "SunShadowTool.h"
#include "TrackTool.h"
#include "ToolList.h"
#include "ToolPad.h"
#include "ViewportMdiSubWindow.h"
#include "WindowTool.h"
#include "ZoomTool.h"
 
namespace Isis {
 
  Workspace::Workspace(bool selfContained, QWidget *parent) : QWidget(parent) {
    m_cubeViewportList = NULL;
    m_tools = NULL;
 
    m_cubeViewportList = new QVector< MdiCubeViewport * >;
    m_tools = new ToolList;
 
    m_mdi = new QMdiArea(this);
 
    QGridLayout *layout = new QGridLayout;
    setLayout(layout);
 
    if (!selfContained) {
      layout->setContentsMargins(0, 0, 0, 0);
      layout->addWidget(m_mdi, 0, 0);
    }
    else {
      /*
       * Layout:
       *
       * ----- MENU ----------------------
       * -PERM TOOLBAR-ACTIVE TOOLBAR------
       * |                              |T|
       * |                              |O|
       * |                              |O|
       * |    MDI AREA                  |L|
       * |                              | |
       * |                              |L|
       * |                              |I|
       * |                              |S|
       * |                              |T|
       * ------------Status Bar------------
       *
       * The perm/active tool bar are in an hbox layout, the rest follows the grid.
       */
      int row = 0;
 
      QMenuBar *menuBar = new QMenuBar;
      layout->addWidget(menuBar, row, 0, 1, 2);
      row++;
 
      QHBoxLayout *permActiveToolBarLayout = new QHBoxLayout;
 
      QToolBar *permToolBar = new QToolBar("Standard Tools", this);
      permToolBar->setObjectName("permToolBar");
      permToolBar->setIconSize(QSize(22, 22));
      permActiveToolBarLayout->addWidget(permToolBar);
 
      QToolBar *activeToolBar = new QToolBar("Active Tool", this);
      activeToolBar->setObjectName("activeToolBar");
      activeToolBar->setIconSize(QSize(22, 22));
      permActiveToolBarLayout->addWidget(activeToolBar);
 
      layout->addLayout(permActiveToolBarLayout, row, 0, 1, 2);
      row++;
 
      layout->addWidget(m_mdi, row, 0, 1, 1);
 
      ToolPad *toolPad = new ToolPad("Tool Pad", this);
      toolPad->setObjectName("toolPad");
      toolPad->setOrientation(Qt::Vertical);
      layout->addWidget(toolPad, row, 1, 1, 1);
      row++;
 
      QStatusBar *statusBar = new QStatusBar(this);
      layout->addWidget(statusBar, row, 0, 1, 2);
      row++;
 
      // Create tools
      Tool *defaultActiveTool = NULL;
 
      m_tools->append(new RubberBandTool(this));
      QnetTool *qnetTool = new QnetTool(this);
      //m_tools->append(new FileTool(this));
      m_tools->append(new QnetFileTool(qnetTool, this));
      m_tools->append(NULL);
      m_tools->append(new BandTool(this));
 
      defaultActiveTool = new ZoomTool(this);
      m_tools->append(defaultActiveTool);
 
      m_tools->append(new PanTool(this));
      m_tools->append(new StretchTool(this));
      m_tools->append(new FindTool(this));
      m_tools->append(new BlinkTool(this));
      m_tools->append(new AdvancedTrackTool(this));
      m_tools->append(new EditTool(this));
      m_tools->append(new WindowTool(this));
      m_tools->append(new MeasureTool(this));
      m_tools->append(new SunShadowTool(this));
      m_tools->append(new FeatureNomenclatureTool(this));
      m_tools->append(new SpecialPixelTool(this));
      m_tools->append(new SpatialPlotTool(this));
      m_tools->append(new SpectralPlotTool(this));
      m_tools->append(new ScatterPlotTool(this));
      m_tools->append(new HistogramTool(this));
      m_tools->append(new StatisticsTool(this));
      m_tools->append(new StereoTool(this));
      m_tools->append(new MatchTool(this));
      m_tools->append(new HelpTool(this));
      m_tools->append(new TrackTool(statusBar));
 
      m_tools->append(new QnetNavTool(qnetTool, this));
      m_tools->append(qnetTool);
 
      QMap<QString, QMenu *> subMenus;
 
      for (int i = 0; i < m_tools->count(); i++) {
        Tool *tool = (*m_tools)[i];
 
        if (tool) {
          tool->addTo(this);
          tool->addToPermanent(permToolBar);
          tool->addToActive(activeToolBar);
          tool->addTo(toolPad);
 
          if (!tool->menuName().isEmpty()) {
            QString menuName = tool->menuName();
 
            QMenu *subMenu = subMenus[menuName];
 
            if (!subMenu) {
              subMenus[menuName] = menuBar->addMenu(menuName);
              subMenu = subMenus[menuName];
            }
 
            tool->addTo(subMenu);
          }
        }
        else {
          permToolBar->addSeparator();
        }
      }
 
      permToolBar->addSeparator();
      defaultActiveTool->activate(true);
    }
 
    connect(m_mdi, SIGNAL(subWindowActivated(QMdiSubWindow *)),
            this, SLOT(activateViewport(QMdiSubWindow *)));
    m_mdi->setActivationOrder(QMdiArea::ActivationHistoryOrder);
  }
 
 
  Workspace::Workspace(const Workspace &other) : m_cubeViewportList(NULL) {
    m_cubeViewportList =
      new QVector< MdiCubeViewport * >(*other.m_cubeViewportList);
  }
 
 
  Workspace::~Workspace() {
    delete m_cubeViewportList;
    m_cubeViewportList = NULL;
 
    delete m_tools;
    m_tools = NULL;
  }
 
 
  void Workspace::activateViewport(QMdiSubWindow *w) {
    if(w) {
      emit cubeViewportActivated((MdiCubeViewport *) w->widget()->layout()->itemAt(0)->widget());
    }
    //Check if there is no current window (on close)
    else if(!m_mdi->currentSubWindow()) {
      emit cubeViewportActivated((MdiCubeViewport *)NULL);
    }
  }
 
  QVector< MdiCubeViewport * > * Workspace::cubeViewportList() {
    m_cubeViewportList->clear();
 
    for(int i = 0; i < m_mdi->subWindowList().size(); i++) {
      m_cubeViewportList->push_back(
          (MdiCubeViewport *)m_mdi->subWindowList()[i]->widget()->layout()->itemAt(0)->widget());
    }
 
    return m_cubeViewportList;
  }
 
 
  Workspace &Workspace::operator=(Workspace other) {
    delete m_cubeViewportList;
    m_cubeViewportList = NULL;
 
    m_cubeViewportList = new QVector< MdiCubeViewport * >;
    *m_cubeViewportList = *other.m_cubeViewportList;
    return *this;
  }
 
 
  void Workspace::addImages(ImageList *images) {
    foreach (Image *image, *images) {
      addCubeViewport(image->cube());
    }
  }
 
 
  bool Workspace::confirmClose() {
    QVector< MdiCubeViewport * > viewports = *cubeViewportList();
 
    bool confirmed = true;
 
    for (int viewportIndex = 0; confirmed && viewportIndex < viewports.count(); viewportIndex++) {
      confirmed = viewports[viewportIndex]->confirmClose();
    }
 
    return confirmed;
  }
 
 
  QWidget *Workspace::cubeToMdiWidget(Cube *cube) {
    QWidget *result = NULL;
 
    for (int i = 0; !result && i < m_cubeViewportList->count(); i++) {
      MdiCubeViewport *viewport = (*m_cubeViewportList)[i];
 
      if (viewport->cube() == cube) {
        result = qobject_cast<QWidget *>(viewport->parent());
      }
    }
 
    return result;
  }
 
 
  QMdiArea *Workspace::mdiArea() {
    return m_mdi;
  }
 
 
  void Workspace::addCubeViewport(QString filename) {
 
    QFileInfo cubeFileName(filename);
 
    QString cubename = cubeFileName.filePath();
 
    try {
      Cube *cube = new Cube;
 
      // Read in the CubeAttribueInput from the cube name
      CubeAttributeInput inAtt(cubename);
      std::vector<QString> bands = inAtt.bands();
 
      // Set the virtual bands to the bands specified by the input
      cube->setVirtualBands(bands);
      cube->open(cubename);
 
      MdiCubeViewport *cvp = addCubeViewport(cube);
 
      // Check for RGB format (#R,#G,#B)
      if(bands.size() == 3) {
        IString st = IString(bands.at(0));
        int index_red = st.ToInteger();
        st = IString(bands.at(1));
        int index_green = st.ToInteger();
        st = IString(bands.at(2));
        int index_blue = st.ToInteger();
        cvp->viewRGB(index_red, index_green, index_blue);
      }
    }
 
    catch (IException &e) {
 
      QString message("Error opening cube [" + cubename + "]...\n");
      message += "Attempting to open [" + cubename + "] as a cube list...\n";
 
      try {
        addCubeViewportFromList(cubename);
      }
      catch (IException &e) {
        message += e.toString();
        throw IException(e, IException::User, message, _FILEINFO_);
      }
 
    }
  }
 
  void Workspace::addCubeViewportFromList(QString cubelist) {
 
    QFileInfo cubeFileName(cubelist);
 
    QList<QString> cubesToOpen;
 
    QFile file(cubeFileName.filePath());
    file.open(QIODevice::ReadOnly);
 
    QTextStream in(&file);
 
    // Loop through every cube name in the cube list and add it to a list of cubes to open.
    while ( !file.atEnd() ) {
      QString line = file.readLine().replace("\n", "");
      cubesToOpen.append(line);
    }
 
    file.close();
 
    for (int i = 0; i < cubesToOpen.size(); i++) {
 
      QString cubename;
      try {
        Cube *cube = new Cube;
        cubename = cubesToOpen.at(i);
 
        // Read in the CubeAttribueInput from the cube name
        CubeAttributeInput inAtt(cubename);
        std::vector<QString> bands = inAtt.bands();
 
        // Set the virtual bands to the bands specified by the input
        cube->setVirtualBands(bands);
        cube->open(cubename);
 
        MdiCubeViewport *cvp = addCubeViewport(cube);
 
        // Check for RGB format (#R,#G,#B)
        if(bands.size() == 3) {
          IString st = IString(bands.at(0));
          int index_red = st.ToInteger();
          st = IString(bands.at(1));
          int index_green = st.ToInteger();
          st = IString(bands.at(2));
          int index_blue = st.ToInteger();
          cvp->viewRGB(index_red, index_green, index_blue);
        }
      }
      catch (IException &e) {
               QString message("Error attempting to open [" + cubename + "] from list [" + cubelist + "]...\n");
 
               throw IException(e, IException::User, message, _FILEINFO_);
      }
    }
  }
 
  MdiCubeViewport *Workspace::addCubeViewport(Cube *cube) {
    MdiCubeViewport *result = NULL;
 
    try {
      ViewportMdiSubWindow *window(new ViewportMdiSubWindow(cube));
      window->setAttribute(Qt::WA_DeleteOnClose);
 
      m_mdi->addSubWindow(window);
 
      window->show();
 
      result = window->viewport();
      emit cubeViewportAdded(result);
    }
    catch(IException &e) {
      throw IException(e,
                       IException::Programmer,
                       tr("Error when attempting to show cube [%1]")
                         .arg(cube->fileName()),
                       _FILEINFO_);
    }
 
    return result;
  }
 
 
  void Workspace::addBrowseView(QString cubename) {
    /* Close the last browse window if necessary.  */
    if (m_mdi->subWindowList().size()) {
      QPointer<QMdiSubWindow> windowToRemove =
          m_mdi->subWindowList().last();
 
      m_mdi->removeSubWindow(windowToRemove.data());
 
      delete windowToRemove.data();
    }
 
    addCubeViewport(cubename);
  }
}