X-Git-Url: http://de.git.xonotic.org/?p=xonotic%2Fnetradiant.git;a=blobdiff_plain;f=radiant%2Fmainframe.cpp;h=2eed7bff0c9f6a935cd146ee0410680b0f210a04;hp=3dbad8f23bb098756fe2b34c21624806bf44fd40;hb=refs%2Fmerge-requests%2F79%2Fhead;hpb=980ee7fd1f5bd8c1625f05cc21a32bf3a9eca6fc

diff --git a/radiant/mainframe.cpp b/radiant/mainframe.cpp
index 3dbad8f2..2eed7bff 100644
--- a/radiant/mainframe.cpp
+++ b/radiant/mainframe.cpp
@@ -26,6 +26,7 @@
 //
 
 #include "mainframe.h"
+#include "globaldefs.h"
 
 #include <gtk/gtk.h>
 
@@ -148,6 +149,8 @@ void VFS_Refresh(){
 	QE_InitVFS();
 	GlobalFileSystem().refresh();
 	g_vfsInitialized = true;
+	// also refresg models
+	RefreshReferences();
 	// also refresh texture browser
 	TextureBrowser_RefreshShaders();
 }
@@ -178,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}};
@@ -195,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() ) ) {
@@ -206,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" );
@@ -245,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();
@@ -368,6 +371,59 @@ void setEnginePath( const char* path ){
 	}
 }
 
+// Pak Path
+
+CopiedString g_strPakPath[g_pakPathCount] = { "", "", "", "", "" };
+ModuleObservers g_pakPathObservers[g_pakPathCount];
+std::size_t g_pakpath_unrealised[g_pakPathCount] = { 1, 1, 1, 1, 1 };
+
+void Radiant_attachPakPathObserver( int num, ModuleObserver& observer ){
+	g_pakPathObservers[num].attach( observer );
+}
+
+void Radiant_detachPakPathObserver( int num, ModuleObserver& observer ){
+	g_pakPathObservers[num].detach( observer );
+}
+
+
+void PakPath_Realise( int num ){
+	if ( --g_pakpath_unrealised[num] == 0 ) {
+		g_pakPathObservers[num].realise();
+	}
+}
+
+const char* PakPath_get( int num ){
+	std::string message = "PakPath_get: pak path " + std::to_string(num) + " not realised";
+	ASSERT_MESSAGE( g_pakpath_unrealised[num] == 0, message.c_str() );
+	return g_strPakPath[num].c_str();
+}
+
+void PakPath_Unrealise( int num ){
+	if ( ++g_pakpath_unrealised[num] == 1 ) {
+		g_pakPathObservers[num].unrealise();
+	}
+}
+
+void setPakPath( int num, const char* path ){
+	if (!g_strcmp0( path, "")) {
+		g_strPakPath[num] = "";
+		return;
+	}
+
+	StringOutputStream buffer( 256 );
+	buffer << DirectoryCleaned( path );
+	if ( !path_equal( buffer.c_str(), g_strPakPath[num].c_str() ) ) {
+		std::string message = "Changing Pak Path " + std::to_string(num);
+		ScopeDisableScreenUpdates disableScreenUpdates( "Processing...", message.c_str() );
+
+		PakPath_Unrealise(num);
+
+		g_strPakPath[num] = buffer.c_str();
+
+		PakPath_Realise(num);
+	}
+}
+
 
 // App Path
 
@@ -411,23 +467,105 @@ const char* GameToolsPath_get(){
 	return g_strGameToolsPath.c_str();
 }
 
