source: trunk/deushax/gtk/glmapview.cpp @ 863 Tweet

//
// Deus Hax (working title)
// Copyright (c) 2010 Sam Hocevar <sam@hocevar.net>
//

#if defined HAVE_CONFIG_H
#   include "config.h"
#endif

#include <gtk/gtk.h>
#include <gtkgl/gtkglarea.h>
#include <gdk/gdkkeysyms.h>

#include "core.h"

using namespace lol;

#include "glmapview.h"

static float const FPS = 30.0f;

GlMapView::GlMapView(GtkContainer *in_container,
                     GtkAdjustment *in_hadj,
                     GtkAdjustment *in_vadj)
  : hadj(in_hadj), vadj(in_vadj),
    ticking(FALSE), panning(FALSE), destroyed(FALSE),
    mapviewer(0),
    xpan(0.0), ypan(0.0)
{
    /* Create new OpenGL widget */
    int attrlist[] =
    {
        GDK_GL_RGBA,
        GDK_GL_RED_SIZE, 1,
        GDK_GL_GREEN_SIZE, 1,
        GDK_GL_BLUE_SIZE, 1,
        GDK_GL_DEPTH_SIZE, 16,
        GDK_GL_DOUBLEBUFFER,
        GDK_GL_NONE
    };

    glarea = gtk_gl_area_new(attrlist);
    gtk_widget_set_usize(glarea, 400, 300);
    gtk_widget_set_events(glarea, GDK_EXPOSURE_MASK |
                                  GDK_POINTER_MOTION_MASK |
                                  GDK_BUTTON_PRESS_MASK |
                                  GDK_BUTTON_RELEASE_MASK);
    gtk_widget_set_can_focus(glarea, TRUE);

    gtk_container_add(in_container, glarea);

    /* We tick from the idle function instead of a timeout to avoid
     * stealing time from the GTK loop when the callback time exceeds
     * the timeout value. */
    g_idle_add((GSourceFunc)IdleTickSignal, this);

    /* FIXME: for completeness, the "hierarchy_changed" signal should be
     * intercepted in case we ever get reparented. */
    g_signal_connect(GTK_OBJECT(glarea), "realize",
                     GTK_SIGNAL_FUNC(SetupSignal), this);
    g_signal_connect(GTK_OBJECT(glarea), "expose_event",
                     GTK_SIGNAL_FUNC(DrawSignal), this);
    g_signal_connect(GTK_OBJECT(glarea), "configure_event",
                     GTK_SIGNAL_FUNC(ReshapeSignal), this);

    g_signal_connect(GTK_OBJECT(glarea), "button_press_event",
                     GTK_SIGNAL_FUNC(MouseButtonSignal), this);
    g_signal_connect(GTK_OBJECT(glarea), "button_release_event",
                     GTK_SIGNAL_FUNC(MouseButtonSignal), this);
    g_signal_connect(GTK_OBJECT(glarea), "motion_notify_event",
                     GTK_SIGNAL_FUNC(MouseMotionSignal), this);

    g_signal_connect(GTK_OBJECT(glarea), "key_press_event",
                     GTK_SIGNAL_FUNC(KeyPressSignal), this);
}

GlMapView::~GlMapView()
{
    Shutdown();
}

void GlMapView::LoadMap(char const *path)
{
    // FIXME: detect when the map viewer is killed
    mapviewer = new MapViewer(path);
    Ticker::Ref(mapviewer);

    UpdateAdjustments();
}

void GlMapView::CloseMap()
{
    if (mapviewer)
        Ticker::Unref(mapviewer);
    mapviewer = NULL;

    UpdateAdjustments();
}

gboolean GlMapView::IdleTick()
{
    if (Ticker::Finished())
    {
        /* Release the hijacked exit sequence */
        gtk_main_quit();
        return FALSE;
    }

    if (!ticking)
    {
        ticking = TRUE;

        if (mapviewer)
            mapviewer->SetPOV(gtk_adjustment_get_value(hadj),
                              mapviewer->GetHeight() - glarea->allocation.height
                               - gtk_adjustment_get_value(vadj));

        /* Tick the game */
        Ticker::TickGame();
    }

    gtk_widget_draw(GTK_WIDGET(glarea), NULL);

    return TRUE;
}

gboolean GlMapView::Setup()
{
    /* Hook to the toplevel's unmap signal */
    GtkWidget *toplevel = gtk_widget_get_toplevel(glarea);
    if (g_signal_handler_find(toplevel, G_SIGNAL_MATCH_DATA,
                              0, 0, NULL, NULL, this) == 0)
        g_signal_connect(GTK_OBJECT(toplevel), "delete_event",
                         GTK_SIGNAL_FUNC(DeleteSignal), this);

    /* Set up display */
    gtk_widget_grab_focus(glarea);
    if (gtk_gl_area_make_current(GTK_GL_AREA(glarea)))
    {
        Ticker::Setup(FPS);
        Video::Setup(ivec2(glarea->allocation.width,
                           glarea->allocation.height));
    }

    UpdateAdjustments();

    return TRUE;
}

/* This method is called when gtk_main_quit() is called, or when the toplevel
 * widget is destroyed, or both. */
