glchartrenderer.cpp

开源的电子海图程序

    double newx = left_edge + x/zoom;

    if (newy >= nlat - ysize/zoom) 
        newy = nlat - ysize/zoom;
    else if (newy <= slat) 
        newy = slat;

    if (newx >= elon - xsize/zoom) 
        newx = elon - xsize/zoom;
    else if (newx <= wlon) 
        newx = wlon;
   
    bottom_edge = newy;
    left_edge = newx;

    Render();
}

/**
 * Update the cursor longitude and latitude labels
 */
void GLChartRenderer::UpdatePointerLongLat()
{
    pointer_lat = pointer_y / zoom;
    pointer_long = pointer_x / zoom;

    pointer_lat += bottom_edge; 
    pointer_long += left_edge;

    signal_pointer_longlat_updated.emit(pointer_lat, pointer_long);
}

//
// opengl callbacks
//

/**
 * Callback for when the window renderer is first up
 */
void GLChartRenderer::on_realize()
{
    Gtk::DrawingArea::on_realize();

    Glib::RefPtr<Gdk::GL::Window> glwindow = get_gl_window();

    if (!glwindow->gl_begin(get_gl_context()))
        std::cerr << "GLChartRenderer::on_realize() unable to get GL context"
                  << std::endl;
       
    glShadeModel(GL_SMOOTH);
    glClearColor(.7, .7, .7, 0.0);
    glDisable(GL_LIGHTING);
    // antialiasing
    glHint(GL_LINE_SMOOTH_HINT, GL_NICEST);
    glEnable(GL_LINE_SMOOTH);

    glwindow->gl_end();
}

/**
 * Callback for when the parent window is resized
 */
bool GLChartRenderer::on_configure_event(GdkEventConfigure *event)
{
    xsize = event->width;
    ysize = event->height;

    // This handles the event in which the new render
    // space reveals non-chart area. In this case we either scroll
    // or zoom to compensate.
    // Note that only the right and top edges are moving during a resize.
    if (chart) {
        // first see if we are too large for the chart in some dimension
        if ((xsize/zoom > (elon - wlon)) || (ysize/zoom > (nlat - slat))) {
            double y = nlat - slat;
            double x = elon - wlon;

            double zoomy = ysize / y;
            double zoomx = xsize / x;

            if (zoomy > zoomx)
                zoom = zoomy;
            else
                zoom = zoomx;
        }
    }

    Scroll(1,1); // this actually fixes any off-chart issues. nice.

    Render();

    return true;
}

/**
 * Callback for when the window is redrawn
 */
bool GLChartRenderer::on_expose_event(GdkEventExpose* event)
{
    Render();

    return true;
}

/**
 * Print renderer's general configuration to a string
 * @return the string
 */
std::string GLChartRenderer::PrintGeneral()
{
    Glib::RefPtr<Gdk::GL::Window> glwindow = get_gl_window();

    std::ostringstream strstr;
    if (!glwindow->gl_begin(get_gl_context())) {
        strstr << "GLChartRenderer::PrintGeneral(): unable to get GL context"
                  << std::endl;
        return strstr.str();
    }

    strstr << "Vendor string: " << glGetString(GL_VENDOR) << std::endl;
    strstr << "Renderer string: " << glGetString(GL_RENDERER) << std::endl;
    strstr << "OpenGL version string: " << glGetString(GL_VERSION) << std::endl;

    glwindow->gl_end();

    return strstr.str();
}

std::string GLChartRenderer::PrintExtensions()
{
    Glib::RefPtr<Gdk::GL::Window> glwindow = get_gl_window();

    std::ostringstream strstr;

    if (!glwindow->gl_begin(get_gl_context())) {
        strstr << "GLChartRenderer::PrintExtensions(): unable to get GL context"
                  << std::endl;
        return strstr.str();
    }

    strstr << "OpenGL extensions: " << glGetString(GL_EXTENSIONS) << std::endl;

    glwindow->gl_end();

    return strstr.str();
}

/**
 * Zoom to the selection rectangle.
 * @param mode Zoom-to-rect mode to use
 */
void GLChartRenderer::ZoomToSelectionRect(int mode)
{
    // first translate to the rect's lower left
    // -find the rect's lower left
    double left = selection_rect[0][0];
    for (int i = 1; i < 4; i++) {
        if (selection_rect[i][0] < left)
            left = selection_rect[i][0];
    }

    double bottom = selection_rect[0][1];
    for (int i = 1; i < 4; i++) {
        if (selection_rect[i][1] < bottom)
            bottom = selection_rect[i][1];
    }

    left_edge += left;
    bottom_edge += bottom;

    // now find the far right and top edges.  We use
    // these to determine the zoom.
    double right = selection_rect[0][0];
    for (int i = 1; i < 4; i++) {
        if (selection_rect[i][0] > right)
            right = selection_rect[i][0];
    }

    double top = selection_rect[0][1];
    for (int i = 1; i < 4; i++) {
        if (selection_rect[i][1] > top)
            top = selection_rect[i][1];
    } 
    
    double zoomy = ysize / (top - bottom);
    double zoomx = xsize / (right - left);

    switch (mode)
    {
        case ZOOM_SELECTION_LOOSE:
            if (zoomy < zoomx)
                zoom = zoomy;
            else
                zoom = zoomx;
            break;
        case ZOOM_SELECTION_TIGHT:
            if (zoomy > zoomx)
                zoom = zoomy;
            else
                zoom = zoomx;
            break;
        default:
            break;
    }

    selection_rect_drawn = false;

    for (int i = 0; i < 4; i++) {
        for (int j = 0; j < 2; j++) {
            selection_rect[i][j] = 0;
        }
    }
}

