Search
lxdream.org :: lxdream/src/gtkui/gtk_win.c
lxdream 0.9.1
released Jun 29
Download Now
filename src/gtkui/gtk_win.c
changeset 854:130928a3cdcb
prev850:28782ebbd01d
next887:8b3ee741c9d7
author nkeynes
date Tue Sep 09 00:51:43 2008 +0000 (11 years ago)
permissions -rw-r--r--
last change Add general gl_window_to_system_coords function to convert window system coordinates
back into something in the DC range of 640x480, update mouse events to use it
view annotate diff log raw
     1 /**
     2  * $Id$
     3  *
     4  * Define the main (emu) GTK window, along with its menubars,
     5  * toolbars, etc.
     6  *
     7  * Copyright (c) 2005 Nathan Keynes.
     8  *
     9  * This program is free software; you can redistribute it and/or modify
    10  * it under the terms of the GNU General Public License as published by
    11  * the Free Software Foundation; either version 2 of the License, or
    12  * (at your option) any later version.
    13  *
    14  * This program is distributed in the hope that it will be useful,
    15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
    16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    17  * GNU General Public License for more details.
    18  */
    20 #include <assert.h>
    21 #include <sys/types.h>
    22 #include <sys/stat.h>
    23 #include <unistd.h>
    24 #include <string.h>
    25 #include <stdio.h>
    26 #include <stdlib.h>
    28 #include <gtk/gtk.h>
    29 #include <gdk/gdk.h>
    30 #include <gdk/gdkkeysyms.h>
    31 #include <X11/Xutil.h>
    33 #include "lxdream.h"
    34 #include "dreamcast.h"
    35 #include "display.h"
    36 #include "gdrom/gdrom.h"
    37 #include "gtkui/gtkui.h"
    40 struct main_window_info {
    41     GtkWidget *window;
    42     GtkWidget *video;
    43     GtkWidget *menubar;
    44     GtkWidget *toolbar;
    45     GtkWidget *statusbar;
    46     GtkActionGroup *actions;
    47     gboolean use_grab;
    48     gboolean is_grabbed;
    49     int32_t mouse_x, mouse_y;
    50 };
    53 /******************** Video window **************************/
    55 #if !(GTK_CHECK_VERSION(2,8,0))
    56 void gdk_display_warp_pointer (GdkDisplay *display,
    57                                GdkScreen  *screen,
    58                                gint        x,
    59                                gint        y);
    60 #endif
    62 /**
    63  * Adjust the mouse pointer so that it appears in the center of the video
    64  * window. Mainly used for when we have the mouse grab
    65  */
    66 void video_window_center_pointer( main_window_t win )
    67 {
    68     GdkDisplay *display = gtk_widget_get_display(win->video);
    69     GdkScreen *screen = gtk_widget_get_screen(win->video);
    70     int x,y;
    71     int width, height;
    73     gdk_window_get_origin(win->video->window, &x, &y);
    74     gdk_drawable_get_size(GDK_DRAWABLE(win->video->window), &width, &height);
    75     x += width / 2;
    76     y += height / 2;
    78     gdk_display_warp_pointer( display, screen, x, y );
    79     win->mouse_x = width/2;
    80     win->mouse_y = height/2;
    81 }
    83 /**
    84  * Grab the keyboard and mouse for the display. The mouse cursor is hidden and
    85  * moved to the centre of the window.
    86  *
    87  * @param win The window receiving the grab
    88  * @return TRUE if the grab was successful, FALSE on failure.
    89  */
    90 gboolean video_window_grab_display( main_window_t win )
    91 {
    92     GdkWindow *gdkwin = win->video->window;
    93     GdkColor color = { 0,0,0,0 };
    94     char bytes[32]; /* 16 * 16 / 8 */
    95     memset(bytes, 0, 32);
    96     GdkPixmap *pixmap = gdk_bitmap_create_from_data(NULL, bytes, 16, 16);
    97     GdkCursor *cursor = gdk_cursor_new_from_pixmap(pixmap, pixmap, &color, &color, 16, 16);
    98     gdk_pixmap_unref(pixmap);
   100     gboolean success =
   101         gdk_pointer_grab( gdkwin, FALSE, 
   102                 GDK_POINTER_MOTION_MASK|GDK_BUTTON_PRESS_MASK|GDK_BUTTON_RELEASE_MASK, 
   103                 gdkwin, cursor, GDK_CURRENT_TIME ) == GDK_GRAB_SUCCESS;
   104     gdk_cursor_unref(cursor);
   105     if( success ) {
   106         success = gdk_keyboard_grab( gdkwin, FALSE, GDK_CURRENT_TIME ) == GDK_GRAB_SUCCESS;
   107         if( !success ) {
   108             gdk_pointer_ungrab(GDK_CURRENT_TIME);
   109         }
   110     }
   111     win->is_grabbed = success;
   112     main_window_set_running(win, dreamcast_is_running());
   113     return success;
   114 }
   116 /**
   117  * Release the display grab.
   118  */
   119 void video_window_ungrab_display( main_window_t win )
   120 {
   121     gdk_pointer_ungrab(GDK_CURRENT_TIME);
   122     gdk_keyboard_ungrab(GDK_CURRENT_TIME);
   123     win->is_grabbed = FALSE;
   124     main_window_set_running(win, dreamcast_is_running());
   125 }
   127 static gboolean on_video_window_mouse_motion( GtkWidget *widget, GdkEventMotion *event,
   128                                               gpointer user_data )
   129 {
   130     main_window_t win = (main_window_t)user_data;
   131     int x = (int)event->x;
   132     int y = (int)event->y;
   133     if( win->is_grabbed && 
   134             (x != win->mouse_x || y != win->mouse_y) ) {
   135         input_event_mousemove( x - win->mouse_x, y - win->mouse_y, FALSE );
   136         video_window_center_pointer(win);
   137     } else {
   138         int width, height;
   139         gl_window_to_system_coords( &x, &y );
   140         input_event_mousemove( x, y, TRUE );
   141     }
   142     return TRUE;
   143 }
   145 static gboolean on_video_window_mouse_exited( GtkWidget *widget, GdkEventCrossing *event,
   146                                               gpointer user_data )
   147 {
   148     main_window_t win = (main_window_t)user_data;
   149     if( !win->is_grabbed ) {
   150         input_event_mousemove( -1, -1, TRUE );
   151     }
   152     return TRUE;
   153 }    
   155 static gboolean on_video_window_mouse_pressed( GtkWidget *widget, GdkEventButton *event,
   156                                                gpointer user_data )
   157 {
   158     main_window_t win = (main_window_t)user_data;
   159     if( win->is_grabbed ) {
   160         input_event_mousedown( event->button-1, 0, 0, FALSE );
   161     } else {
   162         int x = (int)event->x;
   163         int y = (int)event->y;
   164         gl_window_to_system_coords( &x, &y );
   165         input_event_mousedown( event->button-1, x, y, TRUE ); 
   166     }
   167     return TRUE;
   168 }
   170 static gboolean on_video_window_mouse_released( GtkWidget *widget, GdkEventButton *event,
   171                                                 gpointer user_data )
   172 {
   173     main_window_t win = (main_window_t)user_data;
   174     if( win->is_grabbed ) {
   175         input_event_mouseup( event->button-1, 0, 0, FALSE );
   176     } else if( win->use_grab) {
   177         video_window_grab_display(win);
   178     } else {
   179         int x = (int)event->x;
   180         int y = (int)event->y;
   181         gl_window_to_system_coords( &x, &y );
   182         input_event_mouseup( event->button-1, x, y, TRUE ); 
   183     }        
   184     return TRUE;
   185 }
   187 static gboolean on_video_window_key_pressed( GtkWidget *widget, GdkEventKey *event,
   188                                              gpointer user_data )
   189 {
   190     main_window_t win = (main_window_t)user_data;
   191     if( win->is_grabbed ) {
   192 #ifdef HAVE_GTK_OSX
   193         /* On OSX, use the command key rather than ctrl-alt. Mainly because GTK/OSX 
   194          * doesn't seem to be able to get ctrl-alt reliably 
   195          **/
   196         if( event->keyval == GDK_Meta_L || event->keyval == GDK_Meta_R ) {
   197             video_window_ungrab_display(win);
   198             return TRUE;
   199         }
   200 #else    	
   201         /* Check for ungrab key combo (ctrl-alt). Unfortunately GDK sends it as
   202          * a singly-modified keypress rather than a double-modified 'null' press, 
   203          * so we have to do a little more work.
   204          * Only check Ctrl/Shift/Alt for state - don't want to check numlock/capslock/
   205          * mouse buttons/etc
   206          */
   207         int mod = gdk_keycode_to_modifier(gtk_widget_get_display(widget), event->hardware_keycode);
   208         int state = event->state & gtk_accelerator_get_default_mod_mask();
   209         if( (state == GDK_CONTROL_MASK && mod == GDK_MOD1_MASK) ||
   210                 (state == GDK_MOD1_MASK && mod == GDK_CONTROL_MASK) ) {
   211             video_window_ungrab_display(win);
   212             // Consume the keypress, DC doesn't get it.
   213             return TRUE;
   214         }
   215 #endif
   216     }
   217     input_event_keydown( NULL, gtk_get_unmodified_keyval(event), 1 );
   218     return TRUE;
   219 }
   221 static gboolean on_video_window_key_released( GtkWidget *widget, GdkEventKey *event,
   222                                               gpointer user_data )
   223 {
   224     input_event_keyup( NULL, gtk_get_unmodified_keyval(event), 0 );
   225     return TRUE;
   226 }
   228 static gboolean on_video_window_focus_changed( GtkWidget *widget, GdkEventFocus *event,
   229                                                gpointer user_data )
   230 {
   231     display_set_focused(event->in);
   232     return TRUE;
   233 }
   235 /*************************** Main window (frame) ******************************/
   237 static gboolean on_main_window_deleted( GtkWidget *widget, GdkEvent event, gpointer user_data )
   238 {
   239     dreamcast_shutdown();
   240     exit(0);
   241 }
   243 static void on_main_window_state_changed( GtkWidget *widget, GdkEventWindowState *state, 
   244                                           gpointer userdata )
   245 {
   246     main_window_t win = (main_window_t)userdata;
   247     if( state->changed_mask & GDK_WINDOW_STATE_FULLSCREEN ) {
   248         gboolean fs = (state->new_window_state & GDK_WINDOW_STATE_FULLSCREEN);
   249         GtkWidget *frame = gtk_widget_get_parent(win->video);
   250         if( frame->style == NULL ) {
   251             gtk_widget_set_style( frame, gtk_style_new() );
   252         }
   253         if( fs ) {
   254             gtk_widget_hide( win->menubar );
   255             gtk_widget_hide( win->toolbar );
   256             gtk_widget_hide( win->statusbar );
   258             frame->style->xthickness = 0;
   259             frame->style->ythickness = 0;
   260         } else {
   261             frame->style->xthickness = 2;
   262             frame->style->ythickness = 2;
   263             gtk_widget_show( win->menubar );
   264             gtk_widget_show( win->toolbar );
   265             gtk_widget_show( win->statusbar );
   266         }
   267         gtk_widget_queue_draw( win->window );
   268     }
   269 }
   271 main_window_t main_window_new( const gchar *title, GtkWidget *menubar, GtkWidget *toolbar,
   272                                GtkAccelGroup *accel_group )
   273 {
   274     GtkWidget *vbox;
   275     GtkWidget *frame;
   276     main_window_t win = g_malloc0( sizeof(struct main_window_info) );
   278     win->window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
   279     win->menubar = menubar;
   280     win->toolbar = toolbar;
   281     win->use_grab = FALSE;
   282     win->is_grabbed = FALSE;
   283     gtk_window_set_title( GTK_WINDOW(win->window), title );
   284     gtk_window_add_accel_group (GTK_WINDOW (win->window), accel_group);
   286     gtk_toolbar_set_style( GTK_TOOLBAR(toolbar), GTK_TOOLBAR_ICONS );
   288     win->video = video_gtk_create_drawable();
   289     gtk_widget_set_size_request( win->video, 640, 480 ); 
   290     gtk_widget_set_double_buffered( win->video, FALSE );
   291     frame = gtk_frame_new(NULL);
   292     gtk_frame_set_shadow_type( GTK_FRAME(frame), GTK_SHADOW_IN );
   293     gtk_container_add( GTK_CONTAINER(frame), win->video );
   295     win->statusbar = gtk_statusbar_new();
   297     vbox = gtk_vbox_new(FALSE, 0);
   298     gtk_container_add( GTK_CONTAINER(win->window), vbox );
   299     gtk_box_pack_start( GTK_BOX(vbox), menubar, FALSE, FALSE, 0 );
   300     gtk_box_pack_start( GTK_BOX(vbox), toolbar, FALSE, FALSE, 0 );
   301     gtk_box_pack_start( GTK_BOX(vbox), frame, TRUE, TRUE, 0 );
   302     gtk_box_pack_start( GTK_BOX(vbox), win->statusbar, FALSE, FALSE, 0 );
   303     gtk_widget_show_all( win->window );
   304     gtk_widget_grab_focus( win->video );
   306     gtk_statusbar_push( GTK_STATUSBAR(win->statusbar), 1, "Stopped" );
   308     g_signal_connect( win->window, "delete_event", 
   309                       G_CALLBACK(on_main_window_deleted), win );
   310     g_signal_connect( win->window, "window-state-event",
   311                       G_CALLBACK(on_main_window_state_changed), win );
   313     g_signal_connect( win->video, "key-press-event",
   314                       G_CALLBACK(on_video_window_key_pressed), win );
   315     g_signal_connect( win->video, "key-release-event",
   316                       G_CALLBACK(on_video_window_key_released), win );
   317     g_signal_connect( win->video, "motion-notify-event",
   318                       G_CALLBACK(on_video_window_mouse_motion), win );
   319     g_signal_connect( win->video, "leave-notify-event",
   320                       G_CALLBACK(on_video_window_mouse_exited), win );
   321     g_signal_connect( win->video, "button-press-event",
   322                       G_CALLBACK(on_video_window_mouse_pressed), win );
   323     g_signal_connect( win->video, "button-release-event", 
   324                       G_CALLBACK(on_video_window_mouse_released), win );
   325     g_signal_connect( win->video, "focus-in-event",
   326                       G_CALLBACK(on_video_window_focus_changed), win);
   327     g_signal_connect( win->video, "focus-out-event",
   328                       G_CALLBACK(on_video_window_focus_changed), win);
   330     gtk_widget_add_events( win->video, 
   331                            GDK_KEY_PRESS_MASK | GDK_KEY_RELEASE_MASK |
   332                            GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK |
   333                            GDK_POINTER_MOTION_MASK | GDK_FOCUS_CHANGE_MASK |
   334                            GDK_LEAVE_NOTIFY_MASK );
   336     return win;
   337 }
   339 void main_window_set_status_text( main_window_t win, char *text )
   340 {
   341     gtk_statusbar_pop( GTK_STATUSBAR(win->statusbar), 1 );
   342     if( win->is_grabbed ) {
   343         char buf[128];
   344 #ifdef HAVE_GTK_OSX
   345         snprintf( buf, sizeof(buf), "%s %s", text, _("(Press <command> to release grab)") );
   346 #else	
   347         snprintf( buf, sizeof(buf), "%s %s", text, _("(Press <ctrl><alt> to release grab)") );
   348 #endif
   349         gtk_statusbar_push( GTK_STATUSBAR(win->statusbar), 1, buf );
   350     } else {
   351         gtk_statusbar_push( GTK_STATUSBAR(win->statusbar), 1, text );
   352     }
   353 }
   355 void main_window_set_running( main_window_t win, gboolean running )
   356 {
   357     char *text = running ? _("Running") : _("Stopped");
   358     gtk_gui_enable_action( "Pause", running );
   359     gtk_gui_enable_action( "Run", !running && dreamcast_can_run() );
   360     main_window_set_status_text( win, text );
   361 }
   363 void main_window_set_framerate( main_window_t win, float rate )
   364 {
   367 }
   369 void main_window_set_speed( main_window_t win, double speed )
   370 {
   371     char buf[32];
   373     snprintf( buf, 32, "Running (%2.4f%%)", speed );
   374     main_window_set_status_text( win, buf );
   375 }
   377 GtkWidget *main_window_get_renderarea( main_window_t win )
   378 {
   379     return win->video;
   380 }
   382 GtkWindow *main_window_get_frame( main_window_t win )
   383 {
   384     return GTK_WINDOW(win->window);
   385 }
   387 void main_window_set_fullscreen( main_window_t win, gboolean fullscreen )
   388 {
   389     if( fullscreen ) {
   390         gtk_window_fullscreen( GTK_WINDOW(win->window) );
   391     } else {
   392         gtk_window_unfullscreen( GTK_WINDOW(win->window) );
   393     }
   394 }
   396 void main_window_set_use_grab( main_window_t win, gboolean use_grab )
   397 {
   398     if( use_grab != win->use_grab ) {
   399         if( use_grab ) {
   400             GdkCursor *cursor = gdk_cursor_new( GDK_HAND2 );
   401             gdk_window_set_cursor( win->video->window, cursor );
   402             gdk_cursor_unref( cursor );
   403         } else {
   404             gdk_window_set_cursor( win->video->window, NULL );
   405             if( gdk_pointer_is_grabbed() ) {
   406                 video_window_ungrab_display(win);
   407             }
   408         }
   409         win->use_grab = use_grab;
   410     }
   411 }
   413 void main_window_update_title( main_window_t win )
   414 {
   415     const char *disc = gdrom_get_current_disc_title();
   417     if( disc == NULL ) {
   418         gtk_window_set_title( GTK_WINDOW(win->window), lxdream_package_name );
   419     } else {
   420         char buf[256];
   421         snprintf( buf, sizeof(buf), "%s - %s", lxdream_package_name, disc );
   422         gtk_window_set_title( GTK_WINDOW(win->window), buf );
   423     }
   424 }
.