X-Git-Url: http://de.git.xonotic.org/?p=xonotic%2Fnetradiant.git;a=blobdiff_plain;f=radiant%2Fmainframe.cpp;h=26d6b1b290b9521acd7e7af3aec69dce93f2b4f3;hp=0e430f11c634a87b6298e64edb86cd72c4e97e37;hb=6e9818d9cddf3880d001a544770c8c2c5187676f;hpb=8bc246a01343d9c9dd3a8b678681710cf04a2953

diff --git a/radiant/mainframe.cpp b/radiant/mainframe.cpp
index 0e430f11..26d6b1b2 100644
--- a/radiant/mainframe.cpp
+++ b/radiant/mainframe.cpp
@@ -26,14 +26,12 @@
 //
 
 #include "mainframe.h"
+#include "globaldefs.h"
 
-#include "debugging/debugging.h"
-#include "version.h"
+#include <gtk/gtk.h>
 
 #include "ifilesystem.h"
 #include "iundo.h"
-#include "ifilter.h"
-#include "itoolbar.h"
 #include "editable.h"
 #include "ientity.h"
 #include "ishaders.h"
@@ -43,20 +41,9 @@
 #include <ctime>
 
 #include <gdk/gdkkeysyms.h>
-#include <gtk/gtkhbox.h>
-#include <gtk/gtkvbox.h>
-#include <gtk/gtkframe.h>
-#include <gtk/gtklabel.h>
-#include <gtk/gtkhpaned.h>
-#include <gtk/gtkvpaned.h>
-#include <gtk/gtktoolbar.h>
-#include <gtk/gtkmenubar.h>
-#include <gtk/gtkimage.h>
-#include <gtk/gtktable.h>
 
 
 #include "cmdlib.h"
-#include "scenelib.h"
 #include "stream/stringstream.h"
 #include "signal/isignal.h"
 #include "os/path.h"
@@ -65,14 +52,11 @@
 #include "moduleobservers.h"
 
 #include "gtkutil/clipboard.h"
-#include "gtkutil/container.h"
 #include "gtkutil/frame.h"
-#include "gtkutil/glfont.h"
 #include "gtkutil/glwidget.h"
 #include "gtkutil/image.h"
 #include "gtkutil/menu.h"
 #include "gtkutil/paned.h"
-#include "gtkutil/widget.h"
 
 #include "autosave.h"
 #include "build.h"
@@ -101,7 +85,6 @@
 #include "pluginmanager.h"
 #include "pluginmenu.h"
 #include "plugintoolbar.h"
-#include "points.h"
 #include "preferences.h"
 #include "qe3.h"
 #include "qgl.h"
@@ -116,7 +99,7 @@
 #include "renderstate.h"
 #include "feedback.h"
 #include "referencecache.h"
-
+#include "texwindow.h"
 
 
 struct layout_globals_t
@@ -146,22 +129,44 @@ glwindow_globals_t g_glwindow_globals;
 
 
 // VFS
+
+bool g_vfsInitialized = false;
+
+void VFS_Init(){
+	if ( g_vfsInitialized ) return;
+	QE_InitVFS();
+	GlobalFileSystem().initialise();
+	g_vfsInitialized = true;
+}
+void VFS_Shutdown(){
+	if ( !g_vfsInitialized ) return;
+	GlobalFileSystem().shutdown();
+	g_vfsInitialized = false;
+}
+void VFS_Refresh(){
+	if ( !g_vfsInitialized ) return;
+	GlobalFileSystem().clear();
+	QE_InitVFS();
+	GlobalFileSystem().refresh();
+	g_vfsInitialized = true;
+	// also refresg models
+	RefreshReferences();
+	// also refresh texture browser
+	TextureBrowser_RefreshShaders();
+}
+void VFS_Restart(){
+	VFS_Shutdown();
+	VFS_Init();
+}
+
 class VFSModuleObserver : public ModuleObserver
 {
-std::size_t m_unrealised;
 public:
-VFSModuleObserver() : m_unrealised( 1 ){
-}
 void realise(){
-	if ( --m_unrealised == 0 ) {
-		QE_InitVFS();
-		GlobalFileSystem().initialise();
-	}
+	VFS_Init();
 }
 void unrealise(){
-	if ( ++m_unrealised == 1 ) {
-		GlobalFileSystem().shutdown();
-	}
+	VFS_Shutdown();
 }
 };
 
