/homes/esi30/DCS339/coursework/src/main_window.cpp

Go to the documentation of this file.

#include <string>
#include <vector>

#include <glibmm/refptr.h>
#include <glibmm/ustring.h>
#include <gtkmm/aboutdialog.h>
#include <gtkmm/action.h>
#include <gtkmm/actiongroup.h>
#include <gtkmm/enums.h>
#include <gtkmm/filechooserdialog.h>
#include <gtkmm/filefilter.h>
#include <gtkmm/messagedialog.h>
#include <gtkmm/stock.h>
#include <gtkmm/uimanager.h>

#include "catalogue.hpp"
#include "main_window.hpp"
#include "utils.hpp"

Main_window::Main_window(): parent_table(2, 2) {
    set_title("Egami");
    add(parent_table);
    set_resizable();
    init_menu();

    parent_table.attach(*menu, 0, 2, 0, 1, Gtk::FILL, static_cast<Gtk::AttachOptions>(0));
    parent_table.attach(display_catalogue, 0, 1, 1, 2);
    parent_table.attach(processing_catalogue, 1, 2, 1, 2, static_cast<Gtk::AttachOptions>(0));

    show_all_children();
}

void Main_window::init_menu(){
    struct Leaf{ const std::string id; const Gtk::StockID ic; const std::string txt, info; void (Main_window::*fn)(); };

    menu_action_group = Gtk::ActionGroup::create();
    menu_action_group->add(Gtk::Action::create("FileMenu", "File"));
    menu_action_group->add(Gtk::Action::create("EditMenu", "Edit"));
    menu_action_group->add(Gtk::Action::create("HelpMenu", "Help"));

    std::vector<Leaf> menu_leafs{
        { "Open",               Gtk::Stock::OPEN,    "_Open",               "Open a new file",                  &Main_window::on_open },
        { "Save",               Gtk::Stock::SAVE,    "_Save",               "Save",                             &Main_window::on_save },
        { "Save As",            Gtk::Stock::SAVE_AS, "Save As...",          "Save as new file",                 &Main_window::on_save_as },
        { "Quit",               Gtk::Stock::QUIT,    "_Quit",               "Quit egami",                       &Main_window::on_quit },
        { "Undo",               Gtk::Stock::UNDO,    "_Undo",               "Undo previous action",             &Main_window::on_undo },
        { "Redo",               Gtk::Stock::REDO,    "_Redo",               "Redo previous undo",               &Main_window::on_redo },
        { "About",              Gtk::Stock::ABOUT,   "_About",              "About this program",               &Main_window::on_about },
        { "Region of Interest", Gtk::Stock::HELP,    "_Region of Interest", "Help on ROI",                      &Main_window::on_roi },
    };

    Glib::ustring menu_shape = 
            "<ui>"
            "  <menubar name='MenuBar'>"
            "    <menu action='FileMenu'>"
            "      <menuitem action='Open'/>"
            "      <menuitem action='Save'/>"
            "      <menuitem action='Save As'/>"
            "      <menuitem action='Quit'/>"
            "    </menu>"
            "    <menu action='EditMenu'>"
            "      <menuitem action='Undo'/>"
            "      <menuitem action='Redo'/>"
            "    </menu>"
            "    <menu action='HelpMenu'>"
            "      <menuitem action='About'/>"
            "      <menuitem action='Region of Interest'/>"
            "    </menu>"
            "  </menubar>"
            "</ui>";

    // Generate leafs' Action.
    for(std::vector<Leaf>::iterator it=menu_leafs.begin(); it!=menu_leafs.end(); ++it){
        Glib::RefPtr<Gtk::Action> o=Gtk::Action::create(it->id, it->ic, it->txt, it->info);
        o->set_always_show_image();
        menu_action_group->add(o, sigc::mem_fun(*this, it->fn));
    }

    // Populate menu_ui_manager.
    menu_ui_manager = Gtk::UIManager::create();
    menu_ui_manager->insert_action_group(menu_action_group);
    add_accel_group(menu_ui_manager->get_accel_group());
    menu_ui_manager->add_ui_from_string(menu_shape);

    // Extract the menu.
    menu = menu_ui_manager->get_widget("/MenuBar");
}