-void EnginePathImport( CopiedString& self, const char* value ){
+struct EnginePath {
+	static void Export(const CopiedString &self, const Callback<void(const char *)> &returnz) {
+		returnz(self.c_str());
+	}
+
+	static void Import(CopiedString &self, const char *value) {
 	setEnginePath( value );
 }
-typedef ReferenceCaller1<CopiedString, const char*, EnginePathImport> EnginePathImportCaller;
+};
+
+struct PakPath0 {
+	static void Export( const CopiedString &self, const Callback<void(const char*)> &returnz ) {
+		returnz( self.c_str() );
+	}
+
+	static void Import( CopiedString &self, const char *value ) {
+		setPakPath( 0, value );
+	}
+};
+struct PakPath1 {
+	static void Export( const CopiedString &self, const Callback<void(const char*)> &returnz ) {
+		returnz( self.c_str() );
+	}
+
+	static void Import( CopiedString &self, const char *value ) {
+		setPakPath( 1, value );
+	}
+};
+struct PakPath2 {
+	static void Export( const CopiedString &self, const Callback<void(const char*)> &returnz ) {
+		returnz( self.c_str() );
+	}
+
+	static void Import( CopiedString &self, const char *value ) {
+		setPakPath( 2, value );
+	}
+};
+struct PakPath3 {
+	static void Export( const CopiedString &self, const Callback<void(const char*)> &returnz ) {
+		returnz( self.c_str() );
+	}
+
+	static void Import( CopiedString &self, const char *value ) {
+		setPakPath( 3, value );
+	}
+};
+struct PakPath4 {
+	static void Export( const CopiedString &self, const Callback<void(const char*)> &returnz ) {
+		returnz( self.c_str() );
+	}
+
+	static void Import( CopiedString &self, const char *value ) {
+		setPakPath( 4, value );
+	}
+};
+
+bool g_disableEnginePath = false;
+bool g_disableHomePath = false;
 
 void Paths_constructPreferences( PreferencesPage& page ){
-	page.appendPathEntry( "Engine Path", true,
-						  StringImportCallback( EnginePathImportCaller( g_strEnginePath ) ),
-						  StringExportCallback( StringExportCaller( g_strEnginePath ) )
-						  );
+	page.appendPathEntry( "Engine Path", true, make_property<EnginePath>(g_strEnginePath) );
+
+	page.appendCheckBox(
+		"", "Do not use Engine Path",
+		g_disableEnginePath
+		);
+
+	page.appendCheckBox(
+		"", "Do not use Home Path",
+		g_disableHomePath
+		);
+
+	for ( int i = 0; i < g_pakPathCount; i++ ) {
+		std::string label = "Pak Path " + std::to_string(i);
+		switch (i) {
+			case 0:
+			page.appendPathEntry( label.c_str(), true, make_property<PakPath0>( g_strPakPath[i] ) );
+			break;
+			case 1:
+			page.appendPathEntry( label.c_str(), true, make_property<PakPath1>( g_strPakPath[i] ) );
+			break;
+			case 2:
+			page.appendPathEntry( label.c_str(), true, make_property<PakPath2>( g_strPakPath[i] ) );
+			break;
+			case 3:
+			page.appendPathEntry( label.c_str(), true, make_property<PakPath3>( g_strPakPath[i] ) );
+			break;
+			case 4:
+			page.appendPathEntry( label.c_str(), true, make_property<PakPath4>( g_strPakPath[i] ) );
+			break;
+		}
+	}
 }
 void Paths_constructPage( PreferenceGroup& group ){
 	PreferencesPage page( group.createPage( "Paths", "Path Settings" ) );
 	Paths_constructPreferences( page );
 }
 void Paths_registerPreferencesPage(){
-	PreferencesDialog_addSettingsPage( FreeCaller1<PreferenceGroup&, Paths_constructPage>() );
+	PreferencesDialog_addSettingsPage( makeCallbackF(Paths_constructPage) );
 }
 
 
@@ -441,7 +579,7 @@ ui::Window BuildDialog(){
 	frame.add(vbox2);
 
 	{
-		PreferencesPage preferencesPage( *this, ui::Widget(GTK_WIDGET( vbox2 )) );
+		PreferencesPage preferencesPage( *this, vbox2 );
 		Paths_constructPreferences( preferencesPage );
 	}
 
@@ -518,36 +656,27 @@ void gamemode_set( const char* gamemode ){
 
 #include "os/dir.h"
 
-class CLoadModule
-{
-const char* m_path;
-public:
-CLoadModule( const char* path ) : m_path( path ){
-}
-void operator()( const char* name ) const {
-	char fullname[1024];
-	ASSERT_MESSAGE( strlen( m_path ) + strlen( name ) < 1024, "" );
-	strcpy( fullname, m_path );
-	strcat( fullname, name );
-	globalOutputStream() << "Found '" << fullname << "'\n";
-	GlobalModuleServer_loadModule( fullname );
-}
-};
-
 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
 ;
 
 void Radiant_loadModules( const char* path ){
-	Directory_forEach( path, MatchFileExtension<CLoadModule>( c_library_extension, CLoadModule( path ) ) );
+	Directory_forEach(path, matchFileExtension(c_library_extension, [&](const char *name) {
+		char fullname[1024];
+		ASSERT_MESSAGE(strlen(path) + strlen(name) < 1024, "");
+		strcpy(fullname, path);
+		strcat(fullname, name);
+		globalOutputStream() << "Found '" << fullname << "'\n";
+		GlobalModuleServer_loadModule(fullname);
+	}));
 }
 
 void Radiant_loadModulesFromRoot( const char* directory ){
@@ -796,8 +925,8 @@ void ColorScheme_Ydnar(){
 	XY_UpdateAllWindows();
 }
 
-typedef Callback1<Vector3&> GetColourCallback;
-typedef Callback1<const Vector3&> SetColourCallback;
+typedef Callback<void(Vector3&)> GetColourCallback;
+typedef Callback<void(const Vector3&)> SetColourCallback;
 
 class ChooseColour
 {
@@ -820,37 +949,37 @@ void operator()(){
 void Colour_get( const Vector3& colour, Vector3& other ){
 	other = colour;
 }
-typedef ConstReferenceCaller1<Vector3, Vector3&, Colour_get> ColourGetCaller;
+typedef ConstReferenceCaller<Vector3, void(Vector3&), Colour_get> ColourGetCaller;
 
 void Colour_set( Vector3& colour, const Vector3& other ){
 	colour = other;
 	SceneChangeNotify();
 }
-typedef ReferenceCaller1<Vector3, const Vector3&, Colour_set> ColourSetCaller;
+typedef ReferenceCaller<Vector3, void(const Vector3&), Colour_set> ColourSetCaller;
 
 void BrushColour_set( const Vector3& other ){
 	g_xywindow_globals.color_brushes = other;
 	SetWorldspawnColour( g_xywindow_globals.color_brushes );
 	SceneChangeNotify();
 }
-typedef FreeCaller1<const Vector3&, BrushColour_set> BrushColourSetCaller;
+typedef FreeCaller<void(const Vector3&), BrushColour_set> BrushColourSetCaller;
 
 void ClipperColour_set( const Vector3& other ){
 	g_xywindow_globals.color_clipper = other;
 	Brush_clipperColourChanged();
 	SceneChangeNotify();
 }
-typedef FreeCaller1<const Vector3&, ClipperColour_set> ClipperColourSetCaller;
+typedef FreeCaller<void(const Vector3&), ClipperColour_set> ClipperColourSetCaller;
 
 void TextureBrowserColour_get( Vector3& other ){
 	other = TextureBrowser_getBackgroundColour( GlobalTextureBrowser() );
 }
-typedef FreeCaller1<Vector3&, TextureBrowserColour_get> TextureBrowserColourGetCaller;
+typedef FreeCaller<void(Vector3&), TextureBrowserColour_get> TextureBrowserColourGetCaller;
 
 void TextureBrowserColour_set( const Vector3& other ){
 	TextureBrowser_setBackgroundColour( GlobalTextureBrowser(), other );
 }
-typedef FreeCaller1<const Vector3&, TextureBrowserColour_set> TextureBrowserColourSetCaller;
+typedef FreeCaller<void(const Vector3&), TextureBrowserColour_set> TextureBrowserColourSetCaller;
 
 
 class ColoursMenu
@@ -893,7 +1022,7 @@ ColoursMenu g_ColoursMenu;
 
 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 ) ));
+	auto menu_in_menu = ui::Menu::from( gtk_menu_item_get_submenu( colours_menu_item ) );
 	if ( g_Layout_enableDetachableMenus.m_value ) {
 		menu_tearoff( menu_in_menu );
 	}
@@ -955,13 +1084,13 @@ void OpenBugReportURL(){
 }
 
 
-ui::Widget g_page_console;
+ui::Widget g_page_console{ui::null};
 
 void Console_ToggleShow(){
 	GroupDialog_showPage( g_page_console );
 }
 
-ui::Widget g_page_entity;
+ui::Widget g_page_entity{ui::null};
 
 void EntityInspector_ToggleShow(){
 	GroupDialog_showPage( g_page_entity );
@@ -1005,24 +1134,24 @@ template<bool( *BoolFunction ) ( )>
 class BoolFunctionExport
 {
 public:
-static void apply( const BoolImportCallback& importCallback ){
+static void apply( const Callback<void(bool)> & importCallback ){
 	importCallback( BoolFunction() );
 }
 };
 
-typedef FreeCaller1<const BoolImportCallback&, &BoolFunctionExport<EdgeMode>::apply> EdgeModeApplyCaller;
+typedef FreeCaller<void(const Callback<void(bool)> &), &BoolFunctionExport<EdgeMode>::apply> EdgeModeApplyCaller;
 EdgeModeApplyCaller g_edgeMode_button_caller;
-BoolExportCallback g_edgeMode_button_callback( g_edgeMode_button_caller );
+Callback<void(const Callback<void(bool)> &)> g_edgeMode_button_callback( g_edgeMode_button_caller );
 ToggleItem g_edgeMode_button( g_edgeMode_button_callback );
 
-typedef FreeCaller1<const BoolImportCallback&, &BoolFunctionExport<VertexMode>::apply> VertexModeApplyCaller;
+typedef FreeCaller<void(const Callback<void(bool)> &), &BoolFunctionExport<VertexMode>::apply> VertexModeApplyCaller;
 VertexModeApplyCaller g_vertexMode_button_caller;
-BoolExportCallback g_vertexMode_button_callback( g_vertexMode_button_caller );
+Callback<void(const Callback<void(bool)> &)> g_vertexMode_button_callback( g_vertexMode_button_caller );
 ToggleItem g_vertexMode_button( g_vertexMode_button_callback );
 
-typedef FreeCaller1<const BoolImportCallback&, &BoolFunctionExport<FaceMode>::apply> FaceModeApplyCaller;
+typedef FreeCaller<void(const Callback<void(bool)> &), &BoolFunctionExport<FaceMode>::apply> FaceModeApplyCaller;
 FaceModeApplyCaller g_faceMode_button_caller;
-BoolExportCallback g_faceMode_button_callback( g_faceMode_button_caller );
+Callback<void(const Callback<void(bool)> &)> g_faceMode_button_callback( g_faceMode_button_caller );
 ToggleItem g_faceMode_button( g_faceMode_button_callback );
 
 void ComponentModeChanged(){
@@ -1296,44 +1425,44 @@ void Selection_NudgeRight(){
 }
 
 
-void TranslateToolExport( const BoolImportCallback& importCallback ){
+void TranslateToolExport( const Callback<void(bool)> & importCallback ){
 	importCallback( GlobalSelectionSystem().ManipulatorMode() == SelectionSystem::eTranslate );
 }
 
-void RotateToolExport( const BoolImportCallback& importCallback ){
+void RotateToolExport( const Callback<void(bool)> & importCallback ){
 	importCallback( GlobalSelectionSystem().ManipulatorMode() == SelectionSystem::eRotate );
 }
 
-void ScaleToolExport( const BoolImportCallback& importCallback ){
+void ScaleToolExport( const Callback<void(bool)> & importCallback ){
 	importCallback( GlobalSelectionSystem().ManipulatorMode() == SelectionSystem::eScale );
 }
 
-void DragToolExport( const BoolImportCallback& importCallback ){
+void DragToolExport( const Callback<void(bool)> & importCallback ){
 	importCallback( GlobalSelectionSystem().ManipulatorMode() == SelectionSystem::eDrag );
 }
 
-void ClipperToolExport( const BoolImportCallback& importCallback ){
+void ClipperToolExport( const Callback<void(bool)> & importCallback ){
 	importCallback( GlobalSelectionSystem().ManipulatorMode() == SelectionSystem::eClip );
 }
 
-FreeCaller1<const BoolImportCallback&, TranslateToolExport> g_translatemode_button_caller;
-BoolExportCallback g_translatemode_button_callback( g_translatemode_button_caller );
+FreeCaller<void(const Callback<void(bool)> &), TranslateToolExport> g_translatemode_button_caller;
+Callback<void(const Callback<void(bool)> &)> g_translatemode_button_callback( g_translatemode_button_caller );
 ToggleItem g_translatemode_button( g_translatemode_button_callback );
 
-FreeCaller1<const BoolImportCallback&, RotateToolExport> g_rotatemode_button_caller;
-BoolExportCallback g_rotatemode_button_callback( g_rotatemode_button_caller );
+FreeCaller<void(const Callback<void(bool)> &), RotateToolExport> g_rotatemode_button_caller;
+Callback<void(const Callback<void(bool)> &)> g_rotatemode_button_callback( g_rotatemode_button_caller );
 ToggleItem g_rotatemode_button( g_rotatemode_button_callback );
 
-FreeCaller1<const BoolImportCallback&, ScaleToolExport> g_scalemode_button_caller;
-BoolExportCallback g_scalemode_button_callback( g_scalemode_button_caller );
+FreeCaller<void(const Callback<void(bool)> &), ScaleToolExport> g_scalemode_button_caller;
+Callback<void(const Callback<void(bool)> &)> g_scalemode_button_callback( g_scalemode_button_caller );
 ToggleItem g_scalemode_button( g_scalemode_button_callback );
 
-FreeCaller1<const BoolImportCallback&, DragToolExport> g_dragmode_button_caller;
-BoolExportCallback g_dragmode_button_callback( g_dragmode_button_caller );
+FreeCaller<void(const Callback<void(bool)> &), DragToolExport> g_dragmode_button_caller;
+Callback<void(const Callback<void(bool)> &)> g_dragmode_button_callback( g_dragmode_button_caller );
 ToggleItem g_dragmode_button( g_dragmode_button_callback );
 
-FreeCaller1<const BoolImportCallback&, ClipperToolExport> g_clipper_button_caller;
-BoolExportCallback g_clipper_button_callback( g_clipper_button_caller );
+FreeCaller<void(const Callback<void(bool)> &), ClipperToolExport> g_clipper_button_caller;
+Callback<void(const Callback<void(bool)> &)> g_clipper_button_callback( g_clipper_button_caller );
 ToggleItem g_clipper_button( g_clipper_button_callback );
 
 void ToolChanged(){
@@ -1610,7 +1739,7 @@ class WaitDialog
 {
 public:
 ui::Window m_window{ui::null};
-ui::Label m_label{(GtkLabel *) nullptr};
+ui::Label m_label{ui::null};
 };
 
 WaitDialog create_wait_dialog( const char* title, const char* text ){
@@ -1628,7 +1757,7 @@ WaitDialog create_wait_dialog( const char* title, const char* text ){
 		gtk_misc_set_alignment( GTK_MISC( dialog.m_label ), 0.0, 0.5 );
 		gtk_label_set_justify( dialog.m_label, GTK_JUSTIFY_LEFT );
 		dialog.m_label.show();
-		gtk_widget_set_size_request( GTK_WIDGET( dialog.m_label ), 200, -1 );
+		dialog.m_label.dimensions(200, -1);
 
 		dialog.m_window.add(dialog.m_label);
 	}
@@ -1656,7 +1785,7 @@ bool MainFrame_isActiveApp(){
 	for ( GList* i = list; i != 0; i = g_list_next( i ) )
 	{
 		//globalOutputStream() << "toplevel.. ";
-		if ( gtk_window_is_active( GTK_WINDOW( i->data ) ) ) {
+		if ( gtk_window_is_active( ui::Window::from( i->data ) ) ) {
 			//globalOutputStream() << "is active\n";
 			return true;
 		}
@@ -1674,7 +1803,7 @@ bool ScreenUpdates_Enabled(){
 }
 
 void ScreenUpdates_process(){
-	if ( redrawRequired() && gtk_widget_get_visible( g_wait.m_window ) ) {
+	if ( redrawRequired() && g_wait.m_window.visible() ) {
 		ui::process();
 	}
 }
@@ -1689,15 +1818,15 @@ void ScreenUpdates_Disable( const char* message, const char* title ){
 		bool isActiveApp = MainFrame_isActiveApp();
 
 		g_wait = create_wait_dialog( title, message );
-		gtk_grab_add( GTK_WIDGET( g_wait.m_window ) );
+		gtk_grab_add( g_wait.m_window  );
 
 		if ( isActiveApp ) {
 			g_wait.m_window.show();
 			ScreenUpdates_process();
 		}
 	}
-	else if ( gtk_widget_get_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 );
@@ -1708,16 +1837,16 @@ void ScreenUpdates_Enable(){
 	g_wait_stack.pop_back();
 	if ( g_wait_stack.empty() ) {
 		EverySecondTimer_enable();
-		//gtk_widget_set_sensitive(GTK_WIDGET(MainFrame_getWindow()), TRUE);
+		//gtk_widget_set_sensitive(MainFrame_getWindow(), TRUE);
 
-		gtk_grab_remove( GTK_WIDGET( g_wait.m_window ) );
+		gtk_grab_remove( g_wait.m_window  );
 		destroy_floating_window( g_wait.m_window );
 		g_wait.m_window = ui::Window{ui::null};
 
 		//gtk_window_present(MainFrame_getWindow());
 	}
-	else if ( gtk_widget_get_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();
 	}
 }
@@ -1776,17 +1905,17 @@ void ClipperChangeNotify(){
 }
 
 
-LatchedInt g_Layout_viewStyle( 0, "Window Layout" );
-LatchedBool g_Layout_enableDetachableMenus( true, "Detachable Menus" );
-LatchedBool g_Layout_enablePatchToolbar( true, "Patch Toolbar" );
-LatchedBool g_Layout_enablePluginToolbar( true, "Plugin Toolbar" );
+LatchedValue<int> g_Layout_viewStyle( 0, "Window Layout" );
+LatchedValue<bool> g_Layout_enableDetachableMenus( true, "Detachable Menus" );
+LatchedValue<bool> g_Layout_enablePatchToolbar( true, "Patch Toolbar" );
+LatchedValue<bool> g_Layout_enablePluginToolbar( true, "Plugin Toolbar" );
 
 
 
 ui::MenuItem create_file_menu(){
 	// File menu
 	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 ) ));
+	auto menu = ui::Menu::from( gtk_menu_item_get_submenu( file_menu_item ) );
 	if ( g_Layout_enableDetachableMenus.m_value ) {
 		menu_tearoff( menu );
 	}
@@ -1826,7 +1955,7 @@ ui::MenuItem create_file_menu(){
 ui::MenuItem create_edit_menu(){
 	// Edit menu
 	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 ) ));
+	auto menu = ui::Menu::from( gtk_menu_item_get_submenu( edit_menu_item ) );
 	if ( g_Layout_enableDetachableMenus.m_value ) {
 		menu_tearoff( menu );
 	}
@@ -1875,15 +2004,15 @@ void fill_view_xz_front_menu( ui::Menu menu ){
 }
 
 
-ui::Widget g_toggle_z_item;
-ui::Widget g_toggle_console_item;
-ui::Widget g_toggle_entity_item;
-ui::Widget g_toggle_entitylist_item;
+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};
 
 ui::MenuItem create_view_menu( MainFrame::EViewStyle style ){
 	// View menu
 	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 ) ));
+	auto menu = ui::Menu::from( gtk_menu_item_get_submenu( view_menu_item ) );
 	if ( g_Layout_enableDetachableMenus.m_value ) {
 		menu_tearoff( menu );
 	}
@@ -1997,7 +2126,7 @@ ui::MenuItem create_view_menu( MainFrame::EViewStyle style ){
 ui::MenuItem create_selection_menu(){
 	// Selection menu
 	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 ) ));
+	auto menu = ui::Menu::from( gtk_menu_item_get_submenu( selection_menu_item ) );
 	if ( g_Layout_enableDetachableMenus.m_value ) {
 		menu_tearoff( menu );
 	}
@@ -2052,7 +2181,7 @@ ui::MenuItem create_selection_menu(){
 ui::MenuItem create_bsp_menu(){
 	// BSP menu
 	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 ) ));
+	auto menu = ui::Menu::from( gtk_menu_item_get_submenu( bsp_menu_item ) );
 
 	if ( g_Layout_enableDetachableMenus.m_value ) {
 		menu_tearoff( menu );
@@ -2072,7 +2201,7 @@ ui::MenuItem create_bsp_menu(){
 ui::MenuItem create_grid_menu(){
 	// Grid menu
 	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 ) ));
+	auto menu = ui::Menu::from( gtk_menu_item_get_submenu( grid_menu_item ) );
 	if ( g_Layout_enableDetachableMenus.m_value ) {
 		menu_tearoff( menu );
 	}
@@ -2085,28 +2214,28 @@ ui::MenuItem create_grid_menu(){
 ui::MenuItem create_misc_menu(){
 	// Misc menu
 	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 ) ));
+	auto menu = ui::Menu::from( gtk_menu_item_get_submenu( misc_menu_item ) );
 	if ( g_Layout_enableDetachableMenus.m_value ) {
 		menu_tearoff( menu );
 	}
 
 #if 0
-	create_menu_item_with_mnemonic( menu, "_Benchmark", FreeCaller<GlobalCamera_Benchmark>() );
+	create_menu_item_with_mnemonic( menu, "_Benchmark", makeCallbackF(GlobalCamera_Benchmark) );
 #endif
     menu.add(create_colours_menu());
 
 	create_menu_item_with_mnemonic( menu, "Find brush...", "FindBrush" );
 	create_menu_item_with_mnemonic( menu, "Map Info...", "MapInfo" );
 	// http://zerowing.idsoftware.com/bugzilla/show_bug.cgi?id=394
-//  create_menu_item_with_mnemonic(menu, "_Print XY View", FreeCaller<WXY_Print>());
-	create_menu_item_with_mnemonic( menu, "_Background select", FreeCaller<WXY_BackgroundSelect>() );
+//  create_menu_item_with_mnemonic(menu, "_Print XY View", FreeCaller<void(), WXY_Print>());
+	create_menu_item_with_mnemonic( menu, "_Background select", makeCallbackF(WXY_BackgroundSelect) );
 	return misc_menu_item;
 }
 
 ui::MenuItem create_entity_menu(){
 	// Brush menu
 	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 ) ));
+	auto menu = ui::Menu::from( gtk_menu_item_get_submenu( entity_menu_item ) );
 	if ( g_Layout_enableDetachableMenus.m_value ) {
 		menu_tearoff( menu );
 	}
@@ -2119,7 +2248,7 @@ ui::MenuItem create_entity_menu(){
 ui::MenuItem create_brush_menu(){
 	// Brush menu
 	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 ) ));
+	auto menu = ui::Menu::from( gtk_menu_item_get_submenu( brush_menu_item ) );
 	if ( g_Layout_enableDetachableMenus.m_value ) {
 		menu_tearoff( menu );
 	}
@@ -2132,7 +2261,7 @@ ui::MenuItem create_brush_menu(){
 ui::MenuItem create_patch_menu(){
 	// Curve menu
 	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 ) ));
+	auto menu = ui::Menu::from( gtk_menu_item_get_submenu( patch_menu_item ) );
 	if ( g_Layout_enableDetachableMenus.m_value ) {
 		menu_tearoff( menu );
 	}
@@ -2145,7 +2274,7 @@ ui::MenuItem create_patch_menu(){
 ui::MenuItem create_help_menu(){
 	// Help menu
 	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 ) ));
+	auto menu = ui::Menu::from( gtk_menu_item_get_submenu( help_menu_item ) );
 	if ( g_Layout_enableDetachableMenus.m_value ) {
 		menu_tearoff( menu );
 	}
@@ -2156,15 +2285,15 @@ ui::MenuItem create_help_menu(){
 	// it will take care of hooking the Sys_OpenURL calls etc.
 	create_game_help_menu( menu );
 
-	create_menu_item_with_mnemonic( menu, "Bug report", FreeCaller<OpenBugReportURL>() );
-	create_menu_item_with_mnemonic( menu, "Shortcuts list", FreeCaller<DoCommandListDlg>() );
-	create_menu_item_with_mnemonic( menu, "_About", FreeCaller<DoAbout>() );
+	create_menu_item_with_mnemonic( menu, "Bug report", makeCallbackF(OpenBugReportURL) );
+	create_menu_item_with_mnemonic( menu, "Shortcuts list", makeCallbackF(DoCommandListDlg) );
+	create_menu_item_with_mnemonic( menu, "_About", makeCallbackF(DoAbout) );
 
 	return help_menu_item;
 }
 
-GtkMenuBar* create_main_menu( MainFrame::EViewStyle style ){
-	auto menu_bar = ui::MenuBar(GTK_MENU_BAR( gtk_menu_bar_new() ));
+ui::MenuBar create_main_menu( MainFrame::EViewStyle style ){
+	auto menu_bar = ui::MenuBar::from( gtk_menu_bar_new() );
 	menu_bar.show();
 
 	menu_bar.add(create_file_menu());
@@ -2311,14 +2440,14 @@ void Manipulators_constructToolbar( ui::Toolbar toolbar ){
 }
 
 ui::Toolbar create_main_toolbar( MainFrame::EViewStyle style ){
-	auto toolbar = ui::Toolbar(GTK_TOOLBAR( gtk_toolbar_new() ));
+	auto toolbar = ui::Toolbar::from( gtk_toolbar_new() );
 	gtk_orientable_set_orientation( GTK_ORIENTABLE(toolbar), GTK_ORIENTATION_HORIZONTAL );
 	gtk_toolbar_set_style( toolbar, GTK_TOOLBAR_ICONS );
 
 	toolbar.show();
 
 	auto space = [&]() {
-		auto btn = ui::Widget(GTK_WIDGET(gtk_separator_tool_item_new()));
+		auto btn = ui::ToolItem::from(gtk_separator_tool_item_new());
 		btn.show();
 		toolbar.add(btn);
 	};
@@ -2383,8 +2512,8 @@ ui::Toolbar create_main_toolbar( MainFrame::EViewStyle style ){
 
 	// disable the console and texture button in the regular layouts
 	if ( style == MainFrame::eRegular || style == MainFrame::eRegularLeft ) {
-		gtk_widget_set_sensitive( GTK_WIDGET( g_view_console_button ), FALSE );
-		gtk_widget_set_sensitive( GTK_WIDGET( g_view_textures_button ), FALSE );
+		gtk_widget_set_sensitive( g_view_console_button , FALSE );
+		gtk_widget_set_sensitive( g_view_textures_button , FALSE );
 	}
 
 	return toolbar;
@@ -2399,15 +2528,15 @@ ui::Widget create_main_statusbar( ui::Widget pStatusLabel[c_count_status] ){
 		gtk_misc_set_alignment( GTK_MISC( label ), 0, 0.5 );
 		gtk_misc_set_padding( GTK_MISC( label ), 4, 2 );
 		label.show();
-		gtk_table_attach_defaults( table, GTK_WIDGET( label ), 0, 1, 0, 1 );
-		pStatusLabel[c_command_status] = ui::Widget(GTK_WIDGET( label ));
+		table.attach(label, {0, 1, 0, 1});
+		pStatusLabel[c_command_status] = ui::Widget(label );
 	}
 
-	for ( int i = 1; i < c_count_status; ++i )
+	for (unsigned int i = 1; (int) i < c_count_status; ++i)
 	{
 		auto frame = ui::Frame();
 		frame.show();
-		gtk_table_attach_defaults( table, GTK_WIDGET( frame ), i, i + 1, 0, 1 );
+		table.attach(frame, {i, i + 1, 0, 1});
 		gtk_frame_set_shadow_type( frame, GTK_SHADOW_IN );
 
 		auto label = ui::Label( "Label" );
@@ -2416,10 +2545,10 @@ ui::Widget create_main_statusbar( ui::Widget pStatusLabel[c_count_status] ){
 		gtk_misc_set_padding( GTK_MISC( label ), 4, 2 );
 		label.show();
 		frame.add(label);
-		pStatusLabel[i] = ui::Widget(GTK_WIDGET( label ));
+		pStatusLabel[i] = ui::Widget(label );
 	}
 
-	return ui::Widget(GTK_WIDGET( table ));
+	return ui::Widget(table );
 }
 
 #if 0
@@ -2467,7 +2596,7 @@ WindowFocusPrinter g_mainframeFocusPrinter( "mainframe" );
 class MainWindowActive
 {
 static gboolean notify( ui::Window window, gpointer dummy, MainWindowActive* self ){
-	if ( g_wait.m_window && gtk_window_is_active( window ) && !gtk_widget_get_visible( g_wait.m_window ) ) {
+	if ( g_wait.m_window && gtk_window_is_active( window ) && !g_wait.m_window.visible() ) {
 		g_wait.m_window.show();
 	}
 
@@ -2509,7 +2638,7 @@ ui::Window MainFrame_getWindow()
 
 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;
@@ -2517,9 +2646,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] = ui::root;
+	for (auto &n : m_pStatusLabel) {
+        n = NULL;
 	}
 
 	m_bSleeping = false;
@@ -2530,16 +2658,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<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 ){
@@ -2601,7 +2729,7 @@ void MainFrame::CreateContexts(){
 #endif
 }
 
-#ifdef _DEBUG
+#if GDEF_DEBUG
 //#define DBG_SLEEP
 #endif
 
@@ -2660,19 +2788,19 @@ void MainFrame::OnSleep(){
 
 
 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 );
+	auto 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);
 	gtk_window_set_default_size( window, -1, -1 );
 	gtk_window_set_position( window, GTK_WIN_POS_CENTER );
-	gtk_container_set_border_width( GTK_CONTAINER( window ), 0 );
+	gtk_container_set_border_width(window, 0);
 
 	auto image = new_local_image( "splash.png" );
 	image.show();
 	window.add(image);
 
-	gtk_widget_set_size_request( GTK_WIDGET( window ), -1, -1 );
+	window.dimensions(-1, -1);
 	window.show();
 
 	return window;
@@ -2687,7 +2815,7 @@ void show_splash(){
 }
 
 void hide_splash(){
-	gtk_widget_destroy( GTK_WIDGET( splash_screen ) );
+	splash_screen.destroy();
 }
 
 WindowPositionTracker g_posCamWnd;
@@ -2710,7 +2838,7 @@ void MainFrame::Create(){
 
 	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 ) {
@@ -2720,7 +2848,7 @@ void MainFrame::Create(){
 	}
 #endif
 
-	gtk_widget_add_events( GTK_WIDGET( window ), GDK_KEY_PRESS_MASK | GDK_KEY_RELEASE_MASK | GDK_FOCUS_CHANGE_MASK );
+	gtk_widget_add_events( window , GDK_KEY_PRESS_MASK | GDK_KEY_RELEASE_MASK | GDK_FOCUS_CHANGE_MASK );
 	window.connect( "delete_event", G_CALLBACK( mainframe_delete ), this );
 
 	m_position_tracker.connect( window );
@@ -2734,7 +2862,7 @@ void MainFrame::Create(){
 
 	GetPlugInMgr().Init( window );
 
-	ui::Widget vbox = ui::VBox( FALSE, 0 );
+	auto vbox = ui::VBox( FALSE, 0 );
 	window.add(vbox);
 	vbox.show();
 
@@ -2744,20 +2872,20 @@ void MainFrame::Create(){
 
 	register_shortcuts();
 
-	GtkMenuBar* main_menu = create_main_menu( CurrentStyle() );
-	gtk_box_pack_start( GTK_BOX( vbox ), GTK_WIDGET( main_menu ), FALSE, FALSE, 0 );
+    auto main_menu = create_main_menu( CurrentStyle() );
+	vbox.pack_start( main_menu, FALSE, FALSE, 0 );
 
-	GtkToolbar* main_toolbar = create_main_toolbar( CurrentStyle() );
-	gtk_box_pack_start( GTK_BOX( vbox ), GTK_WIDGET( main_toolbar ), FALSE, FALSE, 0 );
+    auto main_toolbar = create_main_toolbar( CurrentStyle() );
+	vbox.pack_start( 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 );
+	vbox.pack_start( plugin_toolbar, FALSE, FALSE, 0 );
 
-	ui::Widget main_statusbar = create_main_statusbar( m_pStatusLabel );
-	gtk_box_pack_end( GTK_BOX( vbox ), main_statusbar, FALSE, TRUE, 2 );
+	ui::Widget main_statusbar = create_main_statusbar(reinterpret_cast<ui::Widget *>(m_pStatusLabel));
+	vbox.pack_end(main_statusbar, FALSE, TRUE, 2);
 
 	GroupDialog_constructWindow( window );
 	g_page_entity = GroupDialog_addPage( "Entities", EntityInspector_constructWindow( GroupDialog_getWindow() ), RawStringExportCaller( "Entities" ) );
@@ -2766,7 +2894,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 );
@@ -2789,9 +2917,9 @@ void MainFrame::Create(){
 
 	if ( CurrentStyle() == eRegular || CurrentStyle() == eRegularLeft ) {
 		{
-			ui::Widget vsplit = ui::VPaned();
+			ui::Widget vsplit = ui::VPaned(ui::New);
 			m_vSplit = vsplit;
-			gtk_box_pack_start( GTK_BOX( vbox ), vsplit, TRUE, TRUE, 0 );
+			vbox.pack_start( vsplit, TRUE, TRUE, 0 );
 			vsplit.show();
 
 			// console
@@ -2799,7 +2927,7 @@ void MainFrame::Create(){
 			gtk_paned_pack2( GTK_PANED( vsplit ), console_window, FALSE, TRUE );
 
 			{
-				ui::Widget hsplit = ui::HPaned();
+				ui::Widget hsplit = ui::HPaned(ui::New);
 				hsplit.show();
 				m_hSplit = hsplit;
 				gtk_paned_add1( GTK_PANED( vsplit ), hsplit );
@@ -2807,10 +2935,10 @@ void MainFrame::Create(){
 				// xy
 				m_pXYWnd = new XYWnd();
 				m_pXYWnd->SetViewType( XY );
-				ui::Widget xy_window = ui::Widget(GTK_WIDGET( create_framed_widget( m_pXYWnd->GetWidget() ) ));
+				ui::Widget xy_window = ui::Widget(create_framed_widget( m_pXYWnd->GetWidget( ) ));
 
 				{
-					ui::Widget vsplit2 = ui::VPaned();
+					ui::Widget vsplit2 = ui::VPaned(ui::New);
 					vsplit2.show();
 					m_vSplit2 = vsplit2;
 
@@ -2829,14 +2957,14 @@ void MainFrame::Create(){
 					m_pCamWnd = NewCamWnd();
 					GlobalCamera_setCamWnd( *m_pCamWnd );
 					CamWnd_setParent( *m_pCamWnd, window );
-					GtkFrame* camera_window = create_framed_widget( CamWnd_getWidget( *m_pCamWnd ) );
+					auto camera_window = create_framed_widget( CamWnd_getWidget( *m_pCamWnd ) );
 
-					gtk_paned_add1( GTK_PANED( vsplit2 ), GTK_WIDGET( camera_window ) );
+					gtk_paned_add1( GTK_PANED( vsplit2 ), camera_window  );
 
 					// textures
-					GtkFrame* texture_window = create_framed_widget( TextureBrowser_constructWindow( window ) );
+					auto texture_window = create_framed_widget( TextureBrowser_constructWindow( window ) );
 
-					gtk_paned_add2( GTK_PANED( vsplit2 ), GTK_WIDGET( texture_window ) );
+					gtk_paned_add2( GTK_PANED( vsplit2 ), texture_window  );
 				}
 			}
 		}
@@ -2931,8 +3059,8 @@ void MainFrame::Create(){
 		}
 
 		{
-			GtkFrame* frame = create_framed_widget( TextureBrowser_constructWindow( GroupDialog_getWindow() ) );
-			g_page_textures = GroupDialog_addPage( "Textures", ui::Widget(GTK_WIDGET( frame )), TextureBrowserExportTitleCaller() );
+			auto frame = create_framed_widget( TextureBrowser_constructWindow( GroupDialog_getWindow() ) );
+			g_page_textures = GroupDialog_addPage( "Textures", frame, TextureBrowserExportTitleCaller() );
 		}
 
 		GroupDialog_show();
@@ -2960,12 +3088,12 @@ void MainFrame::Create(){
 
 		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 );
+        auto split = create_split_views( camera, yz, xy, xz );
+		vbox.pack_start( split, TRUE, TRUE, 0 );
 
 		{
-			GtkFrame* frame = create_framed_widget( TextureBrowser_constructWindow( window ) );
-			g_page_textures = GroupDialog_addPage( "Textures", ui::Widget(GTK_WIDGET( frame )), TextureBrowserExportTitleCaller() );
+            auto frame = create_framed_widget( TextureBrowser_constructWindow( window ) );
+			g_page_textures = GroupDialog_addPage( "Textures", frame, TextureBrowserExportTitleCaller() );
 		}
 	}
 
@@ -2978,7 +3106,7 @@ void MainFrame::Create(){
 	SetActiveXY( m_pXYWnd );
 
 	AddGridChangeCallback( SetGridStatusCaller( *this ) );
-	AddGridChangeCallback( ReferenceCaller<MainFrame, XY_UpdateAllWindows>( *this ) );
+	AddGridChangeCallback( ReferenceCaller<MainFrame, void(), XY_UpdateAllWindows>( *this ) );
 
 	g_defaultToolMode = DragMode;
 	g_defaultToolMode();
@@ -3006,7 +3134,7 @@ void MainFrame::SaveWindowInfo(){
 
 	g_layout_globals.m_position = m_position_tracker.getPosition();
 
-	g_layout_globals.nState = gdk_window_get_state( gtk_widget_get_window(GTK_WIDGET( m_window )) );
+	g_layout_globals.nState = gdk_window_get_state( gtk_widget_get_window(m_window ) );
 }
 
 void MainFrame::Shutdown(){
@@ -3038,11 +3166,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(){
@@ -3096,7 +3224,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() );
 
@@ -3105,11 +3234,11 @@ 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
-	GtkSettings *settings = gtk_settings_get_default();
+	auto settings = gtk_settings_get_default();
 	gchar *fontname;
 	g_object_get( settings, "gtk-font-name", &fontname, NULL );
 	g_font = glfont_create( fontname );
@@ -3132,26 +3261,22 @@ void Layout_constructPreferences( PreferencesPage& page ){
 		page.appendRadioIcons(
 			"Window Layout",
 			STRING_ARRAY_RANGE( layouts ),
-			LatchedIntImportCaller( g_Layout_viewStyle ),
-			IntExportCaller( g_Layout_viewStyle.m_latched )
+			make_property( g_Layout_viewStyle )
 			);
 	}
 	page.appendCheckBox(
 		"", "Detachable Menus",
-		LatchedBoolImportCaller( g_Layout_enableDetachableMenus ),
-		BoolExportCaller( g_Layout_enableDetachableMenus.m_latched )
+		make_property( g_Layout_enableDetachableMenus )
 		);
 	if ( !string_empty( g_pGameDescription->getKeyValue( "no_patch" ) ) ) {
 		page.appendCheckBox(
 			"", "Patch Toolbar",
-			LatchedBoolImportCaller( g_Layout_enablePatchToolbar ),
-			BoolExportCaller( g_Layout_enablePatchToolbar.m_latched )
+			make_property( g_Layout_enablePatchToolbar )
 			);
 	}
 	page.appendCheckBox(
 		"", "Plugin Toolbar",
-		LatchedBoolImportCaller( g_Layout_enablePluginToolbar ),
-		BoolExportCaller( g_Layout_enablePluginToolbar.m_latched )
+		make_property( g_Layout_enablePluginToolbar )
 		);
 }
 
@@ -3161,7 +3286,7 @@ void Layout_constructPage( PreferenceGroup& group ){
 }
 
 void Layout_registerPreferencesPage(){
-	PreferencesDialog_addInterfacePage( FreeCaller1<PreferenceGroup&, Layout_constructPage>() );
+	PreferencesDialog_addInterfacePage( makeCallbackF(Layout_constructPage) );
 }
 
 
@@ -3169,75 +3294,75 @@ void Layout_registerPreferencesPage(){
 #include "stringio.h"
 
 void MainFrame_Construct(){
-	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>() );
-	GlobalCommands_insert( "OpenMap", FreeCaller<OpenMap>(), Accelerator( 'O', (GdkModifierType)GDK_CONTROL_MASK ) );
-	GlobalCommands_insert( "ImportMap", FreeCaller<ImportMap>() );
-	GlobalCommands_insert( "SaveMap", FreeCaller<SaveMap>(), Accelerator( 'S', (GdkModifierType)GDK_CONTROL_MASK ) );
-	GlobalCommands_insert( "SaveMapAs", FreeCaller<SaveMapAs>() );
-	GlobalCommands_insert( "ExportSelected", FreeCaller<ExportMap>() );
-	GlobalCommands_insert( "SaveRegion", FreeCaller<SaveRegion>() );
-	GlobalCommands_insert( "RefreshReferences", FreeCaller<RefreshReferences>() );
-	GlobalCommands_insert( "ProjectSettings", FreeCaller<DoProjectSettings>() );
-	GlobalCommands_insert( "Exit", FreeCaller<Exit>() );
-
-	GlobalCommands_insert( "Undo", FreeCaller<Undo>(), Accelerator( 'Z', (GdkModifierType)GDK_CONTROL_MASK ) );
-	GlobalCommands_insert( "Redo", FreeCaller<Redo>(), Accelerator( 'Y', (GdkModifierType)GDK_CONTROL_MASK ) );
-	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_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_KEY_Escape ) );
-	GlobalCommands_insert( "InvertSelection", FreeCaller<Select_Invert>(), Accelerator( 'I' ) );
-	GlobalCommands_insert( "SelectInside", FreeCaller<Select_Inside>() );
-	GlobalCommands_insert( "SelectTouching", FreeCaller<Select_Touching>() );
-	GlobalCommands_insert( "ExpandSelectionToEntities", FreeCaller<Scene_ExpandSelectionToEntities>(), Accelerator( 'E', (GdkModifierType)( GDK_MOD1_MASK | GDK_CONTROL_MASK ) ) );
-	GlobalCommands_insert( "Preferences", FreeCaller<PreferencesDialog_showDialog>(), Accelerator( 'P' ) );
-
-	GlobalCommands_insert( "ToggleConsole", FreeCaller<Console_ToggleShow>(), Accelerator( 'O' ) );
-	GlobalCommands_insert( "ToggleEntityInspector", FreeCaller<EntityInspector_ToggleShow>(), Accelerator( 'N' ) );
-	GlobalCommands_insert( "EntityList", FreeCaller<EntityList_toggleShown>(), Accelerator( 'L' ) );
-
-	GlobalCommands_insert( "ShowHidden", FreeCaller<Select_ShowAllHidden>(), Accelerator( 'H', (GdkModifierType)GDK_SHIFT_MASK ) );
-	GlobalCommands_insert( "HideSelected", FreeCaller<HideSelected>(), Accelerator( 'H' ) );
-
-	GlobalToggles_insert( "DragVertices", FreeCaller<SelectVertexMode>(), ToggleItem::AddCallbackCaller( g_vertexMode_button ), Accelerator( 'V' ) );
-	GlobalToggles_insert( "DragEdges", FreeCaller<SelectEdgeMode>(), ToggleItem::AddCallbackCaller( g_edgeMode_button ), Accelerator( 'E' ) );
-	GlobalToggles_insert( "DragFaces", FreeCaller<SelectFaceMode>(), ToggleItem::AddCallbackCaller( g_faceMode_button ), Accelerator( 'F' ) );
-
-	GlobalCommands_insert( "MirrorSelectionX", FreeCaller<Selection_Flipx>() );
-	GlobalCommands_insert( "RotateSelectionX", FreeCaller<Selection_Rotatex>() );
-	GlobalCommands_insert( "MirrorSelectionY", FreeCaller<Selection_Flipy>() );
-	GlobalCommands_insert( "RotateSelectionY", FreeCaller<Selection_Rotatey>() );
-	GlobalCommands_insert( "MirrorSelectionZ", FreeCaller<Selection_Flipz>() );
-	GlobalCommands_insert( "RotateSelectionZ", FreeCaller<Selection_Rotatez>() );
-
-	GlobalCommands_insert( "ArbitraryRotation", FreeCaller<DoRotateDlg>() );
-	GlobalCommands_insert( "ArbitraryScale", FreeCaller<DoScaleDlg>() );
-
-	GlobalCommands_insert( "BuildMenuCustomize", FreeCaller<DoBuildMenu>() );
-
-	GlobalCommands_insert( "FindBrush", FreeCaller<DoFind>() );
-
-	GlobalCommands_insert( "MapInfo", FreeCaller<DoMapInfo>(), Accelerator( 'M' ) );
-
-
-	GlobalToggles_insert( "ToggleClipper", FreeCaller<ClipperMode>(), ToggleItem::AddCallbackCaller( g_clipper_button ), Accelerator( 'X' ) );
-
-	GlobalToggles_insert( "MouseTranslate", FreeCaller<TranslateMode>(), ToggleItem::AddCallbackCaller( g_translatemode_button ), Accelerator( 'W' ) );
-	GlobalToggles_insert( "MouseRotate", FreeCaller<RotateMode>(), ToggleItem::AddCallbackCaller( g_rotatemode_button ), Accelerator( 'R' ) );
-	GlobalToggles_insert( "MouseScale", FreeCaller<ScaleMode>(), ToggleItem::AddCallbackCaller( g_scalemode_button ) );
-	GlobalToggles_insert( "MouseDrag", FreeCaller<DragMode>(), ToggleItem::AddCallbackCaller( g_dragmode_button ), Accelerator( 'Q' ) );
-
-	GlobalCommands_insert( "ColorSchemeOriginal", FreeCaller<ColorScheme_Original>() );
-	GlobalCommands_insert( "ColorSchemeQER", FreeCaller<ColorScheme_QER>() );
-	GlobalCommands_insert( "ColorSchemeBlackAndGreen", FreeCaller<ColorScheme_Black>() );
-	GlobalCommands_insert( "ColorSchemeYdnar", FreeCaller<ColorScheme_Ydnar>() );
+	GlobalCommands_insert( "OpenManual", makeCallbackF(OpenHelpURL), Accelerator( GDK_KEY_F1 ) );
+
+	GlobalCommands_insert( "Sleep", makeCallbackF(thunk_OnSleep), Accelerator( 'P', (GdkModifierType)( GDK_SHIFT_MASK | GDK_CONTROL_MASK ) ) );
+	GlobalCommands_insert( "NewMap", makeCallbackF(NewMap) );
+	GlobalCommands_insert( "OpenMap", makeCallbackF(OpenMap), Accelerator( 'O', (GdkModifierType)GDK_CONTROL_MASK ) );
+	GlobalCommands_insert( "ImportMap", makeCallbackF(ImportMap) );
+	GlobalCommands_insert( "SaveMap", makeCallbackF(SaveMap), Accelerator( 'S', (GdkModifierType)GDK_CONTROL_MASK ) );
+	GlobalCommands_insert( "SaveMapAs", makeCallbackF(SaveMapAs) );
+	GlobalCommands_insert( "ExportSelected", makeCallbackF(ExportMap) );
+	GlobalCommands_insert( "SaveRegion", makeCallbackF(SaveRegion) );
+	GlobalCommands_insert( "RefreshReferences", makeCallbackF(VFS_Refresh) );
+	GlobalCommands_insert( "ProjectSettings", makeCallbackF(DoProjectSettings) );
+	GlobalCommands_insert( "Exit", makeCallbackF(Exit) );
+
+	GlobalCommands_insert( "Undo", makeCallbackF(Undo), Accelerator( 'Z', (GdkModifierType)GDK_CONTROL_MASK ) );
+	GlobalCommands_insert( "Redo", makeCallbackF(Redo), Accelerator( 'Y', (GdkModifierType)GDK_CONTROL_MASK ) );
+	GlobalCommands_insert( "Copy", makeCallbackF(Copy), Accelerator( 'C', (GdkModifierType)GDK_CONTROL_MASK ) );
+	GlobalCommands_insert( "Paste", makeCallbackF(Paste), Accelerator( 'V', (GdkModifierType)GDK_CONTROL_MASK ) );
+	GlobalCommands_insert( "PasteToCamera", makeCallbackF(PasteToCamera), Accelerator( 'V', (GdkModifierType)GDK_MOD1_MASK ) );
+	GlobalCommands_insert( "CloneSelection", makeCallbackF(Selection_Clone), Accelerator( GDK_KEY_space ) );
+	GlobalCommands_insert( "CloneSelectionAndMakeUnique", makeCallbackF(Selection_Clone_MakeUnique), Accelerator( GDK_KEY_space, (GdkModifierType)GDK_SHIFT_MASK ) );
+	GlobalCommands_insert( "DeleteSelection", makeCallbackF(deleteSelection), Accelerator( GDK_KEY_BackSpace ) );
+	GlobalCommands_insert( "ParentSelection", makeCallbackF(Scene_parentSelected) );
+	GlobalCommands_insert( "UnSelectSelection", makeCallbackF(Selection_Deselect), Accelerator( GDK_KEY_Escape ) );
+	GlobalCommands_insert( "InvertSelection", makeCallbackF(Select_Invert), Accelerator( 'I' ) );
+	GlobalCommands_insert( "SelectInside", makeCallbackF(Select_Inside) );
+	GlobalCommands_insert( "SelectTouching", makeCallbackF(Select_Touching) );
+	GlobalCommands_insert( "ExpandSelectionToEntities", makeCallbackF(Scene_ExpandSelectionToEntities), Accelerator( 'E', (GdkModifierType)( GDK_MOD1_MASK | GDK_CONTROL_MASK ) ) );
+	GlobalCommands_insert( "Preferences", makeCallbackF(PreferencesDialog_showDialog), Accelerator( 'P' ) );
+
+	GlobalCommands_insert( "ToggleConsole", makeCallbackF(Console_ToggleShow), Accelerator( 'O' ) );
+	GlobalCommands_insert( "ToggleEntityInspector", makeCallbackF(EntityInspector_ToggleShow), Accelerator( 'N' ) );
+	GlobalCommands_insert( "EntityList", makeCallbackF(EntityList_toggleShown), Accelerator( 'L' ) );
+
+	GlobalCommands_insert( "ShowHidden", makeCallbackF(Select_ShowAllHidden), Accelerator( 'H', (GdkModifierType)GDK_SHIFT_MASK ) );
+	GlobalCommands_insert( "HideSelected", makeCallbackF(HideSelected), Accelerator( 'H' ) );
+
+	GlobalToggles_insert( "DragVertices", makeCallbackF(SelectVertexMode), ToggleItem::AddCallbackCaller( g_vertexMode_button ), Accelerator( 'V' ) );
+	GlobalToggles_insert( "DragEdges", makeCallbackF(SelectEdgeMode), ToggleItem::AddCallbackCaller( g_edgeMode_button ), Accelerator( 'E' ) );
+	GlobalToggles_insert( "DragFaces", makeCallbackF(SelectFaceMode), ToggleItem::AddCallbackCaller( g_faceMode_button ), Accelerator( 'F' ) );
+
+	GlobalCommands_insert( "MirrorSelectionX", makeCallbackF(Selection_Flipx) );
+	GlobalCommands_insert( "RotateSelectionX", makeCallbackF(Selection_Rotatex) );
+	GlobalCommands_insert( "MirrorSelectionY", makeCallbackF(Selection_Flipy) );
+	GlobalCommands_insert( "RotateSelectionY", makeCallbackF(Selection_Rotatey) );
+	GlobalCommands_insert( "MirrorSelectionZ", makeCallbackF(Selection_Flipz) );
+	GlobalCommands_insert( "RotateSelectionZ", makeCallbackF(Selection_Rotatez) );
+
+	GlobalCommands_insert( "ArbitraryRotation", makeCallbackF(DoRotateDlg) );
+	GlobalCommands_insert( "ArbitraryScale", makeCallbackF(DoScaleDlg) );
+
+	GlobalCommands_insert( "BuildMenuCustomize", makeCallbackF(DoBuildMenu) );
+
+	GlobalCommands_insert( "FindBrush", makeCallbackF(DoFind) );
+
+	GlobalCommands_insert( "MapInfo", makeCallbackF(DoMapInfo), Accelerator( 'M' ) );
+
+
+	GlobalToggles_insert( "ToggleClipper", makeCallbackF(ClipperMode), ToggleItem::AddCallbackCaller( g_clipper_button ), Accelerator( 'X' ) );
+
+	GlobalToggles_insert( "MouseTranslate", makeCallbackF(TranslateMode), ToggleItem::AddCallbackCaller( g_translatemode_button ), Accelerator( 'W' ) );
+	GlobalToggles_insert( "MouseRotate", makeCallbackF(RotateMode), ToggleItem::AddCallbackCaller( g_rotatemode_button ), Accelerator( 'R' ) );
+	GlobalToggles_insert( "MouseScale", makeCallbackF(ScaleMode), ToggleItem::AddCallbackCaller( g_scalemode_button ) );
+	GlobalToggles_insert( "MouseDrag", makeCallbackF(DragMode), ToggleItem::AddCallbackCaller( g_dragmode_button ), Accelerator( 'Q' ) );
+
+	GlobalCommands_insert( "ColorSchemeOriginal", makeCallbackF(ColorScheme_Original) );
+	GlobalCommands_insert( "ColorSchemeQER", makeCallbackF(ColorScheme_QER) );
+	GlobalCommands_insert( "ColorSchemeBlackAndGreen", makeCallbackF(ColorScheme_Black) );
+	GlobalCommands_insert( "ColorSchemeYdnar", makeCallbackF(ColorScheme_Ydnar) );
 	GlobalCommands_insert( "ChooseTextureBackgroundColor", makeCallback( g_ColoursMenu.m_textureback ) );
 	GlobalCommands_insert( "ChooseGridBackgroundColor", makeCallback( g_ColoursMenu.m_xyback ) );
 	GlobalCommands_insert( "ChooseGridMajorColor", makeCallback( g_ColoursMenu.m_gridmajor ) );
@@ -3254,68 +3379,68 @@ void MainFrame_Construct(){
 	GlobalCommands_insert( "ChooseOrthoViewNameColor", makeCallback( g_ColoursMenu.m_viewname ) );
 
 
-	GlobalCommands_insert( "CSGSubtract", FreeCaller<CSG_Subtract>(), Accelerator( 'U', (GdkModifierType)GDK_SHIFT_MASK ) );
-	GlobalCommands_insert( "CSGMerge", FreeCaller<CSG_Merge>(), Accelerator( 'U', (GdkModifierType)GDK_CONTROL_MASK ) );
-	GlobalCommands_insert( "CSGHollow", FreeCaller<CSG_MakeHollow>() );
+	GlobalCommands_insert( "CSGSubtract", makeCallbackF(CSG_Subtract), Accelerator( 'U', (GdkModifierType)GDK_SHIFT_MASK ) );
+	GlobalCommands_insert( "CSGMerge", makeCallbackF(CSG_Merge), Accelerator( 'U', (GdkModifierType)GDK_CONTROL_MASK ) );
+	GlobalCommands_insert( "CSGHollow", makeCallbackF(CSG_MakeHollow) );
 
 	Grid_registerCommands();
 
-	GlobalCommands_insert( "SnapToGrid", FreeCaller<Selection_SnapToGrid>(), Accelerator( 'G', (GdkModifierType)GDK_CONTROL_MASK ) );
+	GlobalCommands_insert( "SnapToGrid", makeCallbackF(Selection_SnapToGrid), Accelerator( 'G', (GdkModifierType)GDK_CONTROL_MASK ) );
 
-	GlobalCommands_insert( "SelectAllOfType", FreeCaller<Select_AllOfType>(), Accelerator( 'A', (GdkModifierType)GDK_SHIFT_MASK ) );
+	GlobalCommands_insert( "SelectAllOfType", makeCallbackF(Select_AllOfType), Accelerator( 'A', (GdkModifierType)GDK_SHIFT_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( "TexRotateClock", makeCallbackF(Texdef_RotateClockwise), Accelerator( GDK_KEY_Next, (GdkModifierType)GDK_SHIFT_MASK ) );
+	GlobalCommands_insert( "TexRotateCounter", makeCallbackF(Texdef_RotateAntiClockwise), Accelerator( GDK_KEY_Prior, (GdkModifierType)GDK_SHIFT_MASK ) );
+	GlobalCommands_insert( "TexScaleUp", makeCallbackF(Texdef_ScaleUp), Accelerator( GDK_KEY_Up, (GdkModifierType)GDK_CONTROL_MASK ) );
+	GlobalCommands_insert( "TexScaleDown", makeCallbackF(Texdef_ScaleDown), Accelerator( GDK_KEY_Down, (GdkModifierType)GDK_CONTROL_MASK ) );
+	GlobalCommands_insert( "TexScaleLeft", makeCallbackF(Texdef_ScaleLeft), Accelerator( GDK_KEY_Left, (GdkModifierType)GDK_CONTROL_MASK ) );
+	GlobalCommands_insert( "TexScaleRight", makeCallbackF(Texdef_ScaleRight), Accelerator( GDK_KEY_Right, (GdkModifierType)GDK_CONTROL_MASK ) );
+	GlobalCommands_insert( "TexShiftUp", makeCallbackF(Texdef_ShiftUp), Accelerator( GDK_KEY_Up, (GdkModifierType)GDK_SHIFT_MASK ) );
+	GlobalCommands_insert( "TexShiftDown", makeCallbackF(Texdef_ShiftDown), Accelerator( GDK_KEY_Down, (GdkModifierType)GDK_SHIFT_MASK ) );
+	GlobalCommands_insert( "TexShiftLeft", makeCallbackF(Texdef_ShiftLeft), Accelerator( GDK_KEY_Left, (GdkModifierType)GDK_SHIFT_MASK ) );
+	GlobalCommands_insert( "TexShiftRight", makeCallbackF(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( "MoveSelectionDOWN", makeCallbackF(Selection_MoveDown), Accelerator( GDK_KEY_KP_Subtract ) );
+	GlobalCommands_insert( "MoveSelectionUP", makeCallbackF(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 ) );
+	GlobalCommands_insert( "SelectNudgeLeft", makeCallbackF(Selection_NudgeLeft), Accelerator( GDK_KEY_Left, (GdkModifierType)GDK_MOD1_MASK ) );
+	GlobalCommands_insert( "SelectNudgeRight", makeCallbackF(Selection_NudgeRight), Accelerator( GDK_KEY_Right, (GdkModifierType)GDK_MOD1_MASK ) );
+	GlobalCommands_insert( "SelectNudgeUp", makeCallbackF(Selection_NudgeUp), Accelerator( GDK_KEY_Up, (GdkModifierType)GDK_MOD1_MASK ) );
+	GlobalCommands_insert( "SelectNudgeDown", makeCallbackF(Selection_NudgeDown), Accelerator( GDK_KEY_Down, (GdkModifierType)GDK_MOD1_MASK ) );
 
 	Patch_registerCommands();
 	XYShow_registerCommands();
 
-	typedef FreeCaller1<const Selectable&, ComponentMode_SelectionChanged> ComponentModeSelectionChangedCaller;
+	typedef FreeCaller<void(const Selectable&), ComponentMode_SelectionChanged> ComponentModeSelectionChangedCaller;
 	GlobalSelectionSystem().addSelectionChangeCallback( ComponentModeSelectionChangedCaller() );
 
-	GlobalPreferenceSystem().registerPreference( "DetachableMenus", BoolImportStringCaller( g_Layout_enableDetachableMenus.m_latched ), BoolExportStringCaller( g_Layout_enableDetachableMenus.m_latched ) );
-	GlobalPreferenceSystem().registerPreference( "PatchToolBar", BoolImportStringCaller( g_Layout_enablePatchToolbar.m_latched ), BoolExportStringCaller( g_Layout_enablePatchToolbar.m_latched ) );
-	GlobalPreferenceSystem().registerPreference( "PluginToolBar", BoolImportStringCaller( g_Layout_enablePluginToolbar.m_latched ), BoolExportStringCaller( g_Layout_enablePluginToolbar.m_latched ) );
-	GlobalPreferenceSystem().registerPreference( "QE4StyleWindows", IntImportStringCaller( g_Layout_viewStyle.m_latched ), IntExportStringCaller( g_Layout_viewStyle.m_latched ) );
-	GlobalPreferenceSystem().registerPreference( "XYHeight", IntImportStringCaller( g_layout_globals.nXYHeight ), IntExportStringCaller( g_layout_globals.nXYHeight ) );
-	GlobalPreferenceSystem().registerPreference( "XYWidth", IntImportStringCaller( g_layout_globals.nXYWidth ), IntExportStringCaller( g_layout_globals.nXYWidth ) );
-	GlobalPreferenceSystem().registerPreference( "CamWidth", IntImportStringCaller( g_layout_globals.nCamWidth ), IntExportStringCaller( g_layout_globals.nCamWidth ) );
-	GlobalPreferenceSystem().registerPreference( "CamHeight", IntImportStringCaller( g_layout_globals.nCamHeight ), IntExportStringCaller( g_layout_globals.nCamHeight ) );
-
-	GlobalPreferenceSystem().registerPreference( "State", IntImportStringCaller( g_layout_globals.nState ), IntExportStringCaller( g_layout_globals.nState ) );
-	GlobalPreferenceSystem().registerPreference( "PositionX", IntImportStringCaller( g_layout_globals.m_position.x ), IntExportStringCaller( g_layout_globals.m_position.x ) );
-	GlobalPreferenceSystem().registerPreference( "PositionY", IntImportStringCaller( g_layout_globals.m_position.y ), IntExportStringCaller( g_layout_globals.m_position.y ) );
-	GlobalPreferenceSystem().registerPreference( "Width", IntImportStringCaller( g_layout_globals.m_position.w ), IntExportStringCaller( g_layout_globals.m_position.w ) );
-	GlobalPreferenceSystem().registerPreference( "Height", IntImportStringCaller( g_layout_globals.m_position.h ), IntExportStringCaller( g_layout_globals.m_position.h ) );
-
-	GlobalPreferenceSystem().registerPreference( "CamWnd", WindowPositionTrackerImportStringCaller( g_posCamWnd ), WindowPositionTrackerExportStringCaller( g_posCamWnd ) );
-	GlobalPreferenceSystem().registerPreference( "XYWnd", WindowPositionTrackerImportStringCaller( g_posXYWnd ), WindowPositionTrackerExportStringCaller( g_posXYWnd ) );
-	GlobalPreferenceSystem().registerPreference( "YZWnd", WindowPositionTrackerImportStringCaller( g_posYZWnd ), WindowPositionTrackerExportStringCaller( g_posYZWnd ) );
-	GlobalPreferenceSystem().registerPreference( "XZWnd", WindowPositionTrackerImportStringCaller( g_posXZWnd ), WindowPositionTrackerExportStringCaller( g_posXZWnd ) );
+	GlobalPreferenceSystem().registerPreference( "DetachableMenus", make_property_string( g_Layout_enableDetachableMenus.m_latched ) );
+	GlobalPreferenceSystem().registerPreference( "PatchToolBar", make_property_string( g_Layout_enablePatchToolbar.m_latched ) );
+	GlobalPreferenceSystem().registerPreference( "PluginToolBar", make_property_string( g_Layout_enablePluginToolbar.m_latched ) );
+	GlobalPreferenceSystem().registerPreference( "QE4StyleWindows", make_property_string( g_Layout_viewStyle.m_latched ) );
+	GlobalPreferenceSystem().registerPreference( "XYHeight", make_property_string( g_layout_globals.nXYHeight ) );
+	GlobalPreferenceSystem().registerPreference( "XYWidth", make_property_string( g_layout_globals.nXYWidth ) );
+	GlobalPreferenceSystem().registerPreference( "CamWidth", make_property_string( g_layout_globals.nCamWidth ) );
+	GlobalPreferenceSystem().registerPreference( "CamHeight", make_property_string( g_layout_globals.nCamHeight ) );
+
+	GlobalPreferenceSystem().registerPreference( "State", make_property_string( g_layout_globals.nState ) );
+	GlobalPreferenceSystem().registerPreference( "PositionX", make_property_string( g_layout_globals.m_position.x ) );
+	GlobalPreferenceSystem().registerPreference( "PositionY", make_property_string( g_layout_globals.m_position.y ) );
+	GlobalPreferenceSystem().registerPreference( "Width", make_property_string( g_layout_globals.m_position.w ) );
+	GlobalPreferenceSystem().registerPreference( "Height", make_property_string( g_layout_globals.m_position.h ) );
+
+	GlobalPreferenceSystem().registerPreference( "CamWnd", make_property<WindowPositionTracker_String>(g_posCamWnd) );
+	GlobalPreferenceSystem().registerPreference( "XYWnd", make_property<WindowPositionTracker_String>(g_posXYWnd) );
+	GlobalPreferenceSystem().registerPreference( "YZWnd", make_property<WindowPositionTracker_String>(g_posYZWnd) );
+	GlobalPreferenceSystem().registerPreference( "XZWnd", make_property<WindowPositionTracker_String>(g_posXZWnd) );
 
 	{
 		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"
@@ -3326,7 +3451,15 @@ void MainFrame_Construct(){
 		g_strEnginePath = path.c_str();
 	}
 
-	GlobalPreferenceSystem().registerPreference( "EnginePath", CopiedStringImportStringCaller( g_strEnginePath ), CopiedStringExportStringCaller( g_strEnginePath ) );
+	GlobalPreferenceSystem().registerPreference( "EnginePath", make_property_string( g_strEnginePath ) );
+
+	GlobalPreferenceSystem().registerPreference( "DisableEnginePath", make_property_string( g_disableEnginePath ) );
+	GlobalPreferenceSystem().registerPreference( "DisableHomePath", make_property_string( g_disableHomePath ) );
+
+	for ( int i = 0; i < g_pakPathCount; i++ ) {
+		std::string label = "PakPath" + std::to_string(i);
+		GlobalPreferenceSystem().registerPreference( label.c_str(), make_property_string( g_strPakPath[i] ) );
+	}
 
 	g_Layout_viewStyle.useLatched();
 	g_Layout_enableDetachableMenus.useLatched();
@@ -3336,8 +3469,8 @@ void MainFrame_Construct(){
 	Layout_registerPreferencesPage();
 	Paths_registerPreferencesPage();
 
-	g_brushCount.setCountChangedCallback( FreeCaller<QE_brushCountChanged>() );
-	g_entityCount.setCountChangedCallback( FreeCaller<QE_entityCountChanged>() );
+	g_brushCount.setCountChangedCallback( makeCallbackF(QE_brushCountChanged) );
+	g_entityCount.setCountChangedCallback( makeCallbackF(QE_entityCountChanged) );
 	GlobalEntityCreator().setCounter( &g_entityCount );
 
 	GLWidget_sharedContextCreated = GlobalGL_sharedContextCreated;
@@ -3350,13 +3483,13 @@ void MainFrame_Destroy(){
 	GlobalEntityClassManager().detach( g_WorldspawnColourEntityClassObserver );
 
 	GlobalEntityCreator().setCounter( 0 );
-	g_entityCount.setCountChangedCallback( Callback() );
-	g_brushCount.setCountChangedCallback( Callback() );
+	g_entityCount.setCountChangedCallback( Callback<void()>() );
+	g_brushCount.setCountChangedCallback( Callback<void()>() );
 }
 
 
 void GLWindow_Construct(){
-	GlobalPreferenceSystem().registerPreference( "MouseButtons", IntImportStringCaller( g_glwindow_globals.m_nMouseType ), IntExportStringCaller( g_glwindow_globals.m_nMouseType ) );
+	GlobalPreferenceSystem().registerPreference( "MouseButtons", make_property_string( g_glwindow_globals.m_nMouseType ) );
 }
 
 void GLWindow_Destroy(){