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

Go to the documentation of this file.

#include <algorithm>
#include <memory>
#include <string>

#include "catalogue.hpp"
#include "display_page.hpp"
#include "display_unit.hpp"
#include "processing_page.hpp"

#include <gtkmm/enums.h>
#include <gtkmm/messagedialog.h>

Display_catalogue *Display_catalogue::instance;

Display_catalogue::Display_catalogue(){
    instance=this;
}

void Display_catalogue::open_image(const std::string &filepath){
    std::string::const_iterator lastslash=std::find(filepath.rbegin(), filepath.rend(), '/').base();
    std::string::const_iterator lastdot=std::find(filepath.rbegin(), filepath.rend(), '.').base();
    std::string filename(lastslash, lastdot-1);

    std::shared_ptr<Display_page_header> dph(new Display_page_header(filename));
    std::shared_ptr<Image_unit> unit(new Image_unit(filepath));
    std::shared_ptr<Display_page> dp(new Display_page(unit));
    unit->set_page(dp.get());
    dph->assign(this, append(dph, dp));
    set_tab_reorderable(*dp);
}

void Display_catalogue::undo_current(){
    std::shared_ptr<Display_page> current=current_page();
    if(!current){
        Gtk::MessageDialog dialog("No image loaded", false, Gtk::MESSAGE_ERROR);
        dialog.run();
        return;
    }
    current->undo();
}

void Display_catalogue::redo_current(){
    std::shared_ptr<Display_page> current=current_page();
    if(!current){
        Gtk::MessageDialog dialog("No image loaded", false, Gtk::MESSAGE_ERROR);
        dialog.run();
        return;
    }
    current->redo();
}

void Display_catalogue::add_page(const std::string &title, Display_unit *unit){
    std::shared_ptr<Display_page_header> dph(new Display_page_header(title));
    Display_page *rdp;

    if(Image_unit *iu=dynamic_cast<Image_unit*>(unit))
        rdp=new Display_page((std::shared_ptr<Image_unit>(iu)));
    else if(Info_unit *iu=dynamic_cast<Info_unit*>(unit))
        rdp=new Display_page((std::shared_ptr<Info_unit>(iu)));

    dph->assign(instance, instance->append(dph, std::shared_ptr<Display_page>(rdp)));
    instance->set_tab_reorderable(*rdp);
}

std::shared_ptr<Display_page> Display_catalogue::current_page(){
    // Tricky, the return value of get_nth_page is not used in case the object is destroyed after the return of this function.
    // By using the shared_ptr of pages, even if the page is closed, the Display_page will survive until it's no more used.
    int cp=instance->get_current_page();
    if(cp==-1)
        return std::shared_ptr<Display_page>(nullptr);
    return instance->pages[dynamic_cast<Display_page_header*>(instance->get_tab_label(*instance->get_nth_page(cp)))->id].second;
}

std::vector<std::shared_ptr<Display_unit>> Display_catalogue::all_units(){
    std::vector<std::shared_ptr<Display_unit>> r;
    r.reserve(instance->pages.size());
    for(auto e: instance->pages)
        r.push_back(e.second.second->display_unit);
    return r;
}

bool Display_catalogue::save(){
    std::shared_ptr<Display_page> current=current_page();
    if(!current)
        return false;
    return current->save();
}

void Display_catalogue::save_as(const std::string &fp){
    std::shared_ptr<Display_page> current=current_page();
    if(!current){
        Gtk::MessageDialog dialog("No image loaded", false, Gtk::MESSAGE_ERROR);
        dialog.run();
        return;
    }
    current->save_as(fp);
}

Processing_catalogue::Processing_catalogue(){
    set_tab_pos(Gtk::POS_LEFT);
    create_processing_group<Processing_page>("Colours");
    create_processing_group<Processing_page>("Edge detection");
    create_processing_group<Processing_page>("Convolutions");
    create_processing_group<Processing_page>("Order statistic");
    create_processing_group<Processing_page>("Threshold");
    create_processing_group<Processing_page>("Reshape");
    create_processing_group<Processing_page>("Binary Op.");
    create_processing_group<Processing_page>("Tools");
}