gboolean GlMapView::Shutdown()
{
    /* Make sure we don't initiate shutdown twice. It could happen if we
     * got the delete signal first, then the gtk_main_quit() signal. In
     * that case, ignore the latter. */
    if (!destroyed)
    {
        destroyed = TRUE;
        CloseMap();
        Ticker::Shutdown();
        gtk_widget_set_sensitive(gtk_widget_get_toplevel(glarea), FALSE);
        /* Hijack the exit sequence by adding another level of gtk_main,
         * because returning too soon may leave us no time to clean up. */
        gtk_main();
    }
    return FALSE;
}

gboolean GlMapView::Draw(GdkEventExpose *e)
{
    if (e->count > 0)
        return TRUE;

    /* OpenGL functions can be called only if make_current returns true */
    if (ticking && gtk_gl_area_make_current(GTK_GL_AREA(glarea)))
    {
        ticking = FALSE;

        /* Tick the renderer, show the frame and clamp to desired framerate */
        Ticker::TickDraw();
        gtk_gl_area_swapbuffers(GTK_GL_AREA(glarea));
        while (g_main_context_iteration(NULL, FALSE))
            ;

        /* FIXME: do some GTK stuff instead of waiting for so long */
        Ticker::ClampFps();
    }

    return TRUE;
}

void GlMapView::Scroll(double dx, double dy)
{
    gtk_adjustment_set_value(hadj, gtk_adjustment_get_value(hadj) + dx);
    gtk_adjustment_set_value(vadj, gtk_adjustment_get_value(vadj) + dy);

    UpdateAdjustments();
}

void GlMapView::UpdateAdjustments()
{
    float w = mapviewer ? mapviewer->GetWidth() : glarea->allocation.width;
    float h = mapviewer ? mapviewer->GetHeight() : glarea->allocation.height;

    /* Manage adjustments */
    struct { GtkAdjustment *adj; float map_size, sw_size; } s[2] =
    {
        { hadj, w, glarea->allocation.width },
        { vadj, h, glarea->allocation.height },
    };

    for (int i = 0; i < 2; i++)
    {
        gtk_adjustment_set_lower(s[i].adj, 0);
        gtk_adjustment_set_upper(s[i].adj, s[i].map_size);
        gtk_adjustment_set_step_increment(s[i].adj, 1);
        gtk_adjustment_set_page_increment(s[i].adj, s[i].sw_size);
        gtk_adjustment_set_page_size(s[i].adj, s[i].sw_size);

        float val = gtk_adjustment_get_value(s[i].adj);
        if (val + s[i].sw_size > s[i].map_size)
        {
            gtk_adjustment_set_value(s[i].adj,
                                     s[i].map_size - s[i].sw_size);
            gtk_adjustment_value_changed(s[i].adj);
        }
    }
}

gboolean GlMapView::MouseButton(GdkEventButton *e)
{
    if (e->type == GDK_BUTTON_PRESS && e->button == 2)
    {
        panning = TRUE;
        xpan = e->x;
        ypan = e->y;
        GdkCursor *cursor = gdk_cursor_new(GDK_HAND1);
        gdk_window_set_cursor(glarea->window, cursor);
        gdk_cursor_unref(cursor);
        return FALSE;
    }
    else if (e->type == GDK_BUTTON_RELEASE && e->button == 2)
    {
        panning = FALSE;
        gdk_window_set_cursor(glarea->window, NULL);
        return FALSE;
    }

    return TRUE;
}

gboolean GlMapView::MouseMotion(GdkEventMotion *e)
{
    if (panning)
    {
        Scroll(xpan - e->x, ypan - e->y);
        xpan = e->x;
        ypan = e->y;
        return TRUE;
    }

    return FALSE;
}

gboolean GlMapView::KeyPress(GdkEventKey *e)
{
    switch (e->keyval)
    {
    case GDK_Up:    Scroll(  0.0, -10.0); return TRUE;
    case GDK_Down:  Scroll(  0.0,  10.0); return TRUE;
    case GDK_Left:  Scroll(-10.0,   0.0); return TRUE;
    case GDK_Right: Scroll( 10.0,   0.0); return TRUE;
    }

    return FALSE;
}

/* Private signal slots */
gboolean GlMapView::IdleTickSignal(GlMapView *that)
{
    return that->IdleTick();
}

gboolean GlMapView::SetupSignal(GtkWidget *w, GlMapView *that)
{
    (void)w;
    return that->Setup();
}

gboolean GlMapView::DeleteSignal(GtkWidget *w, GdkEvent *e,
                                 GlMapView *that)
{
    /* XXX: w is not glarea, it's the top level window */
    (void)w;
    (void)e;
    return that->Shutdown();
}

gboolean GlMapView::DrawSignal(GtkWidget *w, GdkEventExpose *e,
                               GlMapView *that)
{
    (void)w;
    return that->Draw(e);
}

gboolean GlMapView::ReshapeSignal(GtkWidget *w, GdkEventConfigure *e,
                                  GlMapView *that)
{
    (void)w;
    (void)e;
    return that->Setup();
}

gboolean GlMapView::MouseButtonSignal(GtkWidget *w, GdkEventButton *e,
                                      GlMapView *that)
{
    (void)w;
    return that->MouseButton(e);
}

gboolean GlMapView::MouseMotionSignal(GtkWidget *w, GdkEventMotion *e,
                                      GlMapView *that)
{
    (void)w;
    return that->MouseMotion(e);
}

gboolean GlMapView::KeyPressSignal(GtkWidget *w, GdkEventKey *e,
                                   GlMapView *that)
{
    (void)w;
    return that->KeyPress(e);
}