application.cpp

开源的电子海图程序

                "<menu action='ChartsMenu'>"
                  "<menuitem action='" + chart->description + "'/>"
                "</menu>"
            "</menubar>"
        "</ui>";

    Gtk::UIManager::ui_merge_id id =
                ui_manager->add_ui_from_string(ui_info);
    chart_to_merge_id[chart] = id;

    drawing_configuration.SetSensitive(chart);

    return chart; 
}

/**
 * Close a chart
 * @param chart Chart to close
 */
void Application::CloseChart(Chart *chart)
{
    // remove the chart from the charts menu
    ui_manager->remove_ui(chart_to_merge_id[chart]); 
    chart_to_merge_id.erase(chart);

    // unload chart from any renderers it is present in
    renderer_book.CloseChart(chart);

    // remove the pointer from our charts vector
    std::vector<Chart *>::iterator chit; 
    std::vector<Chart *>::iterator end(charts.end()); 
    for (chit = charts.begin(); chit != end; ++chit) {
        if (*chit == chart) {
            charts.erase(chit);
            break;
        }
    }

    delete chart;
}

/**
 * Close the chart in the current renderer
 */
void Application::CloseCurrentChart()
{
    Gtk::Notebook_Helpers::PageList::iterator it;
    it = renderer_book.get_current();

    if (!it)
        return;

    Chart *chart =
        dynamic_cast<GLChartRenderer *>(it->get_child())->GetChart();

    CloseChart(chart);
}

/**
 * Remove the current renderer
 */
void Application::RemoveRenderer()
{
    int n = renderer_book.get_n_pages(); 

    if (n == 1) {
        std::cerr << "Cowardly refusing to remove sole tab" << std::endl;
        return;
    }

    Gtk::Notebook_Helpers::PageList::iterator it;
    it = renderer_book.get_current();

    if (!it)
        return;

    // FIXME memleak?
    renderer_book.remove_page(*(it->get_child()));
}

/**
 * Callback for when a chart is selected in the ENC browser
 */
void Application::SelectChart(boost::filesystem::path &filepath)
{
    // first find our chart
    Chart *chart = NULL;
    std::vector<Chart *>::iterator chit;
    std::vector<Chart *>::iterator end(charts.end());
    for (chit = charts.begin(); chit != end; ++chit) {
        if ((*chit)->filepath.string() == filepath.string()) {
            chart = *chit;
            break;
        }
    }

    if (chart) {
        Gtk::Notebook_Helpers::PageList::iterator it =
                                      renderer_book.get_current();
        renderer_book.LoadChart(chart, it);
    }
    drawing_configuration.SetSensitive(chart);
}


/**
 * ZoomFit callback
 */
void Application::ZoomFit()
{
    Gtk::Notebook_Helpers::PageList::iterator it;
    it = renderer_book.get_current();
    if (!it)
        return;
    GLChartRenderer *renderer =
                    dynamic_cast<GLChartRenderer *>(it->get_child());
    if (!renderer)
        return;
    renderer->ZoomFit();
}


/**
 * Display the renderer configuration window
 */
void Application::GetRendererConfiguration()
{
    Gtk::Notebook_Helpers::PageList::iterator it;
    it = renderer_book.get_current();

    if (!it) {
        Gtk::MessageDialog dialog(*this, "No renderer found");
        dialog.run();
        return;
    }

    renderer_book.GetRendererConfiguration(it);
}

/**
 * Display the about window
 */
void Application::About()
{
    std::string str = APPNAME;
    str += " Copyright 2005 Jon Michaelchuck [e-mail]\n";
    str += "Licensed under the GPL http://www.gnu.org/copyleft/gpl.html";
    Gtk::MessageDialog dialog(*this, str);
    dialog.run();
}

/**
 * Close
 */
void Application::Quit()
{
    hide();
}

//
// interface creation
//

/**
 * Create the top of the UI
 */
