main_window.cpp

Go to the documentation of this file.

//--------------------------------------------------
//---------------------------------------------------


#include "../controller/controller.h"
#include "../global/settings.h"

#include "main_window.h"
#include "datasets_viewer.h"
#include "choose_views_dialog.h"
#include "tab_organizer.h"
#include "view_container_widget.h"
#include "algorithm_widget.h"
#include "dataset_configuration_tab_widget.h"
#include "settings/settings_dialog.h"
#include "choose_datasets_dialog.h"
#include "about_dialog.h"

#include "../algorithms/configuration.h"

#include <Inventor/Qt/SoQt.h>
#include <QtGui>
#include <QToolBar>
#include <QMessageBox>
#include <QPixmap>
#include <QSettings>

#include <vector>
#include <string>

#include <VolumeViz/nodes/SoVolumeRendering.h>

namespace imedgine
{

  // ---------------- public -------------------------

  //--------------------------------------------------

  MainWindow::MainWindow()
  : QMainWindow(),
    first_launch_(true),
    tab_organizer_(0),
    choose_views_dialog_(0),
    settings_dialog_(0),
    about_dialog_(0)
  {
    setupUI();
    updateRecentFileActions();
  }

  //--------------------------------------------------

  MainWindow::~MainWindow()
  {
  }

  // ---------------- public slots -------------------

  //--------------------------------------------------

  void MainWindow::newDatasetsAdded(
      std::vector<std::pair<dataset_key_type, dataset_type> > const& dataset_keys_and_types)
  {
    std::vector<std::pair<dataset_key_type, dataset_type> >::const_iterator iter = 
        dataset_keys_and_types.begin();
    for ( ; iter != dataset_keys_and_types.end(); ++iter)
    {
      loaded_datasets_.insert(*iter);
      datasets_viewer_->addDataset(iter->first);
      std::cout << "opening overview " << iter->first << std::endl;
      this->openOverview(iter->first, iter->second);
    }
  }
  
  //--------------------------------------------------
  
  void MainWindow::openOverview(dataset_key_type const& dataset, dataset_type type)
  {
    switch (type)
    {
      case ONE_BYTE_IMAGE_PIXEL_DATASET :
      case TWO_BYTE_IMAGE_PIXEL_DATASET :
      case FOUR_BYTE_IMAGE_PIXEL_DATASET :
      {
        tab_organizer_->openOverviewForImage(dataset);
        break;
      }
      case ONE_BYTE_VOLUME_PIXEL_DATASET :
      case TWO_BYTE_VOLUME_PIXEL_DATASET :
      case FOUR_BYTE_VOLUME_PIXEL_DATASET :
      {
        tab_organizer_->openOverviewForVolume(dataset);
      }
      default :
      {
        return;  
      }
    }
  }
  
  //--------------------------------------------------
  
  void MainWindow::openOverview(dataset_key_type const& dataset)
  {
    std::map<dataset_key_type, dataset_type>::const_iterator iter =
        loaded_datasets_.find(dataset);
    if (iter != loaded_datasets_.end())
    {
      this->openOverview(dataset, iter->second);
    }
  }

  //--------------------------------------------------

  void MainWindow::openNewWorkspace(std::vector<view_pointer_type> const& view_vector)
  {
    QString title = tr("Custom_Tab", "MainWindow");
    tab_organizer_->addTab(view_vector, title);
  }

  // ---------------- private slots ------------------

  //--------------------------------------------------

  void MainWindow::openFileFromDialog()
  {
    QFileDialog open_dialog(this);

    QVariant previous_open_path =
      (Settings::getInstance())->getValue("last_open_path", "/");

    QString open_path = open_dialog.getOpenFileName(
        this,
        tr("Choose a File to Open"),
        previous_open_path.toString(),
        "Analyze Files (*.hdr)");

    if(!open_path.isEmpty())
    {
      (Settings::getInstance())->setValue("last_open_path", QVariant(open_path));

      loadDataset(open_path);
    }
  }

  //--------------------------------------------------

  void MainWindow::openRecentFile()
  {
    QAction* action = qobject_cast<QAction *>(sender());
    if (action)
    {
       loadDataset((action->data()).toString());
    }
  }


  //--------------------------------------------------

  void MainWindow::newTabSlot()
  {
    if(choose_views_dialog_ == 0)
    {
      choose_views_dialog_ = new ChooseViewsDialog(this);
      connect(choose_views_dialog_, SIGNAL(sendViewVector(std::vector<view_pointer_type>)),
            this, SLOT(openNewWorkspace(std::vector<view_pointer_type>)));
    }
    choose_views_dialog_->show();
  }