void Main_window::on_open(){
    Gtk::FileChooserDialog dialog("Please choose a file", Gtk::FILE_CHOOSER_ACTION_OPEN);
    dialog.set_transient_for(*this);
    dialog.set_select_multiple();
    dialog.set_current_folder(cmake_install_prefix+std::string("/share/egami/Image Library"));
    dialog.add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
    dialog.add_button(Gtk::Stock::OPEN, Gtk::RESPONSE_OK);


    Glib::RefPtr<Gtk::FileFilter> filter_images = Gtk::FileFilter::create();
    filter_images->set_name("Image files");
    filter_images->add_mime_type("image/jpeg");
    filter_images->add_mime_type("image/png");
    filter_images->add_mime_type("image/bmp");
    filter_images->add_mime_type("image/tiff");
    dialog.add_filter(filter_images);

    Glib::RefPtr<Gtk::FileFilter> filter_any = Gtk::FileFilter::create();
    filter_any->set_name("Any files");
    filter_any->add_pattern("*");
    dialog.add_filter(filter_any);

    int result = dialog.run();

    std::vector<std::string> targetfilenames;
    switch(result){
        case(Gtk::RESPONSE_OK):
            targetfilenames = std::move(dialog.get_filenames());
            break;
        case(Gtk::RESPONSE_CANCEL):
            return;
    }

    for(std::vector<std::string>::iterator it=targetfilenames.begin(); it!=targetfilenames.end(); ++it)
        display_catalogue.open_image(*it);
}

void Main_window::on_save(){
    try{
        if(!display_catalogue.save())
            on_save_as();
    } catch(std::exception &e){
        Gtk::MessageDialog d(*this, e.what());
        d.run();
    }
}

void Main_window::on_save_as(){
    Gtk::FileChooserDialog dialog("Please choose a file", Gtk::FILE_CHOOSER_ACTION_SAVE);
    dialog.set_transient_for(*this);
    dialog.set_current_folder(cmake_install_prefix+std::string("/share/egami/Image Library"));
    dialog.add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
    dialog.add_button(Gtk::Stock::SAVE, Gtk::RESPONSE_OK);

    int result = dialog.run();

    switch(result){
        case(Gtk::RESPONSE_OK):
            try{
                display_catalogue.save_as(dialog.get_filename());
            } catch(std::exception &e){
                Gtk::MessageDialog d(*this, e.what());
                d.run();
            }
            break;
        case(Gtk::RESPONSE_CANCEL):
            return;
    }
}

void Main_window::on_quit(){
    hide();
}

void Main_window::on_undo(){
    display_catalogue.undo_current();
}

void Main_window::on_redo(){
    display_catalogue.redo_current();
}

void Main_window::on_about(){
    Gtk::AboutDialog d;
    d.set_program_name("Egami");
    d.set_version("Final");
    d.set_comments("For the DCS339: C++ for Image Processing course");
    d.set_authors(std::vector<Glib::ustring>{"Étienne Jean Lucien Simon"});
    d.run();
}

void Main_window::on_roi(){
    Gtk::Label text;
    text.set_markup("<big><b>Region of Interest</b></big>\n"
                    "\n"
                    "A region of interest is a subimage in an image. Like a normal image it must be rectangular.\n"
                    "When an image has a currently active ROI (region of interest), all processes apply to this region only.\n"
                    "Some processes are not avaible in ROI mode (e.g. Resizing, rotating). Moreover, copy has the special\n"
                    "semantic of slicing the image. That is, the copy process will \"cut out\" the ROI and it will open it in\n"
                    "another tab.\n"
                    "\n"
                    "In order to select a ROI: first click two times on the image (on two opposite angle of the sub image) then\n"
                    "click on the Select ROI process button (on the \"Tools\" tab). The ROI is persistant, in order to reselect\n"
                    "the image as a whole, you must click on the Unselect ROI process button (also on \"Tools\").\n"
                    "\n"
                    "Note that when a binary operation is effectued on an image in ROI mode, only the ROI portion is affected/used.\n");
    Gtk::Dialog d;
    d.set_resizable(false);
    d.get_vbox()->pack_start(text);
    d.add_button(Gtk::Stock::OK, Gtk::RESPONSE_OK);
    d.show_all_children();
    d.run();
}