void Application::CreateTopUI()
{
    action_group = Gtk::ActionGroup::create();

    action_group->add(Gtk::Action::create("FileMenu", "File"));

    action_group->add(Gtk::Action::create("FileBrowseCatalog", Gtk::Stock::OPEN,
                "Browse Catalog"),
                sigc::mem_fun(*this, &Application::BrowseCatalog));

    action_group->add(Gtk::Action::create("FileCloseChart", Gtk::Stock::CLOSE,
                "Close Current Chart"), Gtk::AccelKey("<control>X"),
                sigc::mem_fun(*this, &Application::CloseCurrentChart));

    action_group->add(Gtk::Action::create("FileNewRenderer", Gtk::Stock::NEW,
                "New Tab"), Gtk::AccelKey("<control>T"),
                sigc::mem_fun(*this, &Application::AddRenderer));

    action_group->add(Gtk::Action::create("FileCloseRenderer",
                Gtk::Stock::CLOSE, "Close Tab"),
                sigc::mem_fun(*this, &Application::RemoveRenderer));

    action_group->add(Gtk::Action::create("FileQuit", Gtk::Stock::QUIT),
                sigc::mem_fun(*this, &Application::Quit));

    action_group->add(Gtk::Action::create("ChartsMenu", "Charts"));

    action_group->add(Gtk::Action::create("ConfigurationMenu",
                                          "Configuration"));

    action_group->add(Gtk::Action::create("HelpMenu", "Help"));

    action_group->add(Gtk::Action::create("About", "About"),
                sigc::mem_fun(*this, &Application::About));

    action_group->add(Gtk::Action::create("RendererConfiguration",
                                          "Renderer Configuration"),
                sigc::mem_fun(*this, &Application::GetRendererConfiguration));

    action_group->add(Gtk::Action::create("DrawnChecklist",
                                          "Drawing Configuration"),
                                          sigc::mem_fun(drawing_configuration,
                                          &DrawingConfiguration::show_all));

    action_group->add(Gtk::Action::create("ZoomFit",
                                            Gtk::Stock::ZOOM_FIT),
                sigc::mem_fun(*this, &Application::ZoomFit));

    Gtk::RadioAction::Group input_modes;
    action_group->add(Gtk::RadioAction::create(input_modes, "Pan",
                        "Pan"), sigc::bind<input_mode_e>(sigc::mem_fun(*this,
                        &Application::SetInputMode), PAN_MODE));
    action_group->add(Gtk::RadioAction::create(input_modes, "ZoomIn",
                        Gtk::Stock::ZOOM_IN),
                        sigc::bind<input_mode_e>(sigc::mem_fun(*this,
                        &Application::SetInputMode), ZOOM_IN_MODE));
    action_group->add(Gtk::RadioAction::create(input_modes, "ZoomOut",
                        Gtk::Stock::ZOOM_OUT),
                         sigc::bind<input_mode_e>(sigc::mem_fun(*this,
                        &Application::SetInputMode), ZOOM_OUT_MODE));
    action_group->add(Gtk::RadioAction::create(input_modes, "AddWaypoints",
                        "Add Waypoints"),
                        sigc::bind<input_mode_e>(sigc::mem_fun(*this,
                        &Application::SetInputMode), WAYPOINT_INSERT_MODE));

    ui_manager = Gtk::UIManager::create();
    ui_manager->insert_action_group(action_group);
     
    add_accel_group(ui_manager->get_accel_group());

    Glib::ustring ui_info =
        "<ui>"
            "<menubar name='MenuBar'>"
                "<menu action='FileMenu'>"
                  "<menuitem action='FileBrowseCatalog'/>"
                  "<separator/>"
                  "<menuitem action='FileNewRenderer'/>"
                  "<menuitem action='FileCloseRenderer'/>"
                  "<separator/>"
                  "<menuitem action='FileQuit'/>"
                "</menu>"
                "<menu action='ChartsMenu'>"
                  "<menuitem action='FileCloseChart'/>"
                  "<separator/>"
                "</menu>"
                "<menu action='ConfigurationMenu'>"
                  "<menuitem action='RendererConfiguration'/>"
                  "<menuitem action='DrawnChecklist'/>"
                "</menu>"
                "<menu action='HelpMenu'>"
                  "<menuitem action='About'/>"
                "</menu>"
            "</menubar>"
            "<toolbar name='ToolBar'>"
                  "<toolitem action='Pan'/>"
                  "<toolitem action='ZoomIn'/>"
                  "<toolitem action='ZoomOut'/>"
                  "<toolitem action='ZoomFit'/>"
                  "<toolitem action='AddWaypoints'/>"
            "</toolbar>"
        "</ui>";

    ui_manager->add_ui_from_string(ui_info);

    menubar = ui_manager->get_widget("/MenuBar");
    toolbar = ui_manager->get_widget("/ToolBar");
}

/**
 * Create the bottom of the ui
 */
void Application::CreateBottomUI()
{
    Gtk::HBox *lat_box = manage(new Gtk::HBox());
    Gtk::HBox *long_box = manage(new Gtk::HBox());
    Gtk::VBox *longlat_vbox = manage(new Gtk::VBox());

    Gtk::Label *lat_label_label = manage(new Gtk::Label("Latitude:   "));
    lat_label.set_text(GetFormattedLongLatString(0));
    lat_box->add(*lat_label_label);
    lat_box->add(lat_label);

    Gtk::Label *long_label_label = manage(new Gtk::Label("Longitude: "));
    long_label.set_text(GetFormattedLongLatString(0));
    long_box->add(*long_label_label);
    long_box->pack_start(long_label);

    longlat_vbox->pack_start(*lat_box, Gtk::PACK_SHRINK);
    longlat_vbox->pack_start(*long_box, Gtk::PACK_SHRINK);

    Gtk::Frame *longlat_frame = manage(new Gtk::Frame());
    longlat_frame->add(*longlat_vbox);
    longlat_frame->set_label("Cursor Position");

    longlat_preview_vbox.pack_end(*longlat_frame, Gtk::PACK_SHRINK);

    bottom_hbox.pack_start(longlat_preview_vbox, Gtk::PACK_SHRINK);

    Gtk::Notebook *notebook = manage(new Gtk::Notebook());
    notebook->append_page(waypoint_list, "Waypoints");

    bottom_hbox.add(*notebook);
}

//
// custom signal handlers
// 

/**
 * update longitide/latitude labels signal handler
 */
void Application::on_pointer_longlat_updated(double x, double y)
{
    std::string str;

    str = GetFormattedLongLatString(x);
    lat_label.set_text(str);

    str = GetFormattedLongLatString(y);
    long_label.set_text(str);
}

/**
 * Add waypoint signal handler
 */
void Application::on_add_waypoint(waypoint_t *waypoint)
{
    waypoint_list.AddWaypoint(*waypoint);
}