  //--------------------------------------------------

  void MainWindow::closeDataset(dataset_key_type const& dataset_name)
  {
    if(datasets_viewer_->count() == 0)
    {
      toggleDatasetDependendActionStatus(false);
    }
    
    emit closeDatasetSignal(dataset_name);
    Controller::getInstance().removeDataset(dataset_name);
    emit datasetClosedSignal(dataset_name);

    loaded_datasets_.erase(dataset_name);
  }

  void MainWindow::checkForDirtyToSave()
  {
    // TODO: iterate the dirty flags of the loaded datasets
    // TODO: check for type of dataset
  }

  //--------------------------------------------------

  void MainWindow::saveSpecificVolumeDataset(dataset_key_type const& dataset_name)
  {
    //TODO: Does not work, and seg fault if not .hdr!
    //TODO: Check if the dataset already has a path, if not, call save as
    //TODO: substitute written.hdr with the saved path
    //TODO: exception handling!
    //TODO: write permissions
    //TODO: add extension if not yet done
    //TODO: destinguish between different types of files

    if ((Controller::getInstance().getDataset(dataset_name))->isDirty())
    {
      std::cout << "Trying to write Datset" << std::endl;
      Controller::getInstance().writeDataset(dataset_name, "/written.hdr");
    }
    else
    {
      std::cout << "Dataset is not dirty, nothing to do" << std::endl;
    }
  }

  //--------------------------------------------------

  void MainWindow::openDatasetSaveSelectionDialog()
  {
    // TODO: some time, when more than only volume datasets
    // can be saved, implement the switching between the different
    // save types in here

    if(loaded_datasets_.size() == 1)
    {
      saveVolumeDatasetAs(loaded_datasets_.begin()->first);
    }
    else if(loaded_datasets_.size() > 1)
    {
      dataset_key_container_type dataset_keys;
      std::map<dataset_key_type, dataset_type>::const_iterator iter =
          loaded_datasets_.begin();
      for ( ; iter != loaded_datasets_.end(); ++iter)
      {
        dataset_keys.push_back(iter->first);
      }
      
      ChooseDatasetsDialog choose_datasets_dialog(this, dataset_keys);
 
      if(choose_datasets_dialog.exec())
      {
        dataset_key_container_type datasets_to_save =
          choose_datasets_dialog.getDatasetsToSave();
        dataset_key_container_type::iterator dataset_name_iterator = datasets_to_save.begin();
        while(dataset_name_iterator != datasets_to_save.end())
        {
          saveVolumeDatasetAs(*dataset_name_iterator);
          ++dataset_name_iterator;
        }
      }
    }
  }

  //--------------------------------------------------

  void MainWindow::saveVolumeDatasetAs(dataset_key_type const& dataset_name)
  {
    QVariant previous_saving_path =
      (Settings::getInstance())->getValue("last_saving_path", "/");

    QFileDialog save_dialog(this);

    QString dialog_title = tr("Choose a path to Save ");
    dialog_title += dialog_title.fromStdString(dataset_name);

    QString saving_path = save_dialog.getSaveFileName(
        this,
        dialog_title,
        previous_saving_path.toString(),
        "Analyze Files (*.hdr)");


    if(!saving_path.isEmpty())
    {
      (Settings::getInstance())->setValue("last_saving_path", QVariant(saving_path));
      // TODO: Segfault if not .hdr file
      Controller::getInstance().writeDataset(dataset_name, saving_path.toStdString());
    }
  }

  //--------------------------------------------------

