rendererbook.cpp

开源的电子海图程序

/* GHelm - Nautical Navigation Software
 * Copyright (C) 2004 Jon Michaelchuck
 *
 * This application is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License version 2
 * as published by the Free Software Foundation.
 *
 * This software is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public
 * License along with this software; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA.
 */

#include "rendererbook.h"
#include "util.h"

/**
 * Constructor
 */
RendererBook::RendererBook() :
    Gtk::GL::Widget(static_cast<Gtk::Widget&>(*this)),
    glconfig(NULL), shared_context(NULL),
    configuration(NULL)
{
}

/**
 * Destructor
 */
RendererBook::~RendererBook()
{
    pages().clear();
    // FIXME delete our renderers
}

/** Init
 * initialize renderer
 * @param conf Configuration pointer
 * @return 0 on success, -1 on failure
 */
int RendererBook::Init(Configuration *conf)
{
    configuration = conf;

    // try to get a double buffered display
    glconfig = Gdk::GL::Config::create(Gdk::GL::MODE_RGB    |
                                       Gdk::GL::MODE_DEPTH  |
                                       Gdk::GL::MODE_DOUBLE);

    // if we can't get double buffered try single.
    if (!glconfig) {
      glconfig = Gdk::GL::Config::create(Gdk::GL::MODE_RGB   |
                                         Gdk::GL::MODE_DEPTH);
        if (!glconfig) {
            std::cerr << "RendererBook::Init(): couldn't get glconfig"
                      << std::endl;
            return -1;
        }
    }

    // Add first renderer and use its context as the list sharing one.
    GLChartRenderer *cr = new GLChartRenderer(glconfig);
    if (cr->Init(configuration) < 0) {
        std::cerr << "RendererBook::Init(): Error intializing first renderer"
                  << std::endl;
        return -1;
    }
    cr->signal_add_waypoint.connect(sigc::mem_fun(signal_add_waypoint,
                            &sigc::signal<void, waypoint_t *>::emit));
    cr->signal_pointer_longlat_updated.connect(sigc::mem_fun(
                            signal_pointer_longlat_updated,
                            &sigc::signal<void, double, double>::emit));
    cr->signal_set_view_rect.connect(sigc::mem_fun(signal_set_view_rect,
                            &sigc::signal<void, double,double,
                                          double, double>::emit));

    append_page(*cr, "No Chart");

    cr->show();

    shared_context = cr->GetContext();
    if (!shared_context) {
        std::cerr << "RendererBook::Init(): Error getting shared context"
                  << std::endl;
        return -1;
    }

    return 0;
}

/**
 * Set input mode
 * @param mode Mode to set
 */
void RendererBook::SetInputMode(input_mode_e mode)
{
    Gtk::Notebook_Helpers::PageList::iterator it;
    Gtk::Notebook_Helpers::PageList::iterator end = pages().end();

    for (it = pages().begin(); it != end; ++it) {
        dynamic_cast<GLChartRenderer *>(it->get_child())->SetInputMode(mode);
    }
}

//
// chart manipulation
//

/**
 * Load a chart into the current renderer
 * @param chart Chart to load
 * @return 0 on success -1 on failure
 */
int RendererBook::LoadChart(Chart *chart,
                               Gtk::Notebook_Helpers::PageList::iterator &it)
{
    GLChartRenderer *renderer =
                            dynamic_cast<GLChartRenderer *>(it->get_child());
    renderer->SetChart(chart);
    // set the tab name
    set_tab_label_text(*renderer, chart->description);

    signal_load_chart.emit(chart);

    return 0;
}

/**
 * Unload a chart if it is present in any renderer
 * @param chart Chart to unload
 */