/**
 * Callback for mouse button press.
 * @param event Event
 * @return true on success, false on failure
 */
bool GLChartRenderer::on_button_press_event(GdkEventButton *event)
{
    switch (input_mode)
    {
        case PAN_MODE:
            switch (event->button)
            {
                case 1:
                    left_mouse_button = true;
                    last_x = event->x;
                    last_y = event->y;
                    break;
                default:
                    break;
            }
            break;
        case ROTATE_MODE:
            switch (event->button)
            {
                case 1:
                    left_mouse_button = true;
                    last_x = event->x;
                    last_y = event->y;
                    break;
                default:
                    break;
            }
            break;
        case ZOOM_IN_MODE:
            switch (event->button)
            {
                case 1:
                    left_mouse_button = true;
                    last_x = event->x;
                    last_y = ysize - event->y;
                    selection_rect_drawn = true;
                    break;
                default:
                    break;
            }
            break;
        case WAYPOINT_INSERT_MODE:
            if (chart) {
                switch (event->button)
                {
                    case 1:
                        AddWaypoint(event->x, ysize - event->y);
                        break;
                    default:
                        break;
                }
            }
            break;
        default:
            break;
    }
        
    return true;
}

/**
 * Mouse button release callback
 * @param event Event
 * @return true on success, false on failure
 */
bool GLChartRenderer::on_button_release_event(GdkEventButton *event)
{
    switch (input_mode)
    {
        case PAN_MODE:
            switch (event->button)
            {
                case 1:
                    left_mouse_button = false;
                    break;
                default:
                    break;
            }
            break;
        case ROTATE_MODE:
            switch (event->button)
            {
                case 1:
                    left_mouse_button = false;
                    break;
                default:
                    break;
            }
            break;
        case ZOOM_IN_MODE:
            switch (event->button)
            {
                case 1:
                {
                    left_mouse_button = false;
                    // we only zoom if we have a sufficiently large
                    // selection rect
                    double left = selection_rect[0][0];
                    double right = selection_rect[0][0];
                    for (int i = 1; i < 4; i++) {
                        if (selection_rect[i][0] < left)
                            left = selection_rect[i][0];
                        else if (selection_rect[i][0] > right)
                            right = selection_rect[i][0];
                    }

                    double top = selection_rect[0][1];
                    double bottom = selection_rect[0][1];
                    for (int i = 1; i < 4; i++) {
                        if (selection_rect[i][0] < bottom)
                            bottom = selection_rect[i][1];
                        else if (selection_rect[i][0] > top)
                            top = selection_rect[i][1];
                    }

                    double size;
                    if ((right - left) > (top - bottom))
                        size = (right - left);
                    else
                        size = (top - bottom);

                    if (size*zoom < SELECTION_ZOOM_MIN_PIXELS)
                        Zoom(true, CLICK_ZOOM);
                    else
                        ZoomToSelectionRect(ZOOM_SELECTION_LOOSE);

                    selection_rect_drawn = false;

                    Render();
                    break;
                }
                default:
                    break;
            }
            break;
         case ZOOM_OUT_MODE:
            switch (event->button)
            {
                case 1:
                    left_mouse_button = false;
                    Zoom(false, CLICK_ZOOM);
                    break;
                default:
                    break;
            }
            break;
        default:
            break;
    }

    return true;
}

/**
 * Mouse motion callback
 * @param event Event
 * @return true on success, false on failure
 */
bool GLChartRenderer::on_motion_notify_event(GdkEventMotion *event)
{
    pointer_x = event->x;
    pointer_y = ysize - event->y;

    switch (input_mode)
    {
        case PAN_MODE:
            if (left_mouse_button) {
                Scroll((last_x - event->x), (event->y - last_y));
                last_x = event->x;
                last_y = event->y;
            }
            break;
        case ZOOM_IN_MODE: 
            if (left_mouse_button) {
                // disallow zooming off render space
                if (pointer_x < 1)
                    pointer_x = 1;
                else if (pointer_x > xsize)
                    pointer_x = xsize;
                if (pointer_y < 1)
                    pointer_y = 1;
                else if (pointer_y > ysize)
                    pointer_y = ysize; 

                selection_rect[0][0] = last_x / zoom;
                selection_rect[0][1] = last_y / zoom;

                selection_rect[1][0] = pointer_x / zoom;
                selection_rect[1][1] = last_y / zoom;

                selection_rect[2][0] = pointer_x / zoom;
                selection_rect[2][1] = pointer_y / zoom;

                selection_rect[3][0] = last_x / zoom;
                selection_rect[3][1] = pointer_y / zoom;
                Render();
            }
            break;
        default:
            break;
    }

    UpdatePointerLongLat();

    return true;
}

/**
 * Mouse scroll wheel callback
 * @param event Event
 * @return true on success, false on failure
 */
bool GLChartRenderer::on_scroll_event(GdkEventScroll *event)
{
    switch (event->direction)
    {
        case GDK_SCROLL_UP:
            Zoom(true, SCROLL_ZOOM);
            break;
        case GDK_SCROLL_DOWN:
            Zoom(false, SCROLL_ZOOM);
            break;
        default:
            break;
    }
    return true;
}

Glib::RefPtr<Gdk::GL::Context> GLChartRenderer::GetContext()
{
    context = get_gl_context();
    if (!context) {
         std::cerr << "GLChartRenderer::GetContext() unable to get GL context"
                   << std::endl;
    }
    return context;
}