#include <map>
#include <set>
-#include <gtk/gtkwindow.h>
-#include <gtk/gtkaccelgroup.h>
+#include <gtk/gtk.h>
#include "generic/callback.h"
#include "generic/bitfield.h"
return 0;
}
k = gdk_keyval_from_name( name );
- if ( k == GDK_VoidSymbol ) {
+ if ( k == GDK_KEY_VoidSymbol ) {
return 0;
}
return k;
ostream << gtk_accelerator_get_label( accelerator.key, accelerator.modifiers );
}
-typedef std::map<Accelerator, Callback> AcceleratorMap;
+typedef std::map<Accelerator, Callback<void()>> AcceleratorMap;
typedef std::set<Accelerator> AcceleratorSet;
-bool accelerator_map_insert( AcceleratorMap& acceleratorMap, Accelerator accelerator, const Callback& callback ){
+bool accelerator_map_insert( AcceleratorMap& acceleratorMap, Accelerator accelerator, const Callback<void()>& callback ){
if ( accelerator.key != 0 ) {
return acceleratorMap.insert( AcceleratorMap::value_type( accelerator, callback ) ).second;
}
Accelerator accelerator_for_event_key( guint keyval, guint state ){
keyval = gdk_keyval_to_upper( keyval );
- if ( keyval == GDK_ISO_Left_Tab ) {
- keyval = GDK_Tab;
+ if ( keyval == GDK_KEY_ISO_Left_Tab ) {
+ keyval = GDK_KEY_Tab;
}
return Accelerator( keyval, (GdkModifierType)( state & gtk_accelerator_get_default_mod_mask() ) );
}
return false;
}
-static gboolean accelerator_key_event( GtkWindow* window, GdkEventKey* event, AcceleratorMap* acceleratorMap ){
+static gboolean accelerator_key_event( ui::Window window, GdkEventKey* event, AcceleratorMap* acceleratorMap ){
return AcceleratorMap_activate( *acceleratorMap, accelerator_for_event_key( event->keyval, event->state ) );
}
return 0;
}
-bool window_has_accel( GtkWindow* toplevel ){
+bool window_has_accel( ui::Window toplevel ){
return g_slist_length( gtk_accel_groups_from_object( G_OBJECT( toplevel ) ) ) != 0;
}
}
-GClosure* accel_group_add_accelerator( GtkAccelGroup* group, Accelerator accelerator, const Callback& callback );
-void accel_group_remove_accelerator( GtkAccelGroup* group, Accelerator accelerator );
+GClosure* accel_group_add_accelerator(ui::AccelGroup group, Accelerator accelerator, const Callback<void()>& callback );
+void accel_group_remove_accelerator(ui::AccelGroup group, Accelerator accelerator );
AcceleratorMap g_queuedAcceleratorsAdd;
AcceleratorSet g_queuedAcceleratorsRemove;
-void globalQueuedAccelerators_add( Accelerator accelerator, const Callback& callback ){
+void globalQueuedAccelerators_add( Accelerator accelerator, const Callback<void()>& callback ){
if ( !g_queuedAcceleratorsAdd.insert( AcceleratorMap::value_type( accelerator, callback ) ).second ) {
globalErrorStream() << "globalQueuedAccelerators_add: accelerator already queued: " << accelerator << "\n";
}
g_queuedAcceleratorsAdd.clear();
}
-void accel_group_test( GtkWindow* toplevel, GtkAccelGroup* accel ){
- guint n_entries;
- gtk_accel_group_query( accel, '4', (GdkModifierType)0, &n_entries );
- globalOutputStream() << "grid4: " << n_entries << "\n";
- globalOutputStream() << "toplevel accelgroups: " << g_slist_length( gtk_accel_groups_from_object( G_OBJECT( toplevel ) ) ) << "\n";
-}
-
-typedef std::set<GtkWindow*> WindowSet;
+typedef std::set<ui::Window> WindowSet;
WindowSet g_accel_windows;
bool Buttons_press( ButtonMask& buttons, guint button, guint state ){
g_accel_enabled = false;
for ( WindowSet::iterator i = g_accel_windows.begin(); i != g_accel_windows.end(); ++i )
{
- GtkWindow* toplevel = *i;
+ ui::Window toplevel = *i;
ASSERT_MESSAGE( window_has_accel( toplevel ), "ERROR" );
- ASSERT_MESSAGE( GTK_WIDGET_TOPLEVEL( toplevel ), "disabling accel for non-toplevel window" );
+ ASSERT_MESSAGE( gtk_widget_is_toplevel( toplevel ), "disabling accel for non-toplevel window" );
gtk_window_remove_accel_group( toplevel, global_accel );
#if 0
globalOutputStream() << reinterpret_cast<unsigned int>( toplevel ) << ": disabled global accelerators\n";
-#endif
-#if 0
- accel_group_test( toplevel, global_accel );
#endif
}
}
g_accel_enabled = true;
for ( WindowSet::iterator i = g_accel_windows.begin(); i != g_accel_windows.end(); ++i )
{
- GtkWindow* toplevel = *i;
+ ui::Window toplevel = *i;
ASSERT_MESSAGE( !window_has_accel( toplevel ), "ERROR" );
- ASSERT_MESSAGE( GTK_WIDGET_TOPLEVEL( toplevel ), "enabling accel for non-toplevel window" );
- gtk_window_add_accel_group( toplevel, global_accel );
+ ASSERT_MESSAGE( gtk_widget_is_toplevel( toplevel ), "enabling accel for non-toplevel window" );
+ toplevel.add_accel_group( global_accel );
#if 0
globalOutputStream() << reinterpret_cast<unsigned int>( toplevel ) << ": enabled global accelerators\n";
-#endif
-#if 0
- accel_group_test( toplevel, global_accel );
#endif
}
globalQueuedAccelerators_commit();
}
};
-gboolean PressedButtons_button_press( GtkWidget* widget, GdkEventButton* event, PressedButtons* pressed ){
+gboolean PressedButtons_button_press(ui::Widget widget, GdkEventButton* event, PressedButtons* pressed ){
if ( event->type == GDK_BUTTON_PRESS ) {
return Buttons_press( pressed->buttons, event->button, event->state );
}
return FALSE;
}
-gboolean PressedButtons_button_release( GtkWidget* widget, GdkEventButton* event, PressedButtons* pressed ){
+gboolean PressedButtons_button_release(ui::Widget widget, GdkEventButton* event, PressedButtons* pressed ){
if ( event->type == GDK_BUTTON_RELEASE ) {
return Buttons_release( pressed->buttons, event->button, event->state );
}
return FALSE;
}
-gboolean PressedButtons_focus_out( GtkWidget* widget, GdkEventFocus* event, PressedButtons* pressed ){
+gboolean PressedButtons_focus_out(ui::Widget widget, GdkEventFocus* event, PressedButtons* pressed ){
Buttons_releaseAll( pressed->buttons );
return FALSE;
}
-void PressedButtons_connect( PressedButtons& pressedButtons, GtkWidget* widget ){
- g_signal_connect( G_OBJECT( widget ), "button_press_event", G_CALLBACK( PressedButtons_button_press ), &pressedButtons );
- g_signal_connect( G_OBJECT( widget ), "button_release_event", G_CALLBACK( PressedButtons_button_release ), &pressedButtons );
- g_signal_connect( G_OBJECT( widget ), "focus_out_event", G_CALLBACK( PressedButtons_focus_out ), &pressedButtons );
+void PressedButtons_connect( PressedButtons& pressedButtons, ui::Widget widget ){
+ widget.connect( "button_press_event", G_CALLBACK( PressedButtons_button_press ), &pressedButtons );
+ widget.connect( "button_release_event", G_CALLBACK( PressedButtons_button_release ), &pressedButtons );
+ widget.connect( "focus_out_event", G_CALLBACK( PressedButtons_focus_out ), &pressedButtons );
}
PressedButtons g_pressedButtons;
#include <set>
+#include <uilib/uilib.h>
struct PressedKeys
{
keys.clear();
}
-gboolean PressedKeys_key_press( GtkWidget* widget, GdkEventKey* event, PressedKeys* pressedKeys ){
+gboolean PressedKeys_key_press(ui::Widget widget, GdkEventKey* event, PressedKeys* pressedKeys ){
//globalOutputStream() << "pressed: " << event->keyval << "\n";
//return event->state == 0 && Keys_press( pressedKeys->keys, event->keyval );
//NumLock perspective window fix
return ( event->state & ALLOWED_MODIFIERS ) == 0 && Keys_press( pressedKeys->keys, event->keyval );
}
-gboolean PressedKeys_key_release( GtkWidget* widget, GdkEventKey* event, PressedKeys* pressedKeys ){
+gboolean PressedKeys_key_release(ui::Widget widget, GdkEventKey* event, PressedKeys* pressedKeys ){
//globalOutputStream() << "released: " << event->keyval << "\n";
return Keys_release( pressedKeys->keys, event->keyval );
}
-gboolean PressedKeys_focus_in( GtkWidget* widget, GdkEventFocus* event, PressedKeys* pressedKeys ){
+gboolean PressedKeys_focus_in(ui::Widget widget, GdkEventFocus* event, PressedKeys* pressedKeys ){
++pressedKeys->refcount;
return FALSE;
}
-gboolean PressedKeys_focus_out( GtkWidget* widget, GdkEventFocus* event, PressedKeys* pressedKeys ){
+gboolean PressedKeys_focus_out(ui::Widget widget, GdkEventFocus* event, PressedKeys* pressedKeys ){
if ( --pressedKeys->refcount == 0 ) {
Keys_releaseAll( pressedKeys->keys, 0 );
}
Keys_releaseAll( g_pressedKeys.keys, 0 );
}
-void GlobalPressedKeys_connect( GtkWindow* window ){
- unsigned int key_press_handler = g_signal_connect( G_OBJECT( window ), "key_press_event", G_CALLBACK( PressedKeys_key_press ), &g_pressedKeys );
- unsigned int key_release_handler = g_signal_connect( G_OBJECT( window ), "key_release_event", G_CALLBACK( PressedKeys_key_release ), &g_pressedKeys );
+void GlobalPressedKeys_connect( ui::Window window ){
+ unsigned int key_press_handler = window.connect( "key_press_event", G_CALLBACK( PressedKeys_key_press ), &g_pressedKeys );
+ unsigned int key_release_handler = window.connect( "key_release_event", G_CALLBACK( PressedKeys_key_release ), &g_pressedKeys );
g_object_set_data( G_OBJECT( window ), "key_press_handler", gint_to_pointer( key_press_handler ) );
g_object_set_data( G_OBJECT( window ), "key_release_handler", gint_to_pointer( key_release_handler ) );
- unsigned int focus_in_handler = g_signal_connect( G_OBJECT( window ), "focus_in_event", G_CALLBACK( PressedKeys_focus_in ), &g_pressedKeys );
- unsigned int focus_out_handler = g_signal_connect( G_OBJECT( window ), "focus_out_event", G_CALLBACK( PressedKeys_focus_out ), &g_pressedKeys );
+ unsigned int focus_in_handler = window.connect( "focus_in_event", G_CALLBACK( PressedKeys_focus_in ), &g_pressedKeys );
+ unsigned int focus_out_handler = window.connect( "focus_out_event", G_CALLBACK( PressedKeys_focus_out ), &g_pressedKeys );
g_object_set_data( G_OBJECT( window ), "focus_in_handler", gint_to_pointer( focus_in_handler ) );
g_object_set_data( G_OBJECT( window ), "focus_out_handler", gint_to_pointer( focus_out_handler ) );
}
-void GlobalPressedKeys_disconnect( GtkWindow* window ){
+void GlobalPressedKeys_disconnect( ui::Window window ){
g_signal_handler_disconnect( G_OBJECT( window ), gpointer_to_int( g_object_get_data( G_OBJECT( window ), "key_press_handler" ) ) );
g_signal_handler_disconnect( G_OBJECT( window ), gpointer_to_int( g_object_get_data( G_OBJECT( window ), "key_release_handler" ) ) );
g_signal_handler_disconnect( G_OBJECT( window ), gpointer_to_int( g_object_get_data( G_OBJECT( window ), "focus_in_handler" ) ) );
-void special_accelerators_add( Accelerator accelerator, const Callback& callback ){
+void special_accelerators_add( Accelerator accelerator, const Callback<void()>& callback ){
//globalOutputStream() << "special_accelerators_add: " << makeQuoted(accelerator) << "\n";
if ( !accelerator_map_insert( g_special_accelerators, accelerator, callback ) ) {
globalErrorStream() << "special_accelerators_add: already exists: " << makeQuoted( accelerator ) << "\n";
}
}
-void keydown_accelerators_add( Accelerator accelerator, const Callback& callback ){
+void keydown_accelerators_add( Accelerator accelerator, const Callback<void()>& callback ){
//globalOutputStream() << "keydown_accelerators_add: " << makeQuoted(accelerator) << "\n";
if ( !accelerator_map_insert( g_keydown_accelerators, accelerator, callback ) ) {
globalErrorStream() << "keydown_accelerators_add: already exists: " << makeQuoted( accelerator ) << "\n";
}
}
-void keyup_accelerators_add( Accelerator accelerator, const Callback& callback ){
+void keyup_accelerators_add( Accelerator accelerator, const Callback<void()>& callback ){
//globalOutputStream() << "keyup_accelerators_add: " << makeQuoted(accelerator) << "\n";
if ( !accelerator_map_insert( g_keyup_accelerators, accelerator, callback ) ) {
globalErrorStream() << "keyup_accelerators_add: already exists: " << makeQuoted( accelerator ) << "\n";
}
-gboolean accel_closure_callback( GtkAccelGroup* group, GtkWidget* widget, guint key, GdkModifierType modifiers, gpointer data ){
- ( *reinterpret_cast<Callback*>( data ) )( );
+gboolean accel_closure_callback(ui::AccelGroup group, ui::Widget widget, guint key, GdkModifierType modifiers, gpointer data ){
+ ( *reinterpret_cast<Callback<void()>*>( data ) )( );
return TRUE;
}
-GClosure* accel_group_add_accelerator( GtkAccelGroup* group, Accelerator accelerator, const Callback& callback ){
+GClosure* accel_group_add_accelerator(ui::AccelGroup group, Accelerator accelerator, const Callback<void()>& callback ){
if ( accelerator.key != 0 && gtk_accelerator_valid( accelerator.key, accelerator.modifiers ) ) {
//globalOutputStream() << "global_accel_connect: " << makeQuoted(accelerator) << "\n";
GClosure* closure = create_cclosure( G_CALLBACK( accel_closure_callback ), callback );
}
}
-void accel_group_remove_accelerator( GtkAccelGroup* group, Accelerator accelerator ){
+void accel_group_remove_accelerator(ui::AccelGroup group, Accelerator accelerator ){
if ( accelerator.key != 0 && gtk_accelerator_valid( accelerator.key, accelerator.modifiers ) ) {
//globalOutputStream() << "global_accel_disconnect: " << makeQuoted(accelerator) << "\n";
gtk_accel_group_disconnect_key( group, accelerator.key, accelerator.modifiers );
}
}
-GtkAccelGroup* global_accel = 0;
-
-void global_accel_init(){
- global_accel = gtk_accel_group_new();
-}
-
-void global_accel_destroy(){
- g_object_unref( global_accel );
-}
+ui::AccelGroup global_accel{ui::New};
-GClosure* global_accel_group_add_accelerator( Accelerator accelerator, const Callback& callback ){
+GClosure* global_accel_group_add_accelerator( Accelerator accelerator, const Callback<void()>& callback ){
if ( !global_accel_enabled() ) {
// workaround: cannot add to GtkAccelGroup while it is disabled
//globalOutputStream() << "queued for add: " << accelerator << "\n";
}
/// \brief Propagates key events to the focus-widget, overriding global accelerators.
-static gboolean override_global_accelerators( GtkWindow* window, GdkEventKey* event, gpointer data ){
+static gboolean override_global_accelerators( ui::Window window, GdkEventKey* event, gpointer data ){
gboolean b = gtk_window_propagate_key_event( window, event );
return b;
}
-void global_accel_connect_window( GtkWindow* window ){
+void global_accel_connect_window( ui::Window window ){
#if 1
- unsigned int override_handler = g_signal_connect( G_OBJECT( window ), "key_press_event", G_CALLBACK( override_global_accelerators ), 0 );
+ unsigned int override_handler = window.connect( "key_press_event", G_CALLBACK( override_global_accelerators ), 0 );
g_object_set_data( G_OBJECT( window ), "override_handler", gint_to_pointer( override_handler ) );
- unsigned int special_key_press_handler = g_signal_connect( G_OBJECT( window ), "key_press_event", G_CALLBACK( accelerator_key_event ), &g_special_accelerators );
+ unsigned int special_key_press_handler = window.connect( "key_press_event", G_CALLBACK( accelerator_key_event ), &g_special_accelerators );
g_object_set_data( G_OBJECT( window ), "special_key_press_handler", gint_to_pointer( special_key_press_handler ) );
GlobalPressedKeys_connect( window );
#else
- unsigned int key_press_handler = g_signal_connect( G_OBJECT( window ), "key_press_event", G_CALLBACK( accelerator_key_event ), &g_keydown_accelerators );
- unsigned int key_release_handler = g_signal_connect( G_OBJECT( window ), "key_release_event", G_CALLBACK( accelerator_key_event ), &g_keyup_accelerators );
+ unsigned int key_press_handler = window.connect( "key_press_event", G_CALLBACK( accelerator_key_event ), &g_keydown_accelerators );
+ unsigned int key_release_handler = window.connect( "key_release_event", G_CALLBACK( accelerator_key_event ), &g_keyup_accelerators );
g_object_set_data( G_OBJECT( window ), "key_press_handler", gint_to_pointer( key_press_handler ) );
g_object_set_data( G_OBJECT( window ), "key_release_handler", gint_to_pointer( key_release_handler ) );
#endif
g_accel_windows.insert( window );
- gtk_window_add_accel_group( window, global_accel );
+ window.add_accel_group( global_accel );
}
-void global_accel_disconnect_window( GtkWindow* window ){
+void global_accel_disconnect_window( ui::Window window ){
#if 1
GlobalPressedKeys_disconnect( window );
return 0;
}
-void global_accel_group_connect( const Accelerator& accelerator, const Callback& callback ){
+void global_accel_group_connect( const Accelerator& accelerator, const Callback<void()>& callback ){
if ( accelerator.key != 0 ) {
global_accel_group_add_accelerator( accelerator, callback );
}
}
-void global_accel_group_disconnect( const Accelerator& accelerator, const Callback& callback ){
+void global_accel_group_disconnect( const Accelerator& accelerator, const Callback<void()>& callback ){
if ( accelerator.key != 0 ) {
global_accel_group_remove_accelerator( accelerator );
}
projects / xonotic / netradiant.git / blobdiff