  void MainWindow::updateGuiInteractionMode()
  {

    if (sender() == standard_mode_action_)
    {
      Controller::getInstance().setGuiInteractionMode(STANDARD_MODE);
      return;
    }
    else if (sender() == zoom_in_mode_action_)
    {
      Controller::getInstance().setGuiInteractionMode(ZOOM_IN_MODE);
      return;
    }
    else if (sender() == zoom_out_mode_action_)
    {
      Controller::getInstance().setGuiInteractionMode(ZOOM_OUT_MODE);
      return;
    }
    else if (sender() == pan_mode_action_)
    {
      Controller::getInstance().setGuiInteractionMode(PAN_MODE);
      return;
    }
    else if (sender() == rotation_mode_action_)
    {
      Controller::getInstance().setGuiInteractionMode(ROTATION_MODE);
      return;
    }
    else if (sender() == region_of_interest_rectangle_mode_action_)
    {
      Controller::getInstance().setGuiInteractionMode(REGION_OF_INTEREST_RECTANGLE_MODE);
      return;
    }
    else if (sender() == region_of_interest_ellipse_mode_action_)
    {
      Controller::getInstance().setGuiInteractionMode(REGION_OF_INTEREST_ELLIPSE_MODE);
      return;
    }
    else if (sender() == region_of_interest_poly_line_mode_action_)
    {
      Controller::getInstance().setGuiInteractionMode(REGION_OF_INTEREST_POLY_LINE_MODE);
      return;
    }
    else if (sender() == region_of_interest_freehand_mode_action_)
    {
      Controller::getInstance().setGuiInteractionMode(REGION_OF_INTEREST_FREEHAND_MODE);
      return;
    }
    else
    {
      // TODO: throw unknownModeException
    }
   
  }

  //--------------------------------------------------

  void MainWindow::openSettingsDialog()
  {
    if(settings_dialog_ == 0)
    {
      settings_dialog_ = new SettingsDialog(this);
    }
    settings_dialog_->show();
  }

  //--------------------------------------------------

  void MainWindow::openAboutDialog()
  {
    if(about_dialog_ == 0)
    {
      about_dialog_ = new AboutDialog(this);
    }
    about_dialog_->show();
  }

  // ---------------- private ------------------------

  //--------------------------------------------------

  void MainWindow::setupUI()
  {
    setWindowTitle(tr("iMEDgine"));
    setWindowState(Qt::WindowMaximized);

    SoQt::init(this);
    SoVolumeRendering::init();
    
    datasets_viewer_ = new DatasetsViewer();
    datasets_viewer_dock_widget_ = new QDockWidget(tr("Datasets Viewer"));
    datasets_viewer_dock_widget_->setWidget(datasets_viewer_);

    
    dataset_configuration_tab_widget_ =
        new DatasetConfigurationTabWidget();
    dataset_configuration_editor_dock_widget_ =
        new QDockWidget(tr("Dataset Configuration"));
    dataset_configuration_editor_dock_widget_->setWidget(dataset_configuration_tab_widget_);
    
    addDockWidget(Qt::LeftDockWidgetArea, datasets_viewer_dock_widget_);
    addDockWidget(Qt::LeftDockWidgetArea, dataset_configuration_editor_dock_widget_);
    
    tab_organizer_ = new TabOrganizer(this);
    setCentralWidget(tab_organizer_);
    createActions();
    createMenus();
    createToolBars();
    createStatusBar();
    
    algorithm_name_container_type loaded_algorithms =
        Controller::getInstance().getLoadedAlgorithmNames();
    
    if(loaded_algorithms.size() == 0)
    {
      //QMessageBox::information(this, tr("Warning"),
      //                         tr("No algorithms found. Please check your config file"));
      //std::cout << "No algorithms found" << std::endl;
    }
    else
    {
      algorithm_config_dock_widget_ = new QDockWidget(tr("Algorithms"));
      algo_widget_ = new AlgorithmWidget(loaded_algorithms);
      algorithm_config_dock_widget_->setWidget(algo_widget_);
      addDockWidget(Qt::RightDockWidgetArea, algorithm_config_dock_widget_);
      toolbox_menu_->addAction(
          algorithm_config_dock_widget_->toggleViewAction());
    }
    initializeConnections();
  }

  //--------------------------------------------------