@@ -176,7 +181,7 @@ void VFS_Destroy(){
 
 // Home Paths
 
-#ifdef WIN32
+#if GDEF_OS_WINDOWS
 #include <shlobj.h>
 #include <objbase.h>
 const GUID qFOLDERID_SavedGames = {0x4C5C32FF, 0xBB9D, 0x43b0, {0xB5, 0xB4, 0x2D, 0x72, 0xE5, 0x4E, 0xAA, 0xA4}};
@@ -193,7 +198,7 @@ void HomePaths_Realise(){
 		if ( !string_empty( prefix ) ) {
 			StringOutputStream path( 256 );
 
-#if defined( __APPLE__ )
+#if GDEF_OS_MACOS
 			path.clear();
 			path << DirectoryCleaned( g_get_home_dir() ) << "Library/Application Support" << ( prefix + 1 ) << "/";
 			if ( file_is_directory( path.c_str() ) ) {
@@ -204,7 +209,7 @@ void HomePaths_Realise(){
 			path << DirectoryCleaned( g_get_home_dir() ) << prefix << "/";
 #endif
 
-#if defined( WIN32 )
+#if GDEF_OS_WINDOWS
 			TCHAR mydocsdir[MAX_PATH + 1];
 			wchar_t *mydocsdirw;
 			HMODULE shfolder = LoadLibrary( "shfolder.dll" );
@@ -243,7 +248,7 @@ void HomePaths_Realise(){
 			}
 #endif
 
-#if defined( POSIX )
+#if GDEF_OS_POSIX
 			path.clear();
 			path << DirectoryCleaned( g_get_home_dir() ) << prefix << "/";
 			g_qeglobals.m_userEnginePath = path.c_str();
@@ -432,18 +437,18 @@ void Paths_registerPreferencesPage(){
 class PathsDialog : public Dialog
 {
 public:
-GtkWindow* BuildDialog(){
-	GtkFrame* frame = create_dialog_frame( "Path settings", GTK_SHADOW_ETCHED_IN );
+ui::Window BuildDialog(){
+	auto frame = create_dialog_frame( "Path settings", ui::Shadow::ETCHED_IN );
 
-	GtkVBox* vbox2 = create_dialog_vbox( 0, 4 );
-	gtk_container_add( GTK_CONTAINER( frame ), GTK_WIDGET( vbox2 ) );
+	auto vbox2 = create_dialog_vbox( 0, 4 );
+	frame.add(vbox2);
 
 	{
-		PreferencesPage preferencesPage( *this, GTK_WIDGET( vbox2 ) );
+		PreferencesPage preferencesPage( *this, vbox2 );
 		Paths_constructPreferences( preferencesPage );
 	}
 
-	return create_simple_modal_dialog_window( "Engine Path Not Found", m_modal, GTK_WIDGET( frame ) );
+	return ui::Window(create_simple_modal_dialog_window( "Engine Path Not Found", m_modal, frame ));
 }
 };
 
@@ -513,6 +518,7 @@ void gamemode_set( const char* gamemode ){
 	}
 }
 
+
 #include "os/dir.h"
 
 class CLoadModule
@@ -534,11 +540,11 @@ void operator()( const char* name ) const {
 const char* const c_library_extension =
 #if defined( CMAKE_SHARED_MODULE_SUFFIX )
     CMAKE_SHARED_MODULE_SUFFIX
-#elif defined( WIN32 )
+#elif GDEF_OS_WINDOWS
 	"dll"
-#elif defined ( __APPLE__ )
+#elif GDEF_OS_MACOS
 	"dylib"
-#elif defined( __linux__ ) || defined ( __FreeBSD__ )
+#elif GDEF_OS_LINUX || GDEF_OS_BSD
 	"so"
 #endif
 ;
@@ -807,7 +813,7 @@ ChooseColour( const GetColourCallback& get, const SetColourCallback& set )
 void operator()(){
 	Vector3 colour;
 	m_get( colour );
-	color_dialog( GTK_WIDGET( MainFrame_getWindow() ), colour );
+	color_dialog( MainFrame_getWindow(), colour );
 	m_set( colour );
 }
 };
@@ -888,14 +894,14 @@ ColoursMenu() :
 
 ColoursMenu g_ColoursMenu;
 
-GtkMenuItem* create_colours_menu(){
-	GtkMenuItem* colours_menu_item = new_sub_menu_item_with_mnemonic( "Colors" );
-	GtkMenu* menu_in_menu = GTK_MENU( gtk_menu_item_get_submenu( colours_menu_item ) );
+ui::MenuItem create_colours_menu(){
+	auto colours_menu_item = new_sub_menu_item_with_mnemonic( "Colors" );
+	auto menu_in_menu = ui::Menu(GTK_MENU( gtk_menu_item_get_submenu( colours_menu_item ) ));
 	if ( g_Layout_enableDetachableMenus.m_value ) {
 		menu_tearoff( menu_in_menu );
 	}
 
-	GtkMenu* menu_3 = create_sub_menu_with_mnemonic( menu_in_menu, "Themes" );
+	auto menu_3 = create_sub_menu_with_mnemonic( menu_in_menu, "Themes" );
 	if ( g_Layout_enableDetachableMenus.m_value ) {
 		menu_tearoff( menu_3 );
 	}
@@ -943,42 +949,22 @@ void thunk_OnSleep(){
 	g_pParentWnd->OnSleep();
 }
 
-void OpenUpdateURL(){
-	// build the URL
-	StringOutputStream URL( 256 );
-	URL << "http://www.icculus.org/netradiant/?cmd=update&data=dlupdate&query_dlup=1";
-#ifdef WIN32
-	URL << "&OS_dlup=1";
-#elif defined( __APPLE__ )
-	URL << "&OS_dlup=2";
-#else
-	URL << "&OS_dlup=3";
-#endif
-	URL << "&Version_dlup=" RADIANT_VERSION;
-	g_GamesDialog.AddPacksURL( URL );
-	OpenURL( URL.c_str() );
-}
-
-// open the Q3Rad manual
 void OpenHelpURL(){
-	// at least on win32, AppPath + "docs/index.html"
-	StringOutputStream help( 256 );
-	help << AppPath_get() << "docs/index.html";
-	OpenURL( help.c_str() );
+	OpenURL( "https://gitlab.com/xonotic/xonotic/wikis/Mapping" );
 }
 
 void OpenBugReportURL(){
-	OpenURL( "http://www.icculus.org/netradiant/?cmd=bugs" );
+	OpenURL( "https://gitlab.com/xonotic/netradiant/issues" );
 }
 
 
-GtkWidget* g_page_console;
+ui::Widget g_page_console{ui::null};
 
 void Console_ToggleShow(){
 	GroupDialog_showPage( g_page_console );
 }
 
-GtkWidget* g_page_entity;
+ui::Widget g_page_entity{ui::null};
 
 void EntityInspector_ToggleShow(){
 	GroupDialog_showPage( g_page_entity );
@@ -1607,47 +1593,47 @@ guint s_qe_every_second_id = 0;
 
 void EverySecondTimer_enable(){
 	if ( s_qe_every_second_id == 0 ) {
-		s_qe_every_second_id = gtk_timeout_add( 1000, qe_every_second, 0 );
+		s_qe_every_second_id = g_timeout_add( 1000, qe_every_second, 0 );
 	}
 }
 
 void EverySecondTimer_disable(){
 	if ( s_qe_every_second_id != 0 ) {
-		gtk_timeout_remove( s_qe_every_second_id );
+		g_source_remove( s_qe_every_second_id );
 		s_qe_every_second_id = 0;
 	}
 }
 
-gint window_realize_remove_decoration( GtkWidget* widget, gpointer data ){
-	gdk_window_set_decorations( widget->window, (GdkWMDecoration)( GDK_DECOR_ALL | GDK_DECOR_MENU | GDK_DECOR_MINIMIZE | GDK_DECOR_MAXIMIZE ) );
+gint window_realize_remove_decoration( ui::Widget widget, gpointer data ){
+	gdk_window_set_decorations( gtk_widget_get_window(widget), (GdkWMDecoration)( GDK_DECOR_ALL | GDK_DECOR_MENU | GDK_DECOR_MINIMIZE | GDK_DECOR_MAXIMIZE ) );
 	return FALSE;
 }
 
 class WaitDialog
 {
 public:
-GtkWindow* m_window;
-GtkLabel* m_label;
+ui::Window m_window{ui::null};
+ui::Label m_label{ui::null};
 };
 
 WaitDialog create_wait_dialog( const char* title, const char* text ){
 	WaitDialog dialog;
 
-	dialog.m_window = create_floating_window( title, MainFrame_getWindow() );
+	dialog.m_window = MainFrame_getWindow().create_floating_window(title);
 	gtk_window_set_resizable( dialog.m_window, FALSE );
 	gtk_container_set_border_width( GTK_CONTAINER( dialog.m_window ), 0 );
 	gtk_window_set_position( dialog.m_window, GTK_WIN_POS_CENTER_ON_PARENT );
 
-	g_signal_connect( G_OBJECT( dialog.m_window ), "realize", G_CALLBACK( window_realize_remove_decoration ), 0 );
+	dialog.m_window.connect( "realize", G_CALLBACK( window_realize_remove_decoration ), 0 );
 
 	{
-		dialog.m_label = GTK_LABEL( gtk_label_new( text ) );
+		dialog.m_label = ui::Label( text );
 		gtk_misc_set_alignment( GTK_MISC( dialog.m_label ), 0.0, 0.5 );
 		gtk_label_set_justify( dialog.m_label, GTK_JUSTIFY_LEFT );
-		gtk_widget_show( GTK_WIDGET( dialog.m_label ) );
+		dialog.m_label.show();
 		gtk_widget_set_size_request( GTK_WIDGET( dialog.m_label ), 200, -1 );
 
-		gtk_container_add( GTK_CONTAINER( dialog.m_window ), GTK_WIDGET( dialog.m_label ) );
+		dialog.m_window.add(dialog.m_label);
 	}
 	return dialog;
 }
@@ -1691,8 +1677,8 @@ bool ScreenUpdates_Enabled(){
 }
 
 void ScreenUpdates_process(){
-	if ( redrawRequired() && GTK_WIDGET_VISIBLE( g_wait.m_window ) ) {
-		process_gui();
+	if ( redrawRequired() && g_wait.m_window.visible() ) {
+		ui::process();
 	}
 }
 
@@ -1701,7 +1687,7 @@ void ScreenUpdates_Disable( const char* message, const char* title ){
 	if ( g_wait_stack.empty() ) {
 		EverySecondTimer_disable();
 
-		process_gui();
+		ui::process();
 
 		bool isActiveApp = MainFrame_isActiveApp();
 
@@ -1709,12 +1695,12 @@ void ScreenUpdates_Disable( const char* message, const char* title ){
 		gtk_grab_add( GTK_WIDGET( g_wait.m_window ) );
 
 		if ( isActiveApp ) {
-			gtk_widget_show( GTK_WIDGET( g_wait.m_window ) );
+			g_wait.m_window.show();
 			ScreenUpdates_process();
 		}
 	}
-	else if ( GTK_WIDGET_VISIBLE( g_wait.m_window ) ) {
-		gtk_label_set_text( g_wait.m_label, message );
+	else if ( g_wait.m_window.visible() ) {
+		g_wait.m_label.text(message);
 		ScreenUpdates_process();
 	}
 	g_wait_stack.push_back( message );
@@ -1729,12 +1715,12 @@ void ScreenUpdates_Enable(){
 
 		gtk_grab_remove( GTK_WIDGET( g_wait.m_window ) );
 		destroy_floating_window( g_wait.m_window );
-		g_wait.m_window = 0;
+		g_wait.m_window = ui::Window{ui::null};
 
 		//gtk_window_present(MainFrame_getWindow());
 	}
-	else if ( GTK_WIDGET_VISIBLE( g_wait.m_window ) ) {
-		gtk_label_set_text( g_wait.m_label, g_wait_stack.back().c_str() );
+	else if ( g_wait.m_window.visible() ) {
+		g_wait.m_label.text(g_wait_stack.back().c_str());
 		ScreenUpdates_process();
 	}
 }
@@ -1800,10 +1786,10 @@ LatchedBool g_Layout_enablePluginToolbar( true, "Plugin Toolbar" );
 
 
 
-GtkMenuItem* create_file_menu(){
+ui::MenuItem create_file_menu(){
 	// File menu
-	GtkMenuItem* file_menu_item = new_sub_menu_item_with_mnemonic( "_File" );
-	GtkMenu* menu = GTK_MENU( gtk_menu_item_get_submenu( file_menu_item ) );
+	auto file_menu_item = new_sub_menu_item_with_mnemonic( "_File" );
+	auto menu = ui::Menu(GTK_MENU( gtk_menu_item_get_submenu( file_menu_item ) ));
 	if ( g_Layout_enableDetachableMenus.m_value ) {
 		menu_tearoff( menu );
 	}
@@ -1823,7 +1809,7 @@ GtkMenuItem* create_file_menu(){
 	create_menu_item_with_mnemonic( menu, "_Import...", "ImportMap" );
 	create_menu_item_with_mnemonic( menu, "_Save", "SaveMap" );
 	create_menu_item_with_mnemonic( menu, "Save _as...", "SaveMapAs" );
-	create_menu_item_with_mnemonic( menu, "Save s_elected...", "SaveSelected" );
+	create_menu_item_with_mnemonic( menu, "_Export selected...", "ExportSelected" );
 	menu_separator( menu );
 	create_menu_item_with_mnemonic( menu, "Save re_gion...", "SaveRegion" );
 	menu_separator( menu );
@@ -1835,16 +1821,15 @@ GtkMenuItem* create_file_menu(){
 	menu_separator( menu );
 	MRU_constructMenu( menu );
 	menu_separator( menu );
-	create_menu_item_with_mnemonic( menu, "Check for NetRadiant update (web)", "CheckForUpdate" ); // FIXME
 	create_menu_item_with_mnemonic( menu, "E_xit", "Exit" );
 
 	return file_menu_item;
 }
 
-GtkMenuItem* create_edit_menu(){
+ui::MenuItem create_edit_menu(){
 	// Edit menu
-	GtkMenuItem* edit_menu_item = new_sub_menu_item_with_mnemonic( "_Edit" );
-	GtkMenu* menu = GTK_MENU( gtk_menu_item_get_submenu( edit_menu_item ) );
+	auto edit_menu_item = new_sub_menu_item_with_mnemonic( "_Edit" );
+	auto menu = ui::Menu(GTK_MENU( gtk_menu_item_get_submenu( edit_menu_item ) ));
 	if ( g_Layout_enableDetachableMenus.m_value ) {
 		menu_tearoff( menu );
 	}
@@ -1866,7 +1851,7 @@ GtkMenuItem* create_edit_menu(){
 	create_menu_item_with_mnemonic( menu, "Select i_nside", "SelectInside" );
 	create_menu_item_with_mnemonic( menu, "Select _touching", "SelectTouching" );
 
-	GtkMenu* convert_menu = create_sub_menu_with_mnemonic( menu, "E_xpand Selection" );
+	auto convert_menu = create_sub_menu_with_mnemonic( menu, "E_xpand Selection" );
 	if ( g_Layout_enableDetachableMenus.m_value ) {
 		menu_tearoff( convert_menu );
 	}
@@ -1878,30 +1863,30 @@ GtkMenuItem* create_edit_menu(){
 	return edit_menu_item;
 }
 
-void fill_view_xy_top_menu( GtkMenu* menu ){
+void fill_view_xy_top_menu( ui::Menu menu ){
 	create_check_menu_item_with_mnemonic( menu, "XY (Top) View", "ToggleView" );
 }
 
 
-void fill_view_yz_side_menu( GtkMenu* menu ){
+void fill_view_yz_side_menu( ui::Menu menu ){
 	create_check_menu_item_with_mnemonic( menu, "YZ (Side) View", "ToggleSideView" );
 }
 
 
-void fill_view_xz_front_menu( GtkMenu* menu ){
+void fill_view_xz_front_menu( ui::Menu menu ){
 	create_check_menu_item_with_mnemonic( menu, "XZ (Front) View", "ToggleFrontView" );
 }
 
 
-GtkWidget* g_toggle_z_item = 0;
-GtkWidget* g_toggle_console_item = 0;
-GtkWidget* g_toggle_entity_item = 0;
-GtkWidget* g_toggle_entitylist_item = 0;
+ui::Widget g_toggle_z_item{ui::null};
+ui::Widget g_toggle_console_item{ui::null};
+ui::Widget g_toggle_entity_item{ui::null};
+ui::Widget g_toggle_entitylist_item{ui::null};
 
-GtkMenuItem* create_view_menu( MainFrame::EViewStyle style ){
+ui::MenuItem create_view_menu( MainFrame::EViewStyle style ){
 	// View menu
-	GtkMenuItem* view_menu_item = new_sub_menu_item_with_mnemonic( "Vie_w" );
-	GtkMenu* menu = GTK_MENU( gtk_menu_item_get_submenu( view_menu_item ) );
+	auto view_menu_item = new_sub_menu_item_with_mnemonic( "Vie_w" );
+	auto menu = ui::Menu(GTK_MENU( gtk_menu_item_get_submenu( view_menu_item ) ));
 	if ( g_Layout_enableDetachableMenus.m_value ) {
 		menu_tearoff( menu );
 	}
@@ -1926,7 +1911,7 @@ GtkMenuItem* create_view_menu( MainFrame::EViewStyle style ){
 
 	menu_separator( menu );
 	{
-		GtkMenu* camera_menu = create_sub_menu_with_mnemonic( menu, "Camera" );
+		auto camera_menu = create_sub_menu_with_mnemonic( menu, "Camera" );
 		if ( g_Layout_enableDetachableMenus.m_value ) {
 			menu_tearoff( camera_menu );
 		}
@@ -1945,7 +1930,7 @@ GtkMenuItem* create_view_menu( MainFrame::EViewStyle style ){
 	}
 	menu_separator( menu );
 	{
-		GtkMenu* orthographic_menu = create_sub_menu_with_mnemonic( menu, "Orthographic" );
+		auto orthographic_menu = create_sub_menu_with_mnemonic( menu, "Orthographic" );
 		if ( g_Layout_enableDetachableMenus.m_value ) {
 			menu_tearoff( orthographic_menu );
 		}
@@ -1965,7 +1950,7 @@ GtkMenuItem* create_view_menu( MainFrame::EViewStyle style ){
 	menu_separator( menu );
 
 	{
-		GtkMenu* menu_in_menu = create_sub_menu_with_mnemonic( menu, "Show" );
+		auto menu_in_menu = create_sub_menu_with_mnemonic( menu, "Show" );
 		if ( g_Layout_enableDetachableMenus.m_value ) {
 			menu_tearoff( menu_in_menu );
 		}
@@ -1980,7 +1965,7 @@ GtkMenuItem* create_view_menu( MainFrame::EViewStyle style ){
 	}
 
 	{
-		GtkMenu* menu_in_menu = create_sub_menu_with_mnemonic( menu, "Filter" );
+		auto menu_in_menu = create_sub_menu_with_mnemonic( menu, "Filter" );
 		if ( g_Layout_enableDetachableMenus.m_value ) {
 			menu_tearoff( menu_in_menu );
 		}
@@ -1988,7 +1973,7 @@ GtkMenuItem* create_view_menu( MainFrame::EViewStyle style ){
 	}
 	menu_separator( menu );
 	{
-		GtkMenu* menu_in_menu = create_sub_menu_with_mnemonic( menu, "Hide/Show" );
+		auto menu_in_menu = create_sub_menu_with_mnemonic( menu, "Hide/Show" );
 		if ( g_Layout_enableDetachableMenus.m_value ) {
 			menu_tearoff( menu_in_menu );
 		}
@@ -1997,7 +1982,7 @@ GtkMenuItem* create_view_menu( MainFrame::EViewStyle style ){
 	}
 	menu_separator( menu );
 	{
-		GtkMenu* menu_in_menu = create_sub_menu_with_mnemonic( menu, "Region" );
+		auto menu_in_menu = create_sub_menu_with_mnemonic( menu, "Region" );
 		if ( g_Layout_enableDetachableMenus.m_value ) {
 			menu_tearoff( menu_in_menu );
 		}
@@ -2012,16 +1997,16 @@ GtkMenuItem* create_view_menu( MainFrame::EViewStyle style ){
 	return view_menu_item;
 }
 
-GtkMenuItem* create_selection_menu(){
+ui::MenuItem create_selection_menu(){
 	// Selection menu
-	GtkMenuItem* selection_menu_item = new_sub_menu_item_with_mnemonic( "M_odify" );
-	GtkMenu* menu = GTK_MENU( gtk_menu_item_get_submenu( selection_menu_item ) );
+	auto selection_menu_item = new_sub_menu_item_with_mnemonic( "M_odify" );
+	auto menu = ui::Menu(GTK_MENU( gtk_menu_item_get_submenu( selection_menu_item ) ));
 	if ( g_Layout_enableDetachableMenus.m_value ) {
 		menu_tearoff( menu );
 	}
 
 	{
-		GtkMenu* menu_in_menu = create_sub_menu_with_mnemonic( menu, "Components" );
+		auto menu_in_menu = create_sub_menu_with_mnemonic( menu, "Components" );
 		if ( g_Layout_enableDetachableMenus.m_value ) {
 			menu_tearoff( menu_in_menu );
 		}
@@ -2033,7 +2018,7 @@ GtkMenuItem* create_selection_menu(){
 	menu_separator( menu );
 
 	{
-		GtkMenu* menu_in_menu = create_sub_menu_with_mnemonic( menu, "Nudge" );
+		auto menu_in_menu = create_sub_menu_with_mnemonic( menu, "Nudge" );
 		if ( g_Layout_enableDetachableMenus.m_value ) {
 			menu_tearoff( menu_in_menu );
 		}
@@ -2043,7 +2028,7 @@ GtkMenuItem* create_selection_menu(){
 		create_menu_item_with_mnemonic( menu_in_menu, "Nudge Down", "SelectNudgeDown" );
 	}
 	{
-		GtkMenu* menu_in_menu = create_sub_menu_with_mnemonic( menu, "Rotate" );
+		auto menu_in_menu = create_sub_menu_with_mnemonic( menu, "Rotate" );
 		if ( g_Layout_enableDetachableMenus.m_value ) {
 			menu_tearoff( menu_in_menu );
 		}
@@ -2052,7 +2037,7 @@ GtkMenuItem* create_selection_menu(){
 		create_menu_item_with_mnemonic( menu_in_menu, "Rotate Z", "RotateSelectionZ" );
 	}
 	{
-		GtkMenu* menu_in_menu = create_sub_menu_with_mnemonic( menu, "Flip" );
+		auto menu_in_menu = create_sub_menu_with_mnemonic( menu, "Flip" );
 		if ( g_Layout_enableDetachableMenus.m_value ) {
 			menu_tearoff( menu_in_menu );
 		}
@@ -2067,10 +2052,10 @@ GtkMenuItem* create_selection_menu(){
 	return selection_menu_item;
 }
 
-GtkMenuItem* create_bsp_menu(){
+ui::MenuItem create_bsp_menu(){
 	// BSP menu
-	GtkMenuItem* bsp_menu_item = new_sub_menu_item_with_mnemonic( "_Build" );
-	GtkMenu* menu = GTK_MENU( gtk_menu_item_get_submenu( bsp_menu_item ) );
+	auto bsp_menu_item = new_sub_menu_item_with_mnemonic( "_Build" );
+	auto menu = ui::Menu(GTK_MENU( gtk_menu_item_get_submenu( bsp_menu_item ) ));
 
 	if ( g_Layout_enableDetachableMenus.m_value ) {
 		menu_tearoff( menu );
@@ -2087,10 +2072,10 @@ GtkMenuItem* create_bsp_menu(){
 	return bsp_menu_item;
 }
 
-GtkMenuItem* create_grid_menu(){
+ui::MenuItem create_grid_menu(){
 	// Grid menu
-	GtkMenuItem* grid_menu_item = new_sub_menu_item_with_mnemonic( "_Grid" );
-	GtkMenu* menu = GTK_MENU( gtk_menu_item_get_submenu( grid_menu_item ) );
+	auto grid_menu_item = new_sub_menu_item_with_mnemonic( "_Grid" );
+	auto menu = ui::Menu(GTK_MENU( gtk_menu_item_get_submenu( grid_menu_item ) ));
 	if ( g_Layout_enableDetachableMenus.m_value ) {
 		menu_tearoff( menu );
 	}
@@ -2100,10 +2085,10 @@ GtkMenuItem* create_grid_menu(){
 	return grid_menu_item;
 }
 
-GtkMenuItem* create_misc_menu(){
+ui::MenuItem create_misc_menu(){
 	// Misc menu
-	GtkMenuItem* misc_menu_item = new_sub_menu_item_with_mnemonic( "M_isc" );
-	GtkMenu* menu = GTK_MENU( gtk_menu_item_get_submenu( misc_menu_item ) );
+	auto misc_menu_item = new_sub_menu_item_with_mnemonic( "M_isc" );
+	auto menu = ui::Menu(GTK_MENU( gtk_menu_item_get_submenu( misc_menu_item ) ));
 	if ( g_Layout_enableDetachableMenus.m_value ) {
 		menu_tearoff( menu );
 	}
@@ -2111,7 +2096,7 @@ GtkMenuItem* create_misc_menu(){
 #if 0
 	create_menu_item_with_mnemonic( menu, "_Benchmark", FreeCaller<GlobalCamera_Benchmark>() );
 #endif
-	gtk_container_add( GTK_CONTAINER( menu ), GTK_WIDGET( create_colours_menu() ) );
+    menu.add(create_colours_menu());
 
 	create_menu_item_with_mnemonic( menu, "Find brush...", "FindBrush" );
 	create_menu_item_with_mnemonic( menu, "Map Info...", "MapInfo" );
@@ -2121,10 +2106,10 @@ GtkMenuItem* create_misc_menu(){
 	return misc_menu_item;
 }
 
-GtkMenuItem* create_entity_menu(){
+ui::MenuItem create_entity_menu(){
 	// Brush menu
-	GtkMenuItem* entity_menu_item = new_sub_menu_item_with_mnemonic( "E_ntity" );
-	GtkMenu* menu = GTK_MENU( gtk_menu_item_get_submenu( entity_menu_item ) );
+	auto entity_menu_item = new_sub_menu_item_with_mnemonic( "E_ntity" );
+	auto menu = ui::Menu(GTK_MENU( gtk_menu_item_get_submenu( entity_menu_item ) ));
 	if ( g_Layout_enableDetachableMenus.m_value ) {
 		menu_tearoff( menu );
 	}
@@ -2134,10 +2119,10 @@ GtkMenuItem* create_entity_menu(){
 	return entity_menu_item;
 }
 
-GtkMenuItem* create_brush_menu(){
+ui::MenuItem create_brush_menu(){
 	// Brush menu
-	GtkMenuItem* brush_menu_item = new_sub_menu_item_with_mnemonic( "B_rush" );
-	GtkMenu* menu = GTK_MENU( gtk_menu_item_get_submenu( brush_menu_item ) );
+	auto brush_menu_item = new_sub_menu_item_with_mnemonic( "B_rush" );
+	auto menu = ui::Menu(GTK_MENU( gtk_menu_item_get_submenu( brush_menu_item ) ));
 	if ( g_Layout_enableDetachableMenus.m_value ) {
 		menu_tearoff( menu );
 	}
@@ -2147,10 +2132,10 @@ GtkMenuItem* create_brush_menu(){
 	return brush_menu_item;
 }
 
-GtkMenuItem* create_patch_menu(){
+ui::MenuItem create_patch_menu(){
 	// Curve menu
-	GtkMenuItem* patch_menu_item = new_sub_menu_item_with_mnemonic( "_Curve" );
-	GtkMenu* menu = GTK_MENU( gtk_menu_item_get_submenu( patch_menu_item ) );
+	auto patch_menu_item = new_sub_menu_item_with_mnemonic( "_Curve" );
+	auto menu = ui::Menu(GTK_MENU( gtk_menu_item_get_submenu( patch_menu_item ) ));
 	if ( g_Layout_enableDetachableMenus.m_value ) {
 		menu_tearoff( menu );
 	}
@@ -2160,10 +2145,10 @@ GtkMenuItem* create_patch_menu(){
 	return patch_menu_item;
 }
 
-GtkMenuItem* create_help_menu(){
+ui::MenuItem create_help_menu(){
 	// Help menu
-	GtkMenuItem* help_menu_item = new_sub_menu_item_with_mnemonic( "_Help" );
-	GtkMenu* menu = GTK_MENU( gtk_menu_item_get_submenu( help_menu_item ) );
+	auto help_menu_item = new_sub_menu_item_with_mnemonic( "_Help" );
+	auto menu = ui::Menu(GTK_MENU( gtk_menu_item_get_submenu( help_menu_item ) ));
 	if ( g_Layout_enableDetachableMenus.m_value ) {
 		menu_tearoff( menu );
 	}
@@ -2182,21 +2167,21 @@ GtkMenuItem* create_help_menu(){
 }
 
 GtkMenuBar* create_main_menu( MainFrame::EViewStyle style ){
-	GtkMenuBar* menu_bar = GTK_MENU_BAR( gtk_menu_bar_new() );
-	gtk_widget_show( GTK_WIDGET( menu_bar ) );
-
-	gtk_container_add( GTK_CONTAINER( menu_bar ), GTK_WIDGET( create_file_menu() ) );
-	gtk_container_add( GTK_CONTAINER( menu_bar ), GTK_WIDGET( create_edit_menu() ) );
-	gtk_container_add( GTK_CONTAINER( menu_bar ), GTK_WIDGET( create_view_menu( style ) ) );
-	gtk_container_add( GTK_CONTAINER( menu_bar ), GTK_WIDGET( create_selection_menu() ) );
-	gtk_container_add( GTK_CONTAINER( menu_bar ), GTK_WIDGET( create_bsp_menu() ) );
-	gtk_container_add( GTK_CONTAINER( menu_bar ), GTK_WIDGET( create_grid_menu() ) );
-	gtk_container_add( GTK_CONTAINER( menu_bar ), GTK_WIDGET( create_misc_menu() ) );
-	gtk_container_add( GTK_CONTAINER( menu_bar ), GTK_WIDGET( create_entity_menu() ) );
-	gtk_container_add( GTK_CONTAINER( menu_bar ), GTK_WIDGET( create_brush_menu() ) );
-	gtk_container_add( GTK_CONTAINER( menu_bar ), GTK_WIDGET( create_patch_menu() ) );
-	gtk_container_add( GTK_CONTAINER( menu_bar ), GTK_WIDGET( create_plugins_menu() ) );
-	gtk_container_add( GTK_CONTAINER( menu_bar ), GTK_WIDGET( create_help_menu() ) );
+	auto menu_bar = ui::MenuBar(GTK_MENU_BAR( gtk_menu_bar_new() ));
+	menu_bar.show();
+
+	menu_bar.add(create_file_menu());
+	menu_bar.add(create_edit_menu());
+	menu_bar.add(create_view_menu(style));
+	menu_bar.add(create_selection_menu());
+	menu_bar.add(create_bsp_menu());
+	menu_bar.add(create_grid_menu());
+	menu_bar.add(create_misc_menu());
+	menu_bar.add(create_entity_menu());
+	menu_bar.add(create_brush_menu());
+	menu_bar.add(create_patch_menu());
+	menu_bar.add(create_plugins_menu());
+	menu_bar.add(create_help_menu());
 
 	return menu_bar;
 }
@@ -2274,17 +2259,17 @@ void register_shortcuts(){
 	SelectByType_registerShortcuts();
 }
 
-void File_constructToolbar( GtkToolbar* toolbar ){
+void File_constructToolbar( ui::Toolbar toolbar ){
 	toolbar_append_button( toolbar, "Open an existing map (CTRL + O)", "file_open.png", "OpenMap" );
 	toolbar_append_button( toolbar, "Save the active map (CTRL + S)", "file_save.png", "SaveMap" );
 }
 
-void UndoRedo_constructToolbar( GtkToolbar* toolbar ){
+void UndoRedo_constructToolbar( ui::Toolbar toolbar ){
 	toolbar_append_button( toolbar, "Undo (CTRL + Z)", "undo.png", "Undo" );
 	toolbar_append_button( toolbar, "Redo (CTRL + Y)", "redo.png", "Redo" );
 }
 
-void RotateFlip_constructToolbar( GtkToolbar* toolbar ){
+void RotateFlip_constructToolbar( ui::Toolbar toolbar ){
 	toolbar_append_button( toolbar, "x-axis Flip", "brush_flipx.png", "MirrorSelectionX" );
 	toolbar_append_button( toolbar, "x-axis Rotate", "brush_rotatex.png", "RotateSelectionX" );
 	toolbar_append_button( toolbar, "y-axis Flip", "brush_flipy.png", "MirrorSelectionY" );
@@ -2293,33 +2278,33 @@ void RotateFlip_constructToolbar( GtkToolbar* toolbar ){
 	toolbar_append_button( toolbar, "z-axis Rotate", "brush_rotatez.png", "RotateSelectionZ" );
 }
 
-void Select_constructToolbar( GtkToolbar* toolbar ){
+void Select_constructToolbar( ui::Toolbar toolbar ){
 	toolbar_append_button( toolbar, "Select touching", "selection_selecttouching.png", "SelectTouching" );
 	toolbar_append_button( toolbar, "Select inside", "selection_selectinside.png", "SelectInside" );
 }
 
-void CSG_constructToolbar( GtkToolbar* toolbar ){
+void CSG_constructToolbar( ui::Toolbar toolbar ){
 	toolbar_append_button( toolbar, "CSG Subtract (SHIFT + U)", "selection_csgsubtract.png", "CSGSubtract" );
 	toolbar_append_button( toolbar, "CSG Merge (CTRL + U)", "selection_csgmerge.png", "CSGMerge" );
 	toolbar_append_button( toolbar, "Hollow", "selection_makehollow.png", "CSGHollow" );
 }
 
-void ComponentModes_constructToolbar( GtkToolbar* toolbar ){
+void ComponentModes_constructToolbar( ui::Toolbar toolbar ){
 	toolbar_append_toggle_button( toolbar, "Select Vertices (V)", "modify_vertices.png", "DragVertices" );
 	toolbar_append_toggle_button( toolbar, "Select Edges (E)", "modify_edges.png", "DragEdges" );
 	toolbar_append_toggle_button( toolbar, "Select Faces (F)", "modify_faces.png", "DragFaces" );
 }
 
-void Clipper_constructToolbar( GtkToolbar* toolbar ){
+void Clipper_constructToolbar( ui::Toolbar toolbar ){
 
 	toolbar_append_toggle_button( toolbar, "Clipper (X)", "view_clipper.png", "ToggleClipper" );
 }
 
-void XYWnd_constructToolbar( GtkToolbar* toolbar ){
+void XYWnd_constructToolbar( ui::Toolbar toolbar ){
 	toolbar_append_button( toolbar, "Change views", "view_change.png", "NextView" );
 }
 
-void Manipulators_constructToolbar( GtkToolbar* toolbar ){
+void Manipulators_constructToolbar( ui::Toolbar toolbar ){
 	toolbar_append_toggle_button( toolbar, "Translate (W)", "select_mousetranslate.png", "MouseTranslate" );
 	toolbar_append_toggle_button( toolbar, "Rotate (R)", "select_mouserotate.png", "MouseRotate" );
 	toolbar_append_toggle_button( toolbar, "Scale", "select_mousescale.png", "MouseScale" );
@@ -2328,69 +2313,75 @@ void Manipulators_constructToolbar( GtkToolbar* toolbar ){
 	Clipper_constructToolbar( toolbar );
 }
 
-GtkToolbar* create_main_toolbar( MainFrame::EViewStyle style ){
-	GtkToolbar* toolbar = GTK_TOOLBAR( gtk_toolbar_new() );
-	gtk_toolbar_set_orientation( toolbar, GTK_ORIENTATION_HORIZONTAL );
+ui::Toolbar create_main_toolbar( MainFrame::EViewStyle style ){
+	auto toolbar = ui::Toolbar(GTK_TOOLBAR( gtk_toolbar_new() ));
+	gtk_orientable_set_orientation( GTK_ORIENTABLE(toolbar), GTK_ORIENTATION_HORIZONTAL );
 	gtk_toolbar_set_style( toolbar, GTK_TOOLBAR_ICONS );
 
-	gtk_widget_show( GTK_WIDGET( toolbar ) );
+	toolbar.show();
+
+	auto space = [&]() {
+		auto btn = ui::Widget(GTK_WIDGET(gtk_separator_tool_item_new()));
+		btn.show();
+		toolbar.add(btn);
+	};
 
 	File_constructToolbar( toolbar );
 
-	gtk_toolbar_append_space( GTK_TOOLBAR( toolbar ) );
+	space();
 
 	UndoRedo_constructToolbar( toolbar );
 
-	gtk_toolbar_append_space( GTK_TOOLBAR( toolbar ) );
+	space();
 
 	RotateFlip_constructToolbar( toolbar );
 
-	gtk_toolbar_append_space( GTK_TOOLBAR( toolbar ) );
+	space();
 
 	Select_constructToolbar( toolbar );
 
-	gtk_toolbar_append_space( GTK_TOOLBAR( toolbar ) );
+	space();
 
 	CSG_constructToolbar( toolbar );
 
-	gtk_toolbar_append_space( GTK_TOOLBAR( toolbar ) );
+	space();
 
 	ComponentModes_constructToolbar( toolbar );
 
 	if ( style == MainFrame::eRegular || style == MainFrame::eRegularLeft || style == MainFrame::eFloating ) {
-		gtk_toolbar_append_space( GTK_TOOLBAR( toolbar ) );
+		space();
 
 		XYWnd_constructToolbar( toolbar );
 	}
 
-	gtk_toolbar_append_space( GTK_TOOLBAR( toolbar ) );
+	space();
 
 	CamWnd_constructToolbar( toolbar );
 
-	gtk_toolbar_append_space( GTK_TOOLBAR( toolbar ) );
+	space();
 
 	Manipulators_constructToolbar( toolbar );
 
 	if ( g_Layout_enablePatchToolbar.m_value ) {
-		gtk_toolbar_append_space( GTK_TOOLBAR( toolbar ) );
+		space();
 
 		Patch_constructToolbar( toolbar );
 	}
 
-	gtk_toolbar_append_space( GTK_TOOLBAR( toolbar ) );
+	space();
 
 	toolbar_append_toggle_button( toolbar, "Texture Lock (SHIFT +T)", "texture_lock.png", "TogTexLock" );
 
-	gtk_toolbar_append_space( GTK_TOOLBAR( toolbar ) );
+	space();
 
-	GtkButton* g_view_entities_button = toolbar_append_button( toolbar, "Entities (N)", "entities.png", "ToggleEntityInspector" );
-	GtkButton* g_view_console_button = toolbar_append_button( toolbar, "Console (O)", "console.png", "ToggleConsole" );
-	GtkButton* g_view_textures_button = toolbar_append_button( toolbar, "Texture Browser (T)", "texture_browser.png", "ToggleTextures" );
+	/*auto g_view_entities_button =*/ toolbar_append_button( toolbar, "Entities (N)", "entities.png", "ToggleEntityInspector" );
+	auto g_view_console_button = toolbar_append_button( toolbar, "Console (O)", "console.png", "ToggleConsole" );
+	auto g_view_textures_button = toolbar_append_button( toolbar, "Texture Browser (T)", "texture_browser.png", "ToggleTextures" );
 	// TODO: call light inspector
 	//GtkButton* g_view_lightinspector_button = toolbar_append_button(toolbar, "Light Inspector", "lightinspector.png", "ToggleLightInspector");
 
-	gtk_toolbar_append_space( GTK_TOOLBAR( toolbar ) );
-	GtkButton* g_refresh_models_button = toolbar_append_button( toolbar, "Refresh Models", "refresh_models.png", "RefreshReferences" );
+	space();
+	/*auto g_refresh_models_button =*/ toolbar_append_button( toolbar, "Refresh Models", "refresh_models.png", "RefreshReferences" );
 
 
 	// disable the console and texture button in the regular layouts
@@ -2402,36 +2393,36 @@ GtkToolbar* create_main_toolbar( MainFrame::EViewStyle style ){
 	return toolbar;
 }
 
-GtkWidget* create_main_statusbar( GtkWidget *pStatusLabel[c_count_status] ){
-	GtkTable* table = GTK_TABLE( gtk_table_new( 1, c_count_status, FALSE ) );
-	gtk_widget_show( GTK_WIDGET( table ) );
+ui::Widget create_main_statusbar( ui::Widget pStatusLabel[c_count_status] ){
+	auto table = ui::Table( 1, c_count_status, FALSE );
+	table.show();
 
 	{
-		GtkLabel* label = GTK_LABEL( gtk_label_new( "Label" ) );
+		auto label = ui::Label( "Label" );
 		gtk_misc_set_alignment( GTK_MISC( label ), 0, 0.5 );
 		gtk_misc_set_padding( GTK_MISC( label ), 4, 2 );
-		gtk_widget_show( GTK_WIDGET( label ) );
+		label.show();
 		gtk_table_attach_defaults( table, GTK_WIDGET( label ), 0, 1, 0, 1 );
-		pStatusLabel[c_command_status] = GTK_WIDGET( label );
+		pStatusLabel[c_command_status] = ui::Widget(GTK_WIDGET( label ));
 	}
 
 	for ( int i = 1; i < c_count_status; ++i )
 	{
-		GtkFrame* frame = GTK_FRAME( gtk_frame_new( 0 ) );
-		gtk_widget_show( GTK_WIDGET( frame ) );
+		auto frame = ui::Frame();
+		frame.show();
 		gtk_table_attach_defaults( table, GTK_WIDGET( frame ), i, i + 1, 0, 1 );
 		gtk_frame_set_shadow_type( frame, GTK_SHADOW_IN );
 
-		GtkLabel* label = GTK_LABEL( gtk_label_new( "Label" ) );
+		auto label = ui::Label( "Label" );
 		gtk_label_set_ellipsize( label, PANGO_ELLIPSIZE_END );
 		gtk_misc_set_alignment( GTK_MISC( label ), 0, 0.5 );
 		gtk_misc_set_padding( GTK_MISC( label ), 4, 2 );
-		gtk_widget_show( GTK_WIDGET( label ) );
-		gtk_container_add( GTK_CONTAINER( frame ), GTK_WIDGET( label ) );
-		pStatusLabel[i] = GTK_WIDGET( label );
+		label.show();
+		frame.add(label);
+		pStatusLabel[i] = ui::Widget(GTK_WIDGET( label ));
 	}
 
-	return GTK_WIDGET( table );
+	return ui::Widget(GTK_WIDGET( table ));
 }
 
 #if 0
@@ -2443,15 +2434,15 @@ class WindowFocusPrinter
 {
 const char* m_name;
 
-static gboolean frame_event( GtkWidget *widget, GdkEvent* event, WindowFocusPrinter* self ){
+static gboolean frame_event( ui::Widget widget, GdkEvent* event, WindowFocusPrinter* self ){
 	globalOutputStream() << self->m_name << " frame_event\n";
 	return FALSE;
 }
-static gboolean keys_changed( GtkWidget *widget, WindowFocusPrinter* self ){
+static gboolean keys_changed( ui::Widget widget, WindowFocusPrinter* self ){
 	globalOutputStream() << self->m_name << " keys_changed\n";
 	return FALSE;
 }
-static gboolean notify( GtkWindow* window, gpointer dummy, WindowFocusPrinter* self ){
+static gboolean notify( ui::Window window, gpointer dummy, WindowFocusPrinter* self ){
 	if ( gtk_window_is_active( window ) ) {
 		globalOutputStream() << self->m_name << " takes toplevel focus\n";
 	}
@@ -2464,11 +2455,11 @@ static gboolean notify( GtkWindow* window, gpointer dummy, WindowFocusPrinter* s
 public:
 WindowFocusPrinter( const char* name ) : m_name( name ){
 }
-void connect( GtkWindow* toplevel_window ){
-	g_signal_connect( G_OBJECT( toplevel_window ), "notify::has_toplevel_focus", G_CALLBACK( notify ), this );
-	g_signal_connect( G_OBJECT( toplevel_window ), "notify::is_active", G_CALLBACK( notify ), this );
-	g_signal_connect( G_OBJECT( toplevel_window ), "keys_changed", G_CALLBACK( keys_changed ), this );
-	g_signal_connect( G_OBJECT( toplevel_window ), "frame_event", G_CALLBACK( frame_event ), this );
+void connect( ui::Window toplevel_window ){
+	toplevel_window.connect( "notify::has_toplevel_focus", G_CALLBACK( notify ), this );
+	toplevel_window.connect( "notify::is_active", G_CALLBACK( notify ), this );
+	toplevel_window.connect( "keys_changed", G_CALLBACK( keys_changed ), this );
+	toplevel_window.connect( "frame_event", G_CALLBACK( frame_event ), this );
 }
 };
 
@@ -2478,16 +2469,16 @@ WindowFocusPrinter g_mainframeFocusPrinter( "mainframe" );
 
 class MainWindowActive
 {
-static gboolean notify( GtkWindow* window, gpointer dummy, MainWindowActive* self ){
-	if ( g_wait.m_window != 0 && gtk_window_is_active( window ) && !GTK_WIDGET_VISIBLE( g_wait.m_window ) ) {
-		gtk_widget_show( GTK_WIDGET( g_wait.m_window ) );
+static gboolean notify( ui::Window window, gpointer dummy, MainWindowActive* self ){
+	if ( g_wait.m_window && gtk_window_is_active( window ) && !g_wait.m_window.visible() ) {
+		g_wait.m_window.show();
 	}
 
 	return FALSE;
 }
 public:
-void connect( GtkWindow* toplevel_window ){
-	g_signal_connect( G_OBJECT( toplevel_window ), "notify::is-active", G_CALLBACK( notify ), this );
+void connect( ui::Window toplevel_window ){
+	toplevel_window.connect( "notify::is-active", G_CALLBACK( notify ), this );
 }
 };
 
@@ -2514,16 +2505,14 @@ void XYWindowMouseDown_disconnect( MouseEventHandlerId id ){
 
 MainFrame* g_pParentWnd = 0;
 
-GtkWindow* MainFrame_getWindow(){
-	if ( g_pParentWnd == 0 ) {
-		return 0;
-	}
-	return g_pParentWnd->m_window;
+ui::Window MainFrame_getWindow()
+{
+	return g_pParentWnd ? g_pParentWnd->m_window : ui::Window{ui::null};
 }
 
-std::vector<GtkWidget*> g_floating_windows;
+std::vector<ui::Widget> g_floating_windows;
 
-MainFrame::MainFrame() : m_window( 0 ), m_idleRedrawStatusText( RedrawStatusTextCaller( *this ) ){
+MainFrame::MainFrame() : m_idleRedrawStatusText( RedrawStatusTextCaller( *this ) ){
 	m_pXYWnd = 0;
 	m_pCamWnd = 0;
 	m_pZWnd = 0;
@@ -2531,9 +2520,8 @@ MainFrame::MainFrame() : m_window( 0 ), m_idleRedrawStatusText( RedrawStatusText
 	m_pXZWnd = 0;
 	m_pActiveXY = 0;
 
-	for ( int n = 0; n < c_count_status; n++ )
-	{
-		m_pStatusLabel[n] = 0;
+	for (auto &n : m_pStatusLabel) {
+        n = NULL;
 	}
 
 	m_bSleeping = false;
@@ -2544,16 +2532,16 @@ MainFrame::MainFrame() : m_window( 0 ), m_idleRedrawStatusText( RedrawStatusText
 MainFrame::~MainFrame(){
 	SaveWindowInfo();
 
-	gtk_widget_hide( GTK_WIDGET( m_window ) );
+	m_window.hide();
 
 	Shutdown();
 
-	for ( std::vector<GtkWidget*>::iterator i = g_floating_windows.begin(); i != g_floating_windows.end(); ++i )
+	for ( std::vector<ui::Widget>::iterator i = g_floating_windows.begin(); i != g_floating_windows.end(); ++i )
 	{
-		gtk_widget_destroy( *i );
+		i->destroy();
 	}
 
-	gtk_widget_destroy( GTK_WIDGET( m_window ) );
+	m_window.destroy();
 }
 
 void MainFrame::SetActiveXY( XYWnd* p ){
@@ -2615,7 +2603,7 @@ void MainFrame::CreateContexts(){
 #endif
 }
 
-#ifdef _DEBUG
+#if GDEF_DEBUG
 //#define DBG_SLEEP
 #endif
 
@@ -2673,8 +2661,8 @@ void MainFrame::OnSleep(){
 }
 
 
-GtkWindow* create_splash(){
-	GtkWindow* window = GTK_WINDOW( gtk_window_new( GTK_WINDOW_TOPLEVEL ) );
+ui::Window create_splash(){
+	ui::Window window = ui::Window( ui::window_type::TOP );
 	gtk_window_set_decorated( window, FALSE );
 	gtk_window_set_resizable( window, FALSE );
 	gtk_window_set_modal( window, TRUE );
@@ -2682,26 +2670,26 @@ GtkWindow* create_splash(){
 	gtk_window_set_position( window, GTK_WIN_POS_CENTER );
 	gtk_container_set_border_width( GTK_CONTAINER( window ), 0 );
 
-	GtkImage* image = new_local_image( "splash.png" );
-	gtk_widget_show( GTK_WIDGET( image ) );
-	gtk_container_add( GTK_CONTAINER( window ), GTK_WIDGET( image ) );
+	auto image = new_local_image( "splash.png" );
+	image.show();
+	window.add(image);
 
 	gtk_widget_set_size_request( GTK_WIDGET( window ), -1, -1 );
-	gtk_widget_show( GTK_WIDGET( window ) );
+	window.show();
 
 	return window;
 }
 
-static GtkWindow *splash_screen = 0;
+static ui::Window splash_screen{ui::null};
 
 void show_splash(){
 	splash_screen = create_splash();
 
-	process_gui();
+	ui::process();
 }
 
 void hide_splash(){
-	gtk_widget_destroy( GTK_WIDGET( splash_screen ) );
+	splash_screen.destroy();
 }
 
 WindowPositionTracker g_posCamWnd;
@@ -2709,7 +2697,7 @@ WindowPositionTracker g_posXYWnd;
 WindowPositionTracker g_posXZWnd;
 WindowPositionTracker g_posYZWnd;
 
-static gint mainframe_delete( GtkWidget *widget, GdkEvent *event, gpointer data ){
+static gint mainframe_delete( ui::Widget widget, GdkEvent *event, gpointer data ){
 	if ( ConfirmModified( "Exit Radiant" ) ) {
 		gtk_main_quit();
 	}
@@ -2718,24 +2706,24 @@ static gint mainframe_delete( GtkWidget *widget, GdkEvent *event, gpointer data
 }
 
 void MainFrame::Create(){
-	GtkWindow* window = GTK_WINDOW( gtk_window_new( GTK_WINDOW_TOPLEVEL ) );
+	ui::Window window = ui::Window( ui::window_type::TOP );
 
 	GlobalWindowObservers_connectTopLevel( window );
 
 	gtk_window_set_transient_for( splash_screen, window );
 
-#if !defined( WIN32 )
+#if !GDEF_OS_WINDOWS
 	{
 		GdkPixbuf* pixbuf = pixbuf_new_from_file_with_mask( "bitmaps/icon.png" );
 		if ( pixbuf != 0 ) {
 			gtk_window_set_icon( window, pixbuf );
-			gdk_pixbuf_unref( pixbuf );
+			g_object_unref( pixbuf );
 		}
 	}
 #endif
 
 	gtk_widget_add_events( GTK_WIDGET( window ), GDK_KEY_PRESS_MASK | GDK_KEY_RELEASE_MASK | GDK_FOCUS_CHANGE_MASK );
-	g_signal_connect( G_OBJECT( window ), "delete_event", G_CALLBACK( mainframe_delete ), this );
+	window.connect( "delete_event", G_CALLBACK( mainframe_delete ), this );
 
 	m_position_tracker.connect( window );
 
@@ -2746,11 +2734,11 @@ void MainFrame::Create(){
 
 	g_MainWindowActive.connect( window );
 
-	GetPlugInMgr().Init( GTK_WIDGET( window ) );
+	GetPlugInMgr().Init( window );
 
-	GtkWidget* vbox = gtk_vbox_new( FALSE, 0 );
-	gtk_container_add( GTK_CONTAINER( window ), vbox );
-	gtk_widget_show( vbox );
+	ui::Widget vbox = ui::VBox( FALSE, 0 );
+	window.add(vbox);
+	vbox.show();
 
 	global_accel_connect_window( window );
 
@@ -2764,13 +2752,13 @@ void MainFrame::Create(){
 	GtkToolbar* main_toolbar = create_main_toolbar( CurrentStyle() );
 	gtk_box_pack_start( GTK_BOX( vbox ), GTK_WIDGET( main_toolbar ), FALSE, FALSE, 0 );
 
-	GtkToolbar* plugin_toolbar = create_plugin_toolbar();
+	auto plugin_toolbar = create_plugin_toolbar();
 	if ( !g_Layout_enablePluginToolbar.m_value ) {
-		gtk_widget_hide( GTK_WIDGET( plugin_toolbar ) );
+		plugin_toolbar.hide();
 	}
 	gtk_box_pack_start( GTK_BOX( vbox ), GTK_WIDGET( plugin_toolbar ), FALSE, FALSE, 0 );
 
-	GtkWidget* main_statusbar = create_main_statusbar( m_pStatusLabel );
+	ui::Widget main_statusbar = create_main_statusbar(reinterpret_cast<ui::Widget *>(m_pStatusLabel));
 	gtk_box_pack_end( GTK_BOX( vbox ), main_statusbar, FALSE, TRUE, 2 );
 
 	GroupDialog_constructWindow( window );
@@ -2780,7 +2768,7 @@ void MainFrame::Create(){
 		g_page_console = GroupDialog_addPage( "Console", Console_constructWindow( GroupDialog_getWindow() ), RawStringExportCaller( "Console" ) );
 	}
 
-#ifdef WIN32
+#if GDEF_OS_WINDOWS
 	if ( g_multimon_globals.m_bStartOnPrimMon ) {
 		PositionWindowOnPrimaryScreen( g_layout_globals.m_position );
 		window_set_position( window, g_layout_globals.m_position );
@@ -2799,33 +2787,33 @@ void MainFrame::Create(){
 
 	m_window = window;
 
-	gtk_widget_show( GTK_WIDGET( window ) );
+	window.show();
 
 	if ( CurrentStyle() == eRegular || CurrentStyle() == eRegularLeft ) {
 		{
-			GtkWidget* vsplit = gtk_vpaned_new();
+			ui::Widget vsplit = ui::VPaned(ui::New);
 			m_vSplit = vsplit;
 			gtk_box_pack_start( GTK_BOX( vbox ), vsplit, TRUE, TRUE, 0 );
-			gtk_widget_show( vsplit );
+			vsplit.show();
 
 			// console
-			GtkWidget* console_window = Console_constructWindow( window );
+			ui::Widget console_window = Console_constructWindow( window );
 			gtk_paned_pack2( GTK_PANED( vsplit ), console_window, FALSE, TRUE );
 
 			{
-				GtkWidget* hsplit = gtk_hpaned_new();
-				gtk_widget_show( hsplit );
+				ui::Widget hsplit = ui::HPaned(ui::New);
+				hsplit.show();
 				m_hSplit = hsplit;
 				gtk_paned_add1( GTK_PANED( vsplit ), hsplit );
 
 				// xy
 				m_pXYWnd = new XYWnd();
 				m_pXYWnd->SetViewType( XY );
-				GtkWidget* xy_window = GTK_WIDGET( create_framed_widget( m_pXYWnd->GetWidget() ) );
+				ui::Widget xy_window = ui::Widget(GTK_WIDGET( create_framed_widget( m_pXYWnd->GetWidget() ) ));
 
 				{
-					GtkWidget* vsplit2 = gtk_vpaned_new();
-					gtk_widget_show( vsplit2 );
+					ui::Widget vsplit2 = ui::VPaned(ui::New);
+					vsplit2.show();
 					m_vSplit2 = vsplit2;
 
 					if ( CurrentStyle() == eRegular ) {
@@ -2869,26 +2857,26 @@ void MainFrame::Create(){
 	}
 	else if ( CurrentStyle() == eFloating ) {
 		{
-			GtkWindow* window = create_persistent_floating_window( "Camera", m_window );
+			ui::Window window = ui::Window(create_persistent_floating_window( "Camera", m_window ));
 			global_accel_connect_window( window );
 			g_posCamWnd.connect( window );
 
-			gtk_widget_show( GTK_WIDGET( window ) );
+			window.show();
 
 			m_pCamWnd = NewCamWnd();
 			GlobalCamera_setCamWnd( *m_pCamWnd );
 
 			{
-				GtkFrame* frame = create_framed_widget( CamWnd_getWidget( *m_pCamWnd ) );
-				gtk_container_add( GTK_CONTAINER( window ), GTK_WIDGET( frame ) );
+				auto frame = create_framed_widget( CamWnd_getWidget( *m_pCamWnd ) );
+				window.add(frame);
 			}
 			CamWnd_setParent( *m_pCamWnd, window );
 
-			g_floating_windows.push_back( GTK_WIDGET( window ) );
+			g_floating_windows.push_back( window );
 		}
 
 		{
-			GtkWindow* window = create_persistent_floating_window( ViewType_getTitle( XY ), m_window );
+			ui::Window window = ui::Window(create_persistent_floating_window( ViewType_getTitle( XY ), m_window ));
 			global_accel_connect_window( window );
 			g_posXYWnd.connect( window );
 
@@ -2898,16 +2886,16 @@ void MainFrame::Create(){
 
 
 			{
-				GtkFrame* frame = create_framed_widget( m_pXYWnd->GetWidget() );
-				gtk_container_add( GTK_CONTAINER( window ), GTK_WIDGET( frame ) );
+				auto frame = create_framed_widget( m_pXYWnd->GetWidget() );
+				window.add(frame);
 			}
 			XY_Top_Shown_Construct( window );
 
-			g_floating_windows.push_back( GTK_WIDGET( window ) );
+			g_floating_windows.push_back( window );
 		}
 
 		{
-			GtkWindow* window = create_persistent_floating_window( ViewType_getTitle( XZ ), m_window );
+			ui::Window window = ui::Window(create_persistent_floating_window( ViewType_getTitle( XZ ), m_window ));
 			global_accel_connect_window( window );
 			g_posXZWnd.connect( window );
 
@@ -2916,17 +2904,17 @@ void MainFrame::Create(){
 			m_pXZWnd->SetViewType( XZ );
 
 			{
-				GtkFrame* frame = create_framed_widget( m_pXZWnd->GetWidget() );
-				gtk_container_add( GTK_CONTAINER( window ), GTK_WIDGET( frame ) );
+				auto frame = create_framed_widget( m_pXZWnd->GetWidget() );
+				window.add(frame);
 			}
 
 			XZ_Front_Shown_Construct( window );
 
-			g_floating_windows.push_back( GTK_WIDGET( window ) );
+			g_floating_windows.push_back( window );
 		}
 
 		{
-			GtkWindow* window = create_persistent_floating_window( ViewType_getTitle( YZ ), m_window );
+			ui::Window window = ui::Window(create_persistent_floating_window( ViewType_getTitle( YZ ), m_window ));
 			global_accel_connect_window( window );
 			g_posYZWnd.connect( window );
 
@@ -2935,18 +2923,18 @@ void MainFrame::Create(){
 			m_pYZWnd->SetViewType( YZ );
 
 			{
-				GtkFrame* frame = create_framed_widget( m_pYZWnd->GetWidget() );
-				gtk_container_add( GTK_CONTAINER( window ), GTK_WIDGET( frame ) );
+				auto frame = create_framed_widget( m_pYZWnd->GetWidget() );
+				window.add(frame);
 			}
 
 			YZ_Side_Shown_Construct( window );
 
-			g_floating_windows.push_back( GTK_WIDGET( window ) );
+			g_floating_windows.push_back( window );
 		}
 
 		{
 			GtkFrame* frame = create_framed_widget( TextureBrowser_constructWindow( GroupDialog_getWindow() ) );
-			g_page_textures = GroupDialog_addPage( "Textures", GTK_WIDGET( frame ), TextureBrowserExportTitleCaller() );
+			g_page_textures = GroupDialog_addPage( "Textures", ui::Widget(GTK_WIDGET( frame )), TextureBrowserExportTitleCaller() );
 		}
 
 		GroupDialog_show();
@@ -2957,29 +2945,29 @@ void MainFrame::Create(){
 		GlobalCamera_setCamWnd( *m_pCamWnd );
 		CamWnd_setParent( *m_pCamWnd, window );
 
-		GtkWidget* camera = CamWnd_getWidget( *m_pCamWnd );
+		ui::Widget camera = CamWnd_getWidget( *m_pCamWnd );
 
 		m_pYZWnd = new XYWnd();
 		m_pYZWnd->SetViewType( YZ );
 
-		GtkWidget* yz = m_pYZWnd->GetWidget();
+		ui::Widget yz = m_pYZWnd->GetWidget();
 
 		m_pXYWnd = new XYWnd();
 		m_pXYWnd->SetViewType( XY );
 
-		GtkWidget* xy = m_pXYWnd->GetWidget();
+		ui::Widget xy = m_pXYWnd->GetWidget();
 
 		m_pXZWnd = new XYWnd();
 		m_pXZWnd->SetViewType( XZ );
 
-		GtkWidget* xz = m_pXZWnd->GetWidget();
+		ui::Widget xz = m_pXZWnd->GetWidget();
 
 		GtkHPaned* split = create_split_views( camera, yz, xy, xz );
 		gtk_box_pack_start( GTK_BOX( vbox ), GTK_WIDGET( split ), TRUE, TRUE, 0 );
 
 		{
 			GtkFrame* frame = create_framed_widget( TextureBrowser_constructWindow( window ) );
-			g_page_textures = GroupDialog_addPage( "Textures", GTK_WIDGET( frame ), TextureBrowserExportTitleCaller() );
+			g_page_textures = GroupDialog_addPage( "Textures", ui::Widget(GTK_WIDGET( frame )), TextureBrowserExportTitleCaller() );
 		}
 	}
 
@@ -3020,7 +3008,7 @@ void MainFrame::SaveWindowInfo(){
 
 	g_layout_globals.m_position = m_position_tracker.getPosition();
 
-	g_layout_globals.nState = gdk_window_get_state( GTK_WIDGET( m_window )->window );
+	g_layout_globals.nState = gdk_window_get_state( gtk_widget_get_window(GTK_WIDGET( m_window )) );
 }
 
 void MainFrame::Shutdown(){
@@ -3052,11 +3040,11 @@ void MainFrame::Shutdown(){
 }
 
 void MainFrame::RedrawStatusText(){
-	gtk_label_set_text( GTK_LABEL( m_pStatusLabel[c_command_status] ), m_command_status.c_str() );
-	gtk_label_set_text( GTK_LABEL( m_pStatusLabel[c_position_status] ), m_position_status.c_str() );
-	gtk_label_set_text( GTK_LABEL( m_pStatusLabel[c_brushcount_status] ), m_brushcount_status.c_str() );
-	gtk_label_set_text( GTK_LABEL( m_pStatusLabel[c_texture_status] ), m_texture_status.c_str() );
-	gtk_label_set_text( GTK_LABEL( m_pStatusLabel[c_grid_status] ), m_grid_status.c_str() );
+	ui::Label::from(m_pStatusLabel[c_command_status]).text(m_command_status.c_str());
+	ui::Label::from(m_pStatusLabel[c_position_status]).text(m_position_status.c_str());
+	ui::Label::from(m_pStatusLabel[c_brushcount_status]).text(m_brushcount_status.c_str());
+	ui::Label::from(m_pStatusLabel[c_texture_status]).text(m_texture_status.c_str());
+	ui::Label::from(m_pStatusLabel[c_grid_status]).text(m_grid_status.c_str());
 }
 
 void MainFrame::UpdateStatusText(){
@@ -3110,7 +3098,8 @@ void GlobalGL_sharedContextCreated(){
 	globalOutputStream() << "GL_VENDOR: " << reinterpret_cast<const char*>( glGetString( GL_VENDOR ) ) << "\n";
 	globalOutputStream() << "GL_RENDERER: " << reinterpret_cast<const char*>( glGetString( GL_RENDERER ) ) << "\n";
 	globalOutputStream() << "GL_VERSION: " << reinterpret_cast<const char*>( glGetString( GL_VERSION ) ) << "\n";
-	globalOutputStream() << "GL_EXTENSIONS: " << reinterpret_cast<const char*>( glGetString( GL_EXTENSIONS ) ) << "\n";
+    const auto extensions = reinterpret_cast<const char*>( glGetString(GL_EXTENSIONS ) );
+    globalOutputStream() << "GL_EXTENSIONS: " << (extensions ? extensions : "") << "\n";
 
 	QGL_sharedContextCreated( GlobalOpenGL() );
 
@@ -3119,7 +3108,7 @@ void GlobalGL_sharedContextCreated(){
 	GlobalShaderCache().realise();
 	Textures_Realise();
 
-#ifdef WIN32
+#if GDEF_OS_WINDOWS
 	/* win32 is dodgy here, just use courier new then */
 	g_font = glfont_create( "arial 9" );
 #else
@@ -3183,7 +3172,7 @@ void Layout_registerPreferencesPage(){
 #include "stringio.h"
 
 void MainFrame_Construct(){
-	GlobalCommands_insert( "OpenManual", FreeCaller<OpenHelpURL>(), Accelerator( GDK_F1 ) );
+	GlobalCommands_insert( "OpenManual", FreeCaller<OpenHelpURL>(), Accelerator( GDK_KEY_F1 ) );
 
 	GlobalCommands_insert( "Sleep", FreeCaller<thunk_OnSleep>(), Accelerator( 'P', (GdkModifierType)( GDK_SHIFT_MASK | GDK_CONTROL_MASK ) ) );
 	GlobalCommands_insert( "NewMap", FreeCaller<NewMap>() );
@@ -3191,11 +3180,10 @@ void MainFrame_Construct(){
 	GlobalCommands_insert( "ImportMap", FreeCaller<ImportMap>() );
 	GlobalCommands_insert( "SaveMap", FreeCaller<SaveMap>(), Accelerator( 'S', (GdkModifierType)GDK_CONTROL_MASK ) );
 	GlobalCommands_insert( "SaveMapAs", FreeCaller<SaveMapAs>() );
-	GlobalCommands_insert( "SaveSelected", FreeCaller<ExportMap>() );
+	GlobalCommands_insert( "ExportSelected", FreeCaller<ExportMap>() );
 	GlobalCommands_insert( "SaveRegion", FreeCaller<SaveRegion>() );
-	GlobalCommands_insert( "RefreshReferences", FreeCaller<RefreshReferences>() );
+	GlobalCommands_insert( "RefreshReferences", FreeCaller<VFS_Refresh>() );
 	GlobalCommands_insert( "ProjectSettings", FreeCaller<DoProjectSettings>() );
-	GlobalCommands_insert( "CheckForUpdate", FreeCaller<OpenUpdateURL>() );
 	GlobalCommands_insert( "Exit", FreeCaller<Exit>() );
 
 	GlobalCommands_insert( "Undo", FreeCaller<Undo>(), Accelerator( 'Z', (GdkModifierType)GDK_CONTROL_MASK ) );
@@ -3203,11 +3191,11 @@ void MainFrame_Construct(){
 	GlobalCommands_insert( "Copy", FreeCaller<Copy>(), Accelerator( 'C', (GdkModifierType)GDK_CONTROL_MASK ) );
 	GlobalCommands_insert( "Paste", FreeCaller<Paste>(), Accelerator( 'V', (GdkModifierType)GDK_CONTROL_MASK ) );
 	GlobalCommands_insert( "PasteToCamera", FreeCaller<PasteToCamera>(), Accelerator( 'V', (GdkModifierType)GDK_MOD1_MASK ) );
-	GlobalCommands_insert( "CloneSelection", FreeCaller<Selection_Clone>(), Accelerator( GDK_space ) );
-	GlobalCommands_insert( "CloneSelectionAndMakeUnique", FreeCaller<Selection_Clone_MakeUnique>(), Accelerator( GDK_space, (GdkModifierType)GDK_SHIFT_MASK ) );
-	GlobalCommands_insert( "DeleteSelection", FreeCaller<deleteSelection>(), Accelerator( GDK_BackSpace ) );
+	GlobalCommands_insert( "CloneSelection", FreeCaller<Selection_Clone>(), Accelerator( GDK_KEY_space ) );
+	GlobalCommands_insert( "CloneSelectionAndMakeUnique", FreeCaller<Selection_Clone_MakeUnique>(), Accelerator( GDK_KEY_space, (GdkModifierType)GDK_SHIFT_MASK ) );
+	GlobalCommands_insert( "DeleteSelection", FreeCaller<deleteSelection>(), Accelerator( GDK_KEY_BackSpace ) );
 	GlobalCommands_insert( "ParentSelection", FreeCaller<Scene_parentSelected>() );
-	GlobalCommands_insert( "UnSelectSelection", FreeCaller<Selection_Deselect>(), Accelerator( GDK_Escape ) );
+	GlobalCommands_insert( "UnSelectSelection", FreeCaller<Selection_Deselect>(), Accelerator( GDK_KEY_Escape ) );
 	GlobalCommands_insert( "InvertSelection", FreeCaller<Select_Invert>(), Accelerator( 'I' ) );
 	GlobalCommands_insert( "SelectInside", FreeCaller<Select_Inside>() );
 	GlobalCommands_insert( "SelectTouching", FreeCaller<Select_Touching>() );
@@ -3279,24 +3267,24 @@ void MainFrame_Construct(){
 
 	GlobalCommands_insert( "SelectAllOfType", FreeCaller<Select_AllOfType>(), Accelerator( 'A', (GdkModifierType)GDK_SHIFT_MASK ) );
 
-	GlobalCommands_insert( "TexRotateClock", FreeCaller<Texdef_RotateClockwise>(), Accelerator( GDK_Next, (GdkModifierType)GDK_SHIFT_MASK ) );
-	GlobalCommands_insert( "TexRotateCounter", FreeCaller<Texdef_RotateAntiClockwise>(), Accelerator( GDK_Prior, (GdkModifierType)GDK_SHIFT_MASK ) );
-	GlobalCommands_insert( "TexScaleUp", FreeCaller<Texdef_ScaleUp>(), Accelerator( GDK_Up, (GdkModifierType)GDK_CONTROL_MASK ) );
-	GlobalCommands_insert( "TexScaleDown", FreeCaller<Texdef_ScaleDown>(), Accelerator( GDK_Down, (GdkModifierType)GDK_CONTROL_MASK ) );
-	GlobalCommands_insert( "TexScaleLeft", FreeCaller<Texdef_ScaleLeft>(), Accelerator( GDK_Left, (GdkModifierType)GDK_CONTROL_MASK ) );
-	GlobalCommands_insert( "TexScaleRight", FreeCaller<Texdef_ScaleRight>(), Accelerator( GDK_Right, (GdkModifierType)GDK_CONTROL_MASK ) );
-	GlobalCommands_insert( "TexShiftUp", FreeCaller<Texdef_ShiftUp>(), Accelerator( GDK_Up, (GdkModifierType)GDK_SHIFT_MASK ) );
-	GlobalCommands_insert( "TexShiftDown", FreeCaller<Texdef_ShiftDown>(), Accelerator( GDK_Down, (GdkModifierType)GDK_SHIFT_MASK ) );
-	GlobalCommands_insert( "TexShiftLeft", FreeCaller<Texdef_ShiftLeft>(), Accelerator( GDK_Left, (GdkModifierType)GDK_SHIFT_MASK ) );
-	GlobalCommands_insert( "TexShiftRight", FreeCaller<Texdef_ShiftRight>(), Accelerator( GDK_Right, (GdkModifierType)GDK_SHIFT_MASK ) );
-
-	GlobalCommands_insert( "MoveSelectionDOWN", FreeCaller<Selection_MoveDown>(), Accelerator( GDK_KP_Subtract ) );
-	GlobalCommands_insert( "MoveSelectionUP", FreeCaller<Selection_MoveUp>(), Accelerator( GDK_KP_Add ) );
-
-	GlobalCommands_insert( "SelectNudgeLeft", FreeCaller<Selection_NudgeLeft>(), Accelerator( GDK_Left, (GdkModifierType)GDK_MOD1_MASK ) );
-	GlobalCommands_insert( "SelectNudgeRight", FreeCaller<Selection_NudgeRight>(), Accelerator( GDK_Right, (GdkModifierType)GDK_MOD1_MASK ) );
-	GlobalCommands_insert( "SelectNudgeUp", FreeCaller<Selection_NudgeUp>(), Accelerator( GDK_Up, (GdkModifierType)GDK_MOD1_MASK ) );
-	GlobalCommands_insert( "SelectNudgeDown", FreeCaller<Selection_NudgeDown>(), Accelerator( GDK_Down, (GdkModifierType)GDK_MOD1_MASK ) );
+	GlobalCommands_insert( "TexRotateClock", FreeCaller<Texdef_RotateClockwise>(), Accelerator( GDK_KEY_Next, (GdkModifierType)GDK_SHIFT_MASK ) );
+	GlobalCommands_insert( "TexRotateCounter", FreeCaller<Texdef_RotateAntiClockwise>(), Accelerator( GDK_KEY_Prior, (GdkModifierType)GDK_SHIFT_MASK ) );
+	GlobalCommands_insert( "TexScaleUp", FreeCaller<Texdef_ScaleUp>(), Accelerator( GDK_KEY_Up, (GdkModifierType)GDK_CONTROL_MASK ) );
+	GlobalCommands_insert( "TexScaleDown", FreeCaller<Texdef_ScaleDown>(), Accelerator( GDK_KEY_Down, (GdkModifierType)GDK_CONTROL_MASK ) );
+	GlobalCommands_insert( "TexScaleLeft", FreeCaller<Texdef_ScaleLeft>(), Accelerator( GDK_KEY_Left, (GdkModifierType)GDK_CONTROL_MASK ) );
+	GlobalCommands_insert( "TexScaleRight", FreeCaller<Texdef_ScaleRight>(), Accelerator( GDK_KEY_Right, (GdkModifierType)GDK_CONTROL_MASK ) );
+	GlobalCommands_insert( "TexShiftUp", FreeCaller<Texdef_ShiftUp>(), Accelerator( GDK_KEY_Up, (GdkModifierType)GDK_SHIFT_MASK ) );
+	GlobalCommands_insert( "TexShiftDown", FreeCaller<Texdef_ShiftDown>(), Accelerator( GDK_KEY_Down, (GdkModifierType)GDK_SHIFT_MASK ) );
+	GlobalCommands_insert( "TexShiftLeft", FreeCaller<Texdef_ShiftLeft>(), Accelerator( GDK_KEY_Left, (GdkModifierType)GDK_SHIFT_MASK ) );
+	GlobalCommands_insert( "TexShiftRight", FreeCaller<Texdef_ShiftRight>(), Accelerator( GDK_KEY_Right, (GdkModifierType)GDK_SHIFT_MASK ) );
+
+	GlobalCommands_insert( "MoveSelectionDOWN", FreeCaller<Selection_MoveDown>(), Accelerator( GDK_KEY_KP_Subtract ) );
+	GlobalCommands_insert( "MoveSelectionUP", FreeCaller<Selection_MoveUp>(), Accelerator( GDK_KEY_KP_Add ) );
+
+	GlobalCommands_insert( "SelectNudgeLeft", FreeCaller<Selection_NudgeLeft>(), Accelerator( GDK_KEY_Left, (GdkModifierType)GDK_MOD1_MASK ) );
+	GlobalCommands_insert( "SelectNudgeRight", FreeCaller<Selection_NudgeRight>(), Accelerator( GDK_KEY_Right, (GdkModifierType)GDK_MOD1_MASK ) );
+	GlobalCommands_insert( "SelectNudgeUp", FreeCaller<Selection_NudgeUp>(), Accelerator( GDK_KEY_Up, (GdkModifierType)GDK_MOD1_MASK ) );
+	GlobalCommands_insert( "SelectNudgeDown", FreeCaller<Selection_NudgeDown>(), Accelerator( GDK_KEY_Down, (GdkModifierType)GDK_MOD1_MASK ) );
 
 	Patch_registerCommands();
 	XYShow_registerCommands();
@@ -3326,11 +3314,11 @@ void MainFrame_Construct(){
 
 	{
 		const char* ENGINEPATH_ATTRIBUTE =
-#if defined( WIN32 )
+#if GDEF_OS_WINDOWS
 			"enginepath_win32"
-#elif defined( __APPLE__ )
+#elif GDEF_OS_MACOS
 			"enginepath_macos"
-#elif defined( __linux__ ) || defined ( __FreeBSD__ )
+#elif GDEF_OS_LINUX || GDEF_OS_BSD
 			"enginepath_linux"
 #else
 #error "unknown platform"