ImageList.cpp

Go to the documentation of this file.

 
#include "Image.h"
#include "ImageList.h"
#include "IException.h"
 
#include <QAction>
#include <QColorDialog>
#include <QDebug>
#include <QDir>
#include <QFile>
#include <QFuture>
#include <QInputDialog>
#include <QLabel>
#include <QProgressDialog>
#include <QtConcurrentMap>
#include <QXmlStreamWriter>
 
#include "Color.h"
#include "FileName.h"
#include "IException.h"
#include "IString.h"
#include "Project.h"
#include "XmlStackedHandlerReader.h"
 
namespace Isis {
  ImageList::ImageList(QString name, QString path, QObject *parent) : QObject(parent) {
    m_name = name;
    m_path = path;
  }
 
 
  ImageList::ImageList(QObject *parent) : QObject(parent) {
  }
 
 
  ImageList::ImageList(QList<Image *> images, QObject *parent) : QObject(parent) {
    append(images);
  }
 
 
  ImageList::ImageList(Project *project, XmlStackedHandlerReader *xmlReader, QObject *parent) :
      QObject(parent) {
    xmlReader->pushContentHandler(new XmlHandler(this, project));
  }
 
 
  ImageList::ImageList(const ImageList &other) :
      QList<Image *>(other) {
    m_name = other.m_name;
    m_path = other.m_path;
  }
 
 
  ImageList::ImageList(QStringList &fileNames) {
    foreach (QString fileName, fileNames) {
      try {
        Image *image = new Image(fileName);
        append(image);
        image->closeCube();
      }
      catch (IException &) {
      }
    }
  }
 
 
  ImageList::~ImageList() {
  }
 
 
  SerialNumberList *ImageList::serialNumberList() {
 
    SerialNumberList *result = new SerialNumberList();
 
    for (int i = 0; i < count(); i++) {
      result->add((*this)[i]->fileName());
    }
    return result;
  }
 
 
  void ImageList::append(Image * const &value) {
    QList<Image *>::append(value);
    emit countChanged(count());
  }
 
 
  void ImageList::append(const QList<Image *> &value) {
    QList<Image *>::append(value);
    emit countChanged(count());
  }
 
 
  void ImageList::clear() {
    bool countChanging = count();
    QList<Image *>::clear();
    if (countChanging) {
      emit countChanged(count());
    }
  }
 
 
  QList<Image *>::iterator ImageList::erase(iterator pos) {
    iterator result = QList<Image *>::erase(pos);
    emit countChanged(count());
    return result;
  }
 
 
  QList<Image *>::iterator ImageList::erase(iterator begin, iterator end) {
    iterator result = QList<Image *>::erase(begin, end);
    emit countChanged(count());
    return result;
  }
 
 
  void ImageList::insert(int i, Image * const &value) {
    QList<Image *>::insert(i, value);
 
    emit countChanged(count());
  }
 
 
  QList<Image *>::iterator ImageList::insert(iterator before, Image * const &value) {
    iterator result = QList<Image *>::insert(before, value);
    emit countChanged(count());
    return result;
  }
 
 
  void ImageList::prepend(Image * const &value) {
    QList<Image *>::prepend(value);
    emit countChanged(count());
  }
 
 
  void ImageList::push_back(Image * const &value) {
    QList<Image *>::push_back(value);
    emit countChanged(count());
  }
 
 
  void ImageList::push_front(Image * const &value) {
    QList<Image *>::push_front(value);
    emit countChanged(count());
  }
 
 
  int ImageList::removeAll(Image * const &value) {
    int result = QList<Image *>::removeAll(value);
 
    if (result != 0) {
      emit countChanged(count());
    }
 
    return result;
  }
 
 
  void ImageList::removeAt(int i) {
    QList<Image *>::removeAt(i);
    emit countChanged(count());
  }
 
 
  void ImageList::removeFirst() {
    QList<Image *>::removeFirst();
    emit countChanged(count());
  }
 
 
  void ImageList::removeLast() {
    QList<Image *>::removeLast();
    emit countChanged(count());
  }
 
 
  bool ImageList::removeOne(Image * const &value) {
    bool result = QList<Image *>::removeOne(value);
 
    if (result) {
      emit countChanged(count());
    }
 
    return result;
  }
 
 
  void ImageList::swap(QList<Image *> &other) {
    QList<Image *>::swap(other);
 
    if (count() != other.count()) {
      emit countChanged(count());
    }
  }
 
 
  Image *ImageList::takeAt(int i) {
    Image * result = QList<Image *>::takeAt(i);
    emit countChanged(count());
    return result;
  }
 
 
  Image *ImageList::takeFirst() {
    Image *result = QList<Image *>::takeFirst();
    emit countChanged(count());
    return result;
  }
 
 
  Image *ImageList::takeLast() {
    Image *result = QList<Image *>::takeLast();
    emit countChanged(count());
    return result;
  }
 
 
  ImageList &ImageList::operator+=(const QList<Image *> &other) {
    QList<Image *>::operator+=(other);
 
    if (other.count()) {
      emit countChanged(count());
    }
 
    return *this;
  }
 
 
  ImageList &ImageList::operator+=(Image * const &other) {
    QList<Image *>::operator+=(other);
    emit countChanged(count());
    return *this;
  }
 
 
  ImageList &ImageList::operator<<(const QList<Image *> &other) {
    QList<Image *>::operator<<(other);
 
    if (other.count()) {
      emit countChanged(count());
    }
 
    return *this;
  }
 
 
  ImageList &ImageList::operator<<(Image * const &other) {
    QList<Image *>::operator<<(other);
    emit countChanged(count());
    return *this;
  }
 
 
  ImageList &ImageList::operator=(const QList<Image *> &rhs) {
    bool countChanging = (rhs.count() != count());
    QList<Image *>::operator=(rhs);
 
    if (countChanging) {
      emit countChanged(count());
    }
 
    return *this;
  }
 
 
  ImageList &ImageList::operator=(const ImageList &rhs) {
    bool countChanging = (rhs.count() != count());
    QList<Image *>::operator=(rhs);
 
    m_name = rhs.m_name;
    m_path = rhs.m_path;
 
    if (countChanging) {
      emit countChanged(count());
    }
 
    return *this;
  }
 
 
  QList<QAction *> ImageList::supportedActions(Project *project) {
 
    QList<QAction *> actions;
 
    // It turns out connect() statements cannot be templated, hence they aren't inside of
    //   createWorkOrder().
    if (allSupport(ImageDisplayProperties::Color)) {
 
      QAction *alphaAction = createWorkOrder(project, ImageListActionWorkOrder::ChangeTransparency);
      if (!project) {
        connect(alphaAction, SIGNAL(triggered()),
                this, SLOT(askAndUpdateAlpha()));
      }
      actions.append(alphaAction);
 
      QAction *colorAction = createWorkOrder(project, ImageListActionWorkOrder::ChangeColor);
      if (!project) {
        connect(colorAction, SIGNAL(triggered()),
                this, SLOT(askAndUpdateColor()));
      }
      actions.append(colorAction);
 
      QAction *ranColorAction = createWorkOrder(project, ImageListActionWorkOrder::RandomizeColor);
      if (!project) {
        connect(ranColorAction, SIGNAL(triggered()),
                this, SLOT(showRandomColor()));
      }
      actions.append(ranColorAction);
    }
 
    if (allSupport(ImageDisplayProperties::ShowLabel)) {
      QAction *labelVisibleAction = createWorkOrder(project,
                                                    ImageListActionWorkOrder::ToggleShowLabel);
      if (!project) {
        connect(labelVisibleAction, SIGNAL(triggered()),
                this, SLOT(saveAndToggleShowLabel()));
      }
      actions.append(labelVisibleAction);
    }
 
    if (allSupport(ImageDisplayProperties::ShowFill)) {
      QAction *fillAction = createWorkOrder(project, ImageListActionWorkOrder::ToggleShowFilled);
      if (!project) {
        connect(fillAction, SIGNAL(triggered()),
                this, SLOT(saveAndToggleShowFill()));
      }
      actions.append(fillAction);
    }
 
    if (allSupport(ImageDisplayProperties::ShowDNs)) {
      QAction *cubeDataAction = createWorkOrder(project,
                                                ImageListActionWorkOrder::ToggleShowCubeData);
      if (!project) {
        connect(cubeDataAction, SIGNAL(triggered()),
                this, SLOT(saveAndToggleShowDNs()));
      }
      actions.append(cubeDataAction);
    }
 
    if (allSupport(ImageDisplayProperties::ShowOutline)) {
      QAction *outlineAction = createWorkOrder(project,
                                               ImageListActionWorkOrder::ToggleShowOutline);
      if (!project) {
        connect(outlineAction, SIGNAL(triggered()),
                this, SLOT(saveAndToggleShowOutline()));
      }
      actions.append(outlineAction);
    }
 
    actions.append(NULL);
 
    if (allSupport(ImageDisplayProperties::ZOrdering)) {
 
      QAction *moveToTopAct = createWorkOrder(project, ImageListActionWorkOrder::MoveToTop);
      QAction *moveUpAct = createWorkOrder(project, ImageListActionWorkOrder::MoveUpOne);
      QAction *moveToBottomAct = createWorkOrder(project, ImageListActionWorkOrder::MoveToBottom);
      QAction *moveDownAct = createWorkOrder(project, ImageListActionWorkOrder::MoveDownOne);
 
      foreach (Image *image, *this) {
        connect(moveToTopAct, SIGNAL(triggered()),
                image->displayProperties(), SIGNAL(moveToTop()));
 
        connect(moveUpAct, SIGNAL(triggered()),
                image->displayProperties(), SIGNAL(moveUpOne()));
 
        connect(moveToBottomAct, SIGNAL(triggered()),
                image->displayProperties(), SIGNAL(moveToBottom()));
 
        connect(moveDownAct, SIGNAL(triggered()),
                image->displayProperties(), SIGNAL(moveDownOne()));
      }
 
      actions.append(moveToTopAct);
      actions.append(moveUpAct);
      actions.append(moveToBottomAct);
      actions.append(moveDownAct);
    }
 
    actions.append(NULL);
 
    if (size() == 1 && allSupport(ImageDisplayProperties::Zooming)) {
      QAction *zoomFit = createWorkOrder(project, ImageListActionWorkOrder::ZoomFit);
      connect(zoomFit, SIGNAL(triggered()),
              first()->displayProperties(), SIGNAL(zoomFit()));
      actions.append(zoomFit);
    }
 
    return actions;
  }
 
 
  bool ImageList::allSupport(ImageDisplayProperties::Property prop) {
    if (isEmpty())
      return false;
 
    foreach (Image *image, *this) {
      if (!image->displayProperties()->supports(prop))
        return false;
    }
 
    return true;
  }
 
 
  void ImageList::setName(QString newName) {
    m_name = newName;
  }
 
 
  void ImageList::setPath(QString newPath) {
    m_path = newPath;
  }
 
 
  QString ImageList::name() const {
    return m_name;
  }
 
 
  QString ImageList::path() const {
    return m_path;
  }
 
 
  void ImageList::deleteFromDisk(Project *project) {
    foreach (Image *image, *this) {
      image->deleteFromDisk();
    }
 
    if (!m_path.isEmpty()) {
      QFile::remove(project->imageDataRoot() + "/" + m_path + "/images.xml");
 
      QDir dir;
      dir.rmdir(project->imageDataRoot() + "/" + m_path);
    }
  }
 
 
  void ImageList::save(QXmlStreamWriter &stream, const Project *project, FileName newProjectRoot)
      const {
    stream.writeStartElement("imageList");
    stream.writeAttribute("name", m_name);
    stream.writeAttribute("path", m_path);
    // The newProjectRoot contains the full path and we want the dataRoot to be relative to the
    // projectRoot so that projects can be moved. 
    QString dataRoot =
        Project::imageDataRoot(newProjectRoot.toString()).remove(project->newProjectRoot());
    // Get rid of any preceding "/"
    if (dataRoot.startsWith("/")) {
      dataRoot.remove(0,1);
    }
    stream.writeAttribute("dataRoot", dataRoot);
 
    FileName settingsFileName(Project::imageDataRoot(newProjectRoot.toString()) +
                              "/" + m_path + "/images.xml");
 
    if (!settingsFileName.dir().mkpath(settingsFileName.path())) {
      throw IException(IException::Io,
                       QString("Failed to create directory [%1]")
                         .arg(settingsFileName.path()),
                       _FILEINFO_);
    }
    QFile imageListContentsFile(settingsFileName.toString());
 
    if (!imageListContentsFile.open(QIODevice::ReadWrite | QIODevice::Truncate)) {
      throw IException(IException::Io,
          QString("Unable to save image information for [%1] because [%2] could not be opened for "
                  "writing")
            .arg(m_name).arg(settingsFileName.original()),
          _FILEINFO_);
    }
 
    QXmlStreamWriter imageDetailsWriter(&imageListContentsFile);
    imageDetailsWriter.setAutoFormatting(true);
    imageDetailsWriter.writeStartDocument();
 
    imageDetailsWriter.writeStartElement("images");
 
    // Only copy images if saving to new location
    if (project->newProjectRoot() != project->projectRoot()) {
      int countWidth = QString("%1L").arg(count()).size() - 1;
      QChar paddingChar('0');
 
      QLabel *progressLabel = new QLabel;
 
      QProgressDialog progressDialog;
      progressDialog.setLabel(progressLabel);
      progressDialog.setRange(-1, count());
      progressDialog.setValue(-1);
 
      // Mapped is way faster than hundreds/thousands of run() calls... so use mapped for performance
      QFuture<void *> future = QtConcurrent::mapped(*this,
                                                    CopyImageDataFunctor(project, newProjectRoot));
 
      for (int i = 0; i < count(); i++) {
        int newProgressValue = progressDialog.value() + 1;
        progressLabel->setText(
            tr("Saving Image Information for [%1] - %L2/%L3 done")
              .arg(m_name)
              .arg(newProgressValue, countWidth, 10, paddingChar)
              .arg(count()));
        progressDialog.setValue(newProgressValue);
        try {
          future.resultAt(i);
        }
        catch(std::exception &e) {
          QString msg("Could not save ImageList: "+this->name() );
          throw IException(IException::Io,msg,_FILEINFO_);
        }
      }
 
      progressLabel->setText(tr("Finalizing..."));
      progressDialog.setRange(0, 0);
      progressDialog.setValue(0);
    }
 
    foreach (Image *image, *this) {
      image->save(imageDetailsWriter, project, newProjectRoot);
    }
 
    imageDetailsWriter.writeEndElement();
 
    imageDetailsWriter.writeEndDocument();
 
    stream.writeEndElement();
  }
 
 
  ImageList::CopyImageDataFunctor::CopyImageDataFunctor(const Project *project,
                                                        FileName newProjectRoot) {
    m_project = project;
    m_newProjectRoot = newProjectRoot;
  }
 
 
  ImageList::CopyImageDataFunctor::CopyImageDataFunctor(const CopyImageDataFunctor &other) {
    m_project = other.m_project;
    m_newProjectRoot = other.m_newProjectRoot;
  }
 
 
  ImageList::CopyImageDataFunctor::~CopyImageDataFunctor() {
  }
 
 
  void *ImageList::CopyImageDataFunctor::operator()(Image * const &imageToCopy) {
    try {
      imageToCopy->copyToNewProjectRoot(m_project, m_newProjectRoot); 
    }
    catch (IException &e) {
      IString msg = "Could not copy image [" + imageToCopy->displayProperties()->displayName() +
                    "]";
      throw IException(e, IException::Io, msg, _FILEINFO_);
    }
    return NULL;
  }
 
 
  ImageList::CopyImageDataFunctor &ImageList::CopyImageDataFunctor::operator=(
      const CopyImageDataFunctor &rhs) {
    m_project = rhs.m_project;
    m_newProjectRoot = rhs.m_newProjectRoot;
    return *this;
  }
 
 
  void ImageList::applyAlphas(QStringList alphaValues) {
    if (count() == alphaValues.count()) {
      for (int i = 0; i < count(); i++) {
        ImageDisplayProperties *dispProps = (*this)[i]->displayProperties();
        QColor color = dispProps->getValue(ImageDisplayProperties::Color).value<QColor>();
        color.setAlpha(alphaValues[i].toInt());
        dispProps->setColor(color);
      }
    }
  }
 
 
  void ImageList::applyColors(QStringList colorValues, int column) {
    if (count() == colorValues.count()) {
      for (int i = 0; i < count(); i++) {
        QString colorData = colorValues[i].split(" ")[column];
        (*this)[i]->displayProperties()->setColor(Color::fromRGBAString(colorData));
      }
    }
  }
 
 
  void ImageList::applyShowLabel(QStringList showLabelValues) {
    if (count() == showLabelValues.count()) {
      for (int i = 0; i < count(); i++) {
        ImageDisplayProperties *dispProps = (*this)[i]->displayProperties();
        dispProps->setShowLabel(showLabelValues[i] == "shown");
      }
    }
  }
 
 
  void ImageList::applyShowFill(QStringList showFillValues) {
    if (count() == showFillValues.count()) {
      for (int i = 0; i < count(); i++) {
        ImageDisplayProperties *dispProps = (*this)[i]->displayProperties();
        dispProps->setShowFill(showFillValues[i] == "shown");
      }
    }
  }
 
 
  void ImageList::applyShowDNs(QStringList showDNsValues) {
    if (count() == showDNsValues.count()) {
      for (int i = 0; i < count(); i++) {
        ImageDisplayProperties *dispProps = (*this)[i]->displayProperties();
        dispProps->setShowDNs(showDNsValues[i] == "shown");
      }
    }
  }
 
 
  void ImageList::applyShowOutline(QStringList showOutlineValues) {
    if (count() == showOutlineValues.count()) {
      for (int i = 0; i < count(); i++) {
        ImageDisplayProperties *dispProps = (*this)[i]->displayProperties();
        dispProps->setShowOutline(showOutlineValues[i] == "shown");
      }
    }
  }
 
 
  bool ImageList::askAlpha(int *alphaResult) const {
    bool result = false;
 
    if (!isEmpty()) {
      ImageDisplayProperties *dispProps = first()->displayProperties();
      *alphaResult = QInputDialog::getInt(NULL, "Transparency Value",
          "Set the cube's transparency\nValues are 0 (invisible) to 255 (solid)",
          dispProps->getValue(ImageDisplayProperties::Color).value<QColor>().alpha(),
          0, 255, 1, &result);
    }
 
    return result;
  }
 
 
  bool ImageList::askNewColor(QColor *colorResult) const {
    *colorResult = QColor();
 
    if (!isEmpty()) {
      ImageDisplayProperties *dispProps = first()->displayProperties();
      *colorResult = QColorDialog::getColor(
          dispProps->getValue(ImageDisplayProperties::Color).value<QColor>(), NULL,
          "Cube Display Color",
          QColorDialog::ShowAlphaChannel);
    }
 
    return colorResult->isValid();
  }
 
 
  QStringList ImageList::saveAndApplyAlpha(int newAlpha) {
    QStringList results;
    foreach (Image *image, *this) {
      ImageDisplayProperties *displayProperties = image->displayProperties();
 
      QColor displayColor = displayProperties->getValue(
          ImageDisplayProperties::Color).value<QColor>();
 
      results.append(QString::number(displayColor.alpha()));
 
      displayColor.setAlpha(newAlpha);
      displayProperties->setColor(displayColor);
    }
 
    return results;
  }
 
 
  QStringList ImageList::saveAndApplyColor(QColor newColor) {
    QStringList results;
 
    if (newColor.isValid()) {
      foreach (Image *image, *this) {
        ImageDisplayProperties *displayProperties = image->displayProperties();
 
        QColor displayColor = displayProperties->getValue(
            ImageDisplayProperties::Color).value<QColor>();
 
        results.append(Color::toRGBAString(displayColor));
 
        displayProperties->setColor(newColor);
      }
    }
 
    return results;
  }
 
 
  QStringList ImageList::saveAndApplyRandomColor() {
    QStringList results;
 
    foreach (Image *image, *this) {
      QColor ranColor = ImageDisplayProperties::randomColor();
 
      ImageDisplayProperties *displayProperties = image->displayProperties();
 
      QColor displayColor = displayProperties->getValue(
          ImageDisplayProperties::Color).value<QColor>();
 
      // Preserve alpha
      ranColor.setAlpha(displayColor.alpha());
 
      // QColor::name() doesn't preserve alpha.
      results.append(
          QString("%1 %2").arg(Color::toRGBAString(displayColor))
                          .arg(Color::toRGBAString(ranColor)));
 
      displayProperties->setColor(ranColor);
    }
 
    return results;
  }
 
 
  void ImageList::askAndUpdateAlpha() {
    int newAlpha = 255;
 
    if (askAlpha(&newAlpha)) {
      saveAndApplyAlpha(newAlpha);
    }
  }
 
 
  void ImageList::askAndUpdateColor() {
    QColor newColor;
    askNewColor(&newColor);
    saveAndApplyColor(newColor);
  }
 
 
  void ImageList::showRandomColor() {
    foreach (Image *image, *this) {
      QColor ranColor = ImageDisplayProperties::randomColor();
      image->displayProperties()->setColor(ranColor);
    }
  }
 
 
  QStringList ImageList::saveAndToggleShowDNs() {
    QStringList results;
 
    if (!isEmpty()) {
      ImageDisplayProperties *firstDisplayProperties = first()->displayProperties();
      bool newValue = !firstDisplayProperties->getValue(ImageDisplayProperties::ShowDNs).toBool();
 
      foreach (Image *image, *this) {
        ImageDisplayProperties *displayProps = image->displayProperties();
 
        bool value = displayProps->getValue(ImageDisplayProperties::ShowDNs).toBool();
        results.append(value? "shown" : "hidden");
 
        image->displayProperties()->setShowDNs(newValue);
      }
    }
 
    return results;
  }
 
 
  QStringList ImageList::saveAndToggleShowFill() {
    QStringList results;
 
    if (!isEmpty()) {
      ImageDisplayProperties *firstDisplayProps = first()->displayProperties();
      bool newValue = !firstDisplayProps->getValue(ImageDisplayProperties::ShowFill).toBool();
 
      foreach (Image *image, *this) {
        ImageDisplayProperties *displayProps = image->displayProperties();
 
        bool value = displayProps->getValue(ImageDisplayProperties::ShowFill).toBool();
        results.append(value? "shown" : "hidden");
 
        image->displayProperties()->setShowFill(newValue);
      }
    }
 
    return results;
  }
 
 
  QStringList ImageList::saveAndToggleShowLabel() {
    QStringList results;
 
    if (!isEmpty()) {
      ImageDisplayProperties *firstDisplayProps = first()->displayProperties();
      bool newValue = !firstDisplayProps->getValue(ImageDisplayProperties::ShowLabel).toBool();
 
      foreach (Image *image, *this) {
        ImageDisplayProperties *displayProps = image->displayProperties();
 
        bool value = displayProps->getValue(ImageDisplayProperties::ShowLabel).toBool();
        results.append(value? "shown" : "hidden");
 
        image->displayProperties()->setShowLabel(newValue);
      }
    }
 
    return results;
  }
 
 
  QStringList ImageList::saveAndToggleShowOutline() {
    QStringList results;
 
    if (!isEmpty()) {
      ImageDisplayProperties *firstDisplayProps = first()->displayProperties();
      bool newValue = !firstDisplayProps->getValue(ImageDisplayProperties::ShowOutline).toBool();
 
      foreach (Image *image, *this) {
        ImageDisplayProperties *displayProps = image->displayProperties();
 
        bool value = displayProps->getValue(ImageDisplayProperties::ShowOutline).toBool();
        results.append(value? "shown" : "hidden");
 
        image->displayProperties()->setShowOutline(newValue);
      }
    }
 
    return results;
  }
 
 
  ImageList::XmlHandler::XmlHandler(ImageList *imageList, Project *project, QString dataRoot) {
    m_imageList = imageList;
    m_project = project;
    m_imageDataRoot = dataRoot;
  }
 
 
  bool ImageList::XmlHandler::startElement(const QString &namespaceURI, const QString &localName,
                                           const QString &qName, const QXmlAttributes &atts) {
    if (XmlStackedHandler::startElement(namespaceURI, localName, qName, atts)) {
      if (localName == "imageList") {
        QString name = atts.value("name");
        QString path = atts.value("path");
        m_imageDataRoot = atts.value("dataRoot");
 
        if (!name.isEmpty()) {
          m_imageList->setName(name);
        }
 
        if (!path.isEmpty()) {
          m_imageList->setPath(path);
        }
      }
      else if (localName == "image") {
        m_imageList->append(new Image(
           m_project->projectRoot() + "/" + m_imageDataRoot + "/" + m_imageList->path(), reader()));
      }
    }
 
    return true;
  }
 
 
  bool ImageList::XmlHandler::endElement(const QString &namespaceURI, const QString &localName,
                                         const QString &qName) {
    if (localName == "imageList") {
      XmlHandler handler(m_imageList, m_project, m_imageDataRoot);
 
      XmlStackedHandlerReader reader;
      reader.pushContentHandler(&handler);
      reader.setErrorHandler(&handler);
 
      QDir projectPath = QDir(m_project->projectRoot()).dirName();
      QString imageListXmlPath = m_project->projectRoot() + "/" + m_imageDataRoot + "/" +
                                 m_imageList->path() + "/images.xml";
      imageListXmlPath = QDir::cleanPath(imageListXmlPath);
 
      QFile file(imageListXmlPath);
 
      if (!file.open(QFile::ReadOnly)) {
        throw IException(IException::Io,
                         QString("Unable to open [%1] with read access")
                           .arg(imageListXmlPath),
                         _FILEINFO_);
      }
 
      QXmlInputSource xmlInputSource(&file);
      if (!reader.parse(xmlInputSource))
        throw IException(IException::Io,
                         tr("Failed to open image list XML [%1]").arg(imageListXmlPath),
                         _FILEINFO_);
    }
 
    return XmlStackedHandler::endElement(namespaceURI, localName, qName);
  }
}