void RendererBook::CloseChart(Chart *chart)
{
    Gtk::Notebook_Helpers::PageList::iterator it;
    Gtk::Notebook_Helpers::PageList::iterator end = pages().end();

    for (it = pages().begin(); it != end; ++it) {
        GLChartRenderer *chart_renderer =
                        dynamic_cast<GLChartRenderer *>(it->get_child());
        if (chart_renderer->GetChart() == chart) {
            chart_renderer->UnloadChart();
            set_tab_label_text(*chart_renderer, "No Chart");

            signal_unload_chart.emit();
        }
    }
}

//
// renderer manipulation
//

/** 
 * Add a renderer
 */
void RendererBook::AddRenderer()
{
    //FIXME errcheck
    GLChartRenderer *cr = new GLChartRenderer(glconfig, shared_context);
    cr->Init(configuration);

    cr->signal_add_waypoint.connect(sigc::mem_fun(signal_add_waypoint,
                            &sigc::signal<void, waypoint_t *>::emit));
    cr->signal_pointer_longlat_updated.connect(sigc::mem_fun(
                            signal_pointer_longlat_updated,
                            &sigc::signal<void, double, double>::emit));
    cr->signal_set_view_rect.connect(sigc::mem_fun(signal_set_view_rect,
                            &sigc::signal<void, double,double,
                                          double, double>::emit));

    append_page(*cr, "No Chart");

    cr->show();
}

//
// renderer info
//

/**
 * Display the renderer configuration window
 */
void RendererBook::GetRendererConfiguration(
                                Gtk::Notebook_Helpers::PageList::iterator &it)
{
    std::string text =
        dynamic_cast<GLChartRenderer *>(it->get_child())->PrintGeneral();

    Gtk::Frame frame_general("General");
    Gtk::Label label_general(text);
    label_general.set_justify(Gtk::JUSTIFY_LEFT);
    label_general.set_line_wrap();
    frame_general.add(label_general);

    text = PrintGLSettings();

    Gtk::Frame frame_settings("OpenGL Settings");
    Gtk::Label label_settings(text);
    label_settings.set_justify(Gtk::JUSTIFY_LEFT);
    label_settings.set_line_wrap();
    frame_settings.add(label_settings);

    Gtk::Dialog dialog("Renderer Configuration");

    dialog.get_vbox()->pack_start(frame_general, Gtk::PACK_SHRINK);
    dialog.get_vbox()->pack_start(frame_settings, Gtk::PACK_SHRINK);

    dialog.get_vbox()->show_all();

    dialog.add_button(Gtk::Stock::OK, Gtk::RESPONSE_OK);

    dialog.run();
}

/**
 * Print a GL attribute from the Gdk::GL::Config
 */
void RendererBook::PrintGLAttribute(std::ostringstream &strstr,
             const char* attrib_str, int attrib, bool is_boolean)
{
    int value;

    if (glconfig->get_attrib(attrib, value)) {
        strstr << attrib_str << ": ";
        if (is_boolean)
            strstr << (value == true ? "true" : "false") << std::endl;
        else
            strstr << value << std::endl;
    } else 
        strstr << "Cannot get " << attrib_str << " attribute value"
               << std::endl;
}

/**
 * Print the gl configuration to a string
 * @return std::string with the configuration details
 */