  void MainWindow::createActions()
  {
    load_dataset_action_ = new QAction(QIcon(":icons/document-open.png"),
      tr("&Open"), this);
    save_dataset_action_ = new QAction(QIcon(":icons/document-save.png"),
      tr("&Save"), this);
    save_as_dataset_action_ = new QAction(QIcon(":icons/document-save-as.png"),
      tr("S&ave as"), this);
    new_tab_action_ = new QAction(QIcon(":icons/tab-new.png"),
      tr("&New Tab"), this);

    for (int counter = 0; counter < max_recent_files; ++counter)
    {
      recent_file_actions_[counter] = new QAction(this);
      recent_file_actions_[counter]->setVisible(false);
      connect(recent_file_actions_[counter], SIGNAL(triggered()),
              this, SLOT(openRecentFile()));
    }

    // TODO: bad icon
    quit_action_ = new QAction(QIcon(":icons/document-close.png"), tr("&Quit"), this);


   configure_imedgine_action_ = new QAction(QIcon(":icons/preferences-imedgine.png"),
      tr("&Configure iMEDgine"), this);

    toggle_datasets_viewer_action_ = datasets_viewer_dock_widget_->toggleViewAction();

    toggle_dataset_configuration_editor_action_ =
      dataset_configuration_editor_dock_widget_->toggleViewAction();

    about_action_ = new QAction(tr("&About"), this);

    // -----------    Toolbar Actions   --------
    // TODO: bad icon
    standard_mode_action_ = new QAction(QIcon(":icons/process-stop.png"), tr("Select"), this);
    // TODO: bad icon
    zoom_in_mode_action_ = new QAction(QIcon(":icons/page-magnifier"), tr("Zoom In"), this);
    // TODO: bad icon
    zoom_out_mode_action_ = new QAction(QIcon(":icons/page-magnifier"), tr("Zoom Out"), this);
    pan_mode_action_ = new QAction(QIcon(":icons/transform-move.png"), tr("Pan"), this);
    // TODO: bad icon
    rotation_mode_action_ = new QAction(QIcon(":icons/view-refresh.png"), tr("Rotate"), this);
    region_of_interest_rectangle_mode_action_ =
      new QAction(QIcon(":icons/draw-rectangle.png"), tr("Draw Rectangle"), this);
    region_of_interest_ellipse_mode_action_ =
      new QAction(QIcon(":icons/draw-ellipse.png"), tr("Draw Ellipse"), this);
    region_of_interest_poly_line_mode_action_ =
      new QAction(QIcon(":icons/draw-polyline.png"), tr("Draw Polyline"), this);
    region_of_interest_freehand_mode_action_ =
      new QAction(QIcon(":icons/draw-freehand.png"), tr("Draw Freehand"), this);

    toggleDatasetDependendActionStatus(false);
  }

  //--------------------------------------------------

  void MainWindow::createMenus()
  {
    file_menu_ = menuBar()->addMenu(tr("&File"));
    file_menu_->addAction(load_dataset_action_);
    file_menu_->addAction(save_dataset_action_);
    file_menu_->addAction(save_as_dataset_action_);
    file_menu_->addAction(new_tab_action_);
    separator_action_ = file_menu_->addSeparator();

    for (int counter = 0; counter < max_recent_files; ++counter)
      file_menu_->addAction(recent_file_actions_[counter]);

    file_menu_->addSeparator();
    file_menu_->addAction(quit_action_);

    menuBar()->addSeparator();
    
    view_menu_ = menuBar()->addMenu(tr("&View"));
    toolbox_menu_ = view_menu_->addMenu(tr("&Toolboxes"));
    toolbox_menu_->addAction(toggle_datasets_viewer_action_);
    toolbox_menu_->addAction(toggle_dataset_configuration_editor_action_);

    settings_menu_ = menuBar()->addMenu(tr("&Settings"));
    settings_menu_->addAction(configure_imedgine_action_);

    help_menu_ = menuBar()->addMenu(tr("&Help"));
    help_menu_->addAction(about_action_);
  }

  //--------------------------------------------------

  void MainWindow::createToolBars()
  {
    QToolBar* main_tool_bar_ = addToolBar(tr("File"));
    main_tool_bar_->addAction(load_dataset_action_);
    main_tool_bar_->addAction(save_dataset_action_);
    main_tool_bar_->addAction(save_as_dataset_action_);
    main_tool_bar_->addSeparator();
    main_tool_bar_->addAction(new_tab_action_);


    addToolBar(Qt::TopToolBarArea, main_tool_bar_);

    QToolBar* mode_tool_bar_ = addToolBar(tr("Modes"));
    mode_tool_bar_->addAction(standard_mode_action_);
    mode_tool_bar_->addSeparator();
    mode_tool_bar_->addAction(zoom_in_mode_action_);
    mode_tool_bar_->addAction(zoom_out_mode_action_);
    mode_tool_bar_->addSeparator();
    mode_tool_bar_->addAction(pan_mode_action_);
    mode_tool_bar_->addAction(rotation_mode_action_);
    mode_tool_bar_->addSeparator();
    mode_tool_bar_->addAction(region_of_interest_rectangle_mode_action_);
    mode_tool_bar_->addAction(region_of_interest_ellipse_mode_action_);
    mode_tool_bar_->addAction(region_of_interest_poly_line_mode_action_);
    mode_tool_bar_->addAction(region_of_interest_freehand_mode_action_);
    addToolBar(Qt::TopToolBarArea, mode_tool_bar_);
  }

  //--------------------------------------------------

  void MainWindow::createStatusBar()
  {
    statusBar()->showMessage(tr("Ready"));
  }

  //--------------------------------------------------

  void MainWindow::initializeConnections()
  {
    connect(load_dataset_action_, SIGNAL(triggered()),
            this, SLOT(openFileFromDialog()));
    // TODO: Check for dirty bit, connect to other slot, check for filename
    connect(save_dataset_action_, SIGNAL(triggered()),
            this, SLOT(checkForDirtyToSave()));
    connect(save_as_dataset_action_, SIGNAL(triggered()),
            this, SLOT(openDatasetSaveSelectionDialog()));
    // TODO: don't call close directly, check first for unsaved data
    connect(quit_action_, SIGNAL(triggered()),
            this, SLOT(close()));

    connect(new_tab_action_, SIGNAL(triggered()),
            this, SLOT(newTabSlot()));
    connect(datasets_viewer_, SIGNAL(datasetDoubleClicked(dataset_key_type const&)),
            this, SLOT(openOverview(dataset_key_type const&)));
    connect(configure_imedgine_action_, SIGNAL(triggered()),
            this, SLOT(openSettingsDialog()));
    connect(about_action_, SIGNAL(triggered()),
            this, SLOT(openAboutDialog()));

    connect(datasets_viewer_, SIGNAL(closeDatasetSignal(dataset_key_type const&)),
            this, SLOT(closeDataset(dataset_key_type const&)));
    connect(this, SIGNAL(closeDatasetSignal(dataset_key_type const&)),
            tab_organizer_, SLOT(closeTab(dataset_key_type const&)));
    connect(algo_widget_, SIGNAL(notifyNewDatasetGeneration(
              std::vector<std::pair<dataset_key_type, dataset_type> > const&)),
            this, SLOT(newDatasetsAdded(
              std::vector<std::pair<dataset_key_type, dataset_type> > const&)));

    connect(datasets_viewer_, SIGNAL(saveDatasetSignal(dataset_key_type const&)),
            this, SLOT(saveSpecificVolumeDataset(dataset_key_type const&)));
    connect(datasets_viewer_, SIGNAL(saveAsDatasetSignal(dataset_key_type const&)),
            this, SLOT(saveDatasetVolumeAs(dataset_key_type const&)));

    // Dataset Configuration
    /*connect(this, SIGNAL(newDatasetLoaded(dataset_key_type const&)),
            algo_widget_,
            SLOT(datasetChanged(dataset_key_type const&)));*/
    connect(this, SIGNAL(newDatasetLoaded(dataset_key_type const&)),
            dataset_configuration_tab_widget_,
            SLOT(addDatasetConfigurationTab(dataset_key_type const&)));
    connect(algo_widget_, SIGNAL(notifyNewDatasetGeneration(
              std::vector<std::pair<dataset_key_type, dataset_type> > const&)),
            dataset_configuration_tab_widget_, SLOT(addDatasetConfigurationTabs(
              std::vector<std::pair<dataset_key_type, dataset_type> > const&)));
    connect(this, SIGNAL(closeDatasetSignal(dataset_key_type const&)),
            dataset_configuration_tab_widget_,
            SLOT(removeDatasetConfigurationTab(dataset_key_type const&)));
    connect(this, SIGNAL(datasetClosedSignal(dataset_key_type const&)),
            algo_widget_,
            SLOT(datasetChanged(dataset_key_type const&)));

    // Mode Connections
    connect(standard_mode_action_, SIGNAL(triggered()),
            this, SLOT(updateGuiInteractionMode()));
    connect(zoom_in_mode_action_, SIGNAL(triggered()),
            this, SLOT(updateGuiInteractionMode()));
    connect(zoom_out_mode_action_, SIGNAL(triggered()),
            this, SLOT(updateGuiInteractionMode()));
    connect(pan_mode_action_, SIGNAL(triggered()),
            this, SLOT(updateGuiInteractionMode()));
    connect(rotation_mode_action_, SIGNAL(triggered()),
            this, SLOT(updateGuiInteractionMode()));
    connect(region_of_interest_rectangle_mode_action_, SIGNAL(triggered()),
            this, SLOT(updateGuiInteractionMode()));
    connect(region_of_interest_ellipse_mode_action_, SIGNAL(triggered()),
            this, SLOT(updateGuiInteractionMode()));
    connect(region_of_interest_poly_line_mode_action_, SIGNAL(triggered()),
            this, SLOT(updateGuiInteractionMode()));
    connect(region_of_interest_freehand_mode_action_, SIGNAL(triggered()),
            this, SLOT(updateGuiInteractionMode()));

  }