std::string RendererBook::PrintGLSettings()
{
    std::ostringstream strstr;

    strstr << "OpenGL Configuration:" << std::endl;
    strstr << "RGBA: "
              << (glconfig->is_rgba() ? "true" : "false")
              << std::endl;
    strstr << "Double Buffering: "
              << (glconfig->is_double_buffered() ? "true" : "false")
              << std::endl;
    strstr << "Stereo: "
              << (glconfig->is_stereo() ? "true" : "false")
              << std::endl;
    strstr << "Alpha Channel: "
              << (glconfig->has_alpha() ? "true" : "false")
              << std::endl;
    strstr << "Depth Buffer: "
              << (glconfig->has_depth_buffer() ? "true" : "false")
              << std::endl;
    strstr << "Stencil Buffer: "
              << (glconfig->has_stencil_buffer() ? "true" : "false")
              << std::endl;
    strstr << "Accumulation Buffer: "
              << (glconfig->has_accum_buffer() ? "true" : "false")
              << std::endl;
    strstr << std::endl;

    PrintGLAttribute(strstr, "Gdk::GL::USE_GL", Gdk::GL::USE_GL, true);
    PrintGLAttribute(strstr, "Gdk::GL::BUFFER_SIZE",
                                        Gdk::GL::BUFFER_SIZE, false);
    PrintGLAttribute(strstr, "Gdk::GL::LEVEL", Gdk::GL::LEVEL, false);
    PrintGLAttribute(strstr, "Gdk::GL::RGBA", Gdk::GL::RGBA, true);
    PrintGLAttribute(strstr, "Gdk::GL::DOUBLEBUFFER",
                                        Gdk::GL::DOUBLEBUFFER, true);
    PrintGLAttribute(strstr, "Gdk::GL::STEREO", Gdk::GL::STEREO, true);
    PrintGLAttribute(strstr, "Gdk::GL::AUX_BUFFERS",
                                        Gdk::GL::AUX_BUFFERS, false);
    PrintGLAttribute(strstr, "Gdk::GL::RED_SIZE", Gdk::GL::RED_SIZE, false);
    PrintGLAttribute(strstr, "Gdk::GL::GREEN_SIZE", Gdk::GL::GREEN_SIZE, false);
    PrintGLAttribute(strstr, "Gdk::GL::BLUE_SIZE", Gdk::GL::BLUE_SIZE, false);
    PrintGLAttribute(strstr, "Gdk::GL::ALPHA_SIZE", Gdk::GL::ALPHA_SIZE, false);
    PrintGLAttribute(strstr, "Gdk::GL::DEPTH_SIZE", Gdk::GL::DEPTH_SIZE, false);
    PrintGLAttribute(strstr, "Gdk::GL::STENCIL_SIZE",
                                        Gdk::GL::STENCIL_SIZE, false);
    PrintGLAttribute(strstr, "Gdk::GL::ACCUM_RED_SIZE",
                                        Gdk::GL::ACCUM_RED_SIZE, false);
    PrintGLAttribute(strstr, "Gdk::GL::ACCUM_GREEN_SIZE",
                                        Gdk::GL::ACCUM_GREEN_SIZE, false);
    PrintGLAttribute(strstr, "Gdk::GL::ACCUM_BLUE_SIZE",
                                        Gdk::GL::ACCUM_BLUE_SIZE, false);
    PrintGLAttribute(strstr, "Gdk::GL::ACCUM_ALPHA_SIZE",
                                        Gdk::GL::ACCUM_ALPHA_SIZE, false);

    strstr << std::endl;
    return strstr.str();
}

//
// custom signal handlers
//

/**
 * drawing config changed callback
 * @param type Type (point, line, area)
 * @param index index changed
 * @drawn drawn bool
 */
void RendererBook::on_changed(feature_type_e type, int index, bool drawn)
{
    switch (type)
    {
        case POINT:
            configuration->points_drawn[index] = drawn;
            break;
        case LINE:
            configuration->lines_drawn[index] = drawn;
            break;
        case AREA:
            configuration->areas_drawn[index] = drawn;
            break;
        default:
            break;
    }
    Gtk::Notebook_Helpers::PageList::iterator it;
    it = get_current();
    GLChartRenderer *renderer =
                        dynamic_cast<GLChartRenderer *>(it->get_child());
    renderer->ForceRender();
}

/**
 * Switch page callback
 */
void RendererBook::on_switch_page(GtkNotebookPage *page, guint page_num)
{
    Gtk::Notebook::on_switch_page(page, page_num);
    GLChartRenderer *renderer =
                    dynamic_cast<GLChartRenderer *>(get_nth_page(page_num));
    Chart *chart = renderer->GetChart();

    signal_switched.emit(chart);
}