  //--------------------------------------------------

  void MainWindow::loadDataset(const QString& file_path)
  {
    std::pair<dataset_key_type, dataset_type> dataset_key_and_type;
    try
    {
      dataset_key_and_type =
          Controller::getInstance().loadDataset(file_path.toStdString());
    }
    catch(FormatNotSupportedException &exc)
    {
      QMessageBox::information(this, tr("Warning"),
                               tr("The filetype is not recognized by the\
                                   application!"));
      return;
    }

    loaded_datasets_.insert(dataset_key_and_type);

    datasets_viewer_->addDataset(dataset_key_and_type.first);
    
    algo_widget_->datasetChanged(dataset_key_and_type.first);
    
    this->openOverview(dataset_key_and_type.first, dataset_key_and_type.second);

    updateRecentFileList(file_path);

    std::cout << "Loaded Datasets Size: " << loaded_datasets_.size() << std::endl;

    if(loaded_datasets_.size() == 1)
    {
      toggleDatasetDependendActionStatus(true);
    }
    emit newDatasetLoaded(dataset_key_and_type.first);
  }

  //--------------------------------------------------
  // TODO: change order of the recent files when opened again
  void MainWindow::updateRecentFileList(const QString& file_path)
  {
    QVariant recent_file_setting = (Settings::getInstance())->getValue("recentFileList");
    
    if(!recent_file_setting.isValid())
    {
      QStringList list_of_files;
      list_of_files << file_path;
      (Settings::getInstance())->setValue("recentFileList", QVariant(list_of_files));
    }
    else
    {
      QStringList string_list = recent_file_setting.toStringList();
      bool already_in_recently_used_files = false;
      
      QStringList::const_iterator iterator;
      for (iterator = string_list.constBegin(); iterator != string_list.constEnd();
           ++iterator)
      {
        //std::cout << (*iterator).toStdString() << std::endl;
        if( *iterator == file_path)
        {
          //std::cout << "ALREADY in RECENTLY" << std::endl;
          already_in_recently_used_files = true;
        }
      }
      
      if(!already_in_recently_used_files)
      {
        if(string_list.size() == 5)
        {
          string_list.removeAt(0);
        }
        string_list << file_path;
        (Settings::getInstance())->setValue("recentFileList", QVariant(string_list));
      }
    }
    updateRecentFileActions();
  }

  //--------------------------------------------------

  void MainWindow::updateRecentFileActions()
  {
    QStringList files = (Settings::getInstance())->getValue("recentFileList").toStringList();

    int num_recent_files = qMin(files.size(), (int)max_recent_files);

    for (int i = 0; i < num_recent_files; ++i) {
      QString text = tr("&%1 %2").arg(i + 1).arg(strippedName(files[i]));
      recent_file_actions_[i]->setText(text);
      recent_file_actions_[i]->setData(files[i]);
      recent_file_actions_[i]->setVisible(true);
    }
    for (int j = num_recent_files; j < max_recent_files; ++j)
      recent_file_actions_[j]->setVisible(false);

    separator_action_->setVisible(num_recent_files > 0);
  }

  //--------------------------------------------------

  QString MainWindow::strippedName(const QString& full_file_name)
  {
    return QFileInfo(full_file_name).fileName();
  }

  //--------------------------------------------------

  void MainWindow::toggleDatasetDependendActionStatus(bool enable)
  {
      new_tab_action_->setEnabled(enable);
      save_dataset_action_->setEnabled(enable);
      save_as_dataset_action_->setEnabled(enable);
      standard_mode_action_->setEnabled(enable);
      zoom_in_mode_action_->setEnabled(enable);
      zoom_out_mode_action_->setEnabled(enable);
      pan_mode_action_->setEnabled(enable);
      rotation_mode_action_->setEnabled(enable);
      region_of_interest_rectangle_mode_action_->setEnabled(enable);
      region_of_interest_ellipse_mode_action_->setEnabled(enable);
      region_of_interest_poly_line_mode_action_->setEnabled(enable);
      region_of_interest_freehand_mode_action_->setEnabled(enable);
  }
}

---