//
#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"
#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"
#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"
#include "pluginmanager.h"
#include "pluginmenu.h"
#include "plugintoolbar.h"
-#include "points.h"
#include "preferences.h"
#include "qe3.h"
#include "qgl.h"
#include "renderstate.h"
#include "feedback.h"
#include "referencecache.h"
+#include "texwindow.h"
+#if GDEF_OS_WINDOWS
+#include <process.h>
+#else
+#include <spawn.h>
+#endif
+#ifdef WORKAROUND_WINDOWS_GTK2_GLWIDGET
+/* workaround for gtk 2.24 issue: not displayed glwidget after toggle */
+#define WORKAROUND_GOBJECT_SET_GLWIDGET(window, widget) g_object_set_data( G_OBJECT( window ), "glwidget", G_OBJECT( widget ) )
+#else
+#define WORKAROUND_GOBJECT_SET_GLWIDGET(window, widget)
+#endif
struct layout_globals_t
{
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 refresh models
+ RefreshReferences();
+ // also refresh texture browser
+ TextureBrowser_RefreshShaders();
+}
+
void VFS_Restart(){
VFS_Shutdown();
VFS_Init();
void realise(){
VFS_Init();
}
+
void unrealise(){
VFS_Shutdown();
}
void VFS_Construct(){
Radiant_attachHomePathsObserver( g_VFSModuleObserver );
}
+
void VFS_Destroy(){
Radiant_detachHomePathsObserver( g_VFSModuleObserver );
}
// 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}};
typedef HRESULT ( WINAPI qSHGetKnownFolderPath_t )( qREFKNOWNFOLDERID rfid, DWORD dwFlags, HANDLE hToken, PWSTR *ppszPath );
static qSHGetKnownFolderPath_t *qSHGetKnownFolderPath;
#endif
+
void HomePaths_Realise(){
do
{
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() ) ) {
}
path.clear();
path << DirectoryCleaned( g_get_home_dir() ) << prefix << "/";
-#endif
-
-#if defined( WIN32 )
+#elif GDEF_OS_WINDOWS
TCHAR mydocsdir[MAX_PATH + 1];
wchar_t *mydocsdirw;
HMODULE shfolder = LoadLibrary( "shfolder.dll" );
break;
}
}
-#endif
-
-#if defined( POSIX )
+#elif GDEF_OS_XDG
path.clear();
- path << DirectoryCleaned( g_get_home_dir() ) << prefix << "/";
- g_qeglobals.m_userEnginePath = path.c_str();
- break;
+ path << DirectoryCleaned( g_get_user_data_dir() ) << ( prefix + 1 ) << "/";
+ if ( file_exists( path.c_str() ) && file_is_directory( path.c_str() ) ) {
+ g_qeglobals.m_userEnginePath = path.c_str();
+ break;
+ }
+ else {
+ path.clear();
+ path << DirectoryCleaned( g_get_home_dir() ) << prefix << "/";
+ g_qeglobals.m_userEnginePath = path.c_str();
+ break;
+ }
#endif
}
public:
HomePathsModuleObserver() : m_unrealised( 1 ){
}
+
void realise(){
if ( --m_unrealised == 0 ) {
HomePaths_Realise();
g_homePathObservers.realise();
}
}
+
void unrealise(){
if ( ++m_unrealised == 1 ) {
g_homePathObservers.unrealise();
void HomePaths_Construct(){
Radiant_attachEnginePathObserver( g_HomePathsModuleObserver );
}
+
void HomePaths_Destroy(){
Radiant_detachEnginePathObserver( g_HomePathsModuleObserver );
}
}
}
+// 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);
+ }
+}
+
+
+// executable file path (full path)
+CopiedString g_strAppFilePath;
-// App Path
+// directory paths
+CopiedString g_strAppPath;
+CopiedString g_strLibPath;
+CopiedString g_strDataPath;
-CopiedString g_strAppPath; ///< holds the full path of the executable
+const char* AppFilePath_get(){
+ return g_strAppFilePath.c_str();
+}
const char* AppPath_get(){
return g_strAppPath.c_str();
}
+const char *LibPath_get()
+{
+ return g_strLibPath.c_str();
+}
+
+const char *DataPath_get()
+{
+ return g_strDataPath.c_str();
+}
+
/// the path to the local rc-dir
const char* LocalRcPath_get( void ){
static CopiedString rc_path;
/// directory for temp files
/// NOTE: on *nix this is were we check for .pid
CopiedString g_strSettingsPath;
+
const char* SettingsPath_get(){
return g_strSettingsPath.c_str();
}
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_constructBasicPreferences( PreferencesPage& page ) {
+ page.appendPathEntry( "Engine Path", true, make_property<EnginePath>(g_strEnginePath) );
+}
void Paths_constructPreferences( PreferencesPage& page ){
- page.appendPathEntry( "Engine Path", true,
- StringImportCallback( EnginePathImportCaller( g_strEnginePath ) ),
- StringExportCallback( StringExportCaller( g_strEnginePath ) )
- );
+ Paths_constructBasicPreferences( page );
+
+ page.appendSpacer( 4 );
+ page.appendLabel( "", "Advanced options" );
+ page.appendCheckBox( "", "Do not use Engine Path", g_disableEnginePath );
+ page.appendCheckBox( "", "Do not use Home Path", g_disableHomePath );
+
+ page.appendSpacer( 4 );
+ page.appendLabel( "", "Only a very few games support Pak Paths," );
+ page.appendLabel( "", "if you don't know what it is, leave this blank." );
+
+ const char *label = "Pak Path ";
+ page.appendPathEntry( label, true, make_property<PakPath0>( g_strPakPath[0] ) );
+ page.appendPathEntry( label, true, make_property<PakPath1>( g_strPakPath[1] ) );
+ page.appendPathEntry( label, true, make_property<PakPath2>( g_strPakPath[2] ) );
+ page.appendPathEntry( label, true, make_property<PakPath3>( g_strPakPath[3] ) );
+ page.appendPathEntry( label, true, make_property<PakPath4>( g_strPakPath[4] ) );
}
+
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) );
}
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 ) );
- Paths_constructPreferences( preferencesPage );
+ PreferencesPage page( *this, vbox2 );
+ Paths_constructBasicPreferences( page );
}
- 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 ));
}
};
#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 ){
public:
WorldspawnColourEntityClassObserver() : m_unrealised( 1 ){
}
+
void realise(){
if ( --m_unrealised == 0 ) {
SetWorldspawnColour( g_xywindow_globals.color_brushes );
}
}
+
void unrealise(){
if ( ++m_unrealised == 1 ) {
}
void Radiant_Initialise(){
GlobalModuleServer_Initialise();
- Radiant_loadModulesFromRoot( AppPath_get() );
+ Radiant_loadModulesFromRoot( LibPath_get() );
Preferences_Load();
}
void Exit(){
- if ( ConfirmModified( "Exit Radiant" ) ) {
+ if ( ConfirmModified( "Exit " RADIANT_NAME ) ) {
gtk_main_quit();
}
}
XY_UpdateAllWindows();
}
-typedef Callback1<Vector3&> GetColourCallback;
-typedef Callback1<const Vector3&> SetColourCallback;
+/* color scheme to fit the GTK Adwaita Dark theme */
+void ColorScheme_AdwaitaDark()
+{
+ // SI_Colors0
+ // GlobalTextureBrowser().color_textureback
+ TextureBrowser_setBackgroundColour(GlobalTextureBrowser(), Vector3(0.25f, 0.25f, 0.25f));
+
+ // SI_Colors4
+ g_camwindow_globals.color_cameraback = Vector3(0.25f, 0.25f, 0.25f);
+ // SI_Colors12
+ g_camwindow_globals.color_selbrushes3d = Vector3(1.0f, 0.0f, 0.0f);
+ CamWnd_Update(*g_pParentWnd->GetCamWnd());
+
+ // SI_Colors1
+ g_xywindow_globals.color_gridback = Vector3(0.25f, 0.25f, 0.25f);
+ // SI_Colors2
+ g_xywindow_globals.color_gridminor = Vector3(0.21f, 0.23f, 0.23f);
+ // SI_Colors3
+ g_xywindow_globals.color_gridmajor = Vector3(0.14f, 0.15f, 0.15f);
+ // SI_Colors14
+ g_xywindow_globals.color_gridmajor_alt = Vector3(1.0f, 0.0f, 0.0f);
+ // SI_Colors6
+ g_xywindow_globals.color_gridblock = Vector3(1.0f, 1.0f, 1.0f);
+ // SI_Colors7
+ g_xywindow_globals.color_gridtext = Vector3(0.0f, 0.0f, 0.0f);
+ // ??
+ g_xywindow_globals.color_selbrushes = Vector3(1.0f, 0.0f, 0.0f);
+ // ??
+ g_xywindow_globals.color_clipper = Vector3(0.0f, 0.0f, 1.0f);
+ // SI_Colors8
+ g_xywindow_globals.color_brushes = Vector3(0.73f, 0.73f, 0.73f);
+
+ // SI_AxisColors0
+ g_xywindow_globals.AxisColorX = Vector3(1.0f, 0.0f, 0.0f);
+ // SI_AxisColors1
+ g_xywindow_globals.AxisColorY = Vector3(0.0f, 1.0f, 0.0f);
+ // SI_AxisColors2
+ g_xywindow_globals.AxisColorZ = Vector3(0.0f, 0.0f, 1.0f);
+ SetWorldspawnColour(g_xywindow_globals.color_brushes);
+ // ??
+ g_xywindow_globals.color_viewname = Vector3(0.5f, 0.0f, 0.75f);
+ XY_UpdateAllWindows();
+
+ // SI_Colors5
+ // g_entity_globals.color_entity = Vector3(0.0f, 0.0f, 0.0f);
+}
+
+typedef Callback<void(Vector3&)> GetColourCallback;
+typedef Callback<void(const Vector3&)> SetColourCallback;
class ChooseColour
{
ChooseColour( const GetColourCallback& get, const SetColourCallback& set )
: m_get( get ), m_set( set ){
}
+
void operator()(){
Vector3 colour;
m_get( colour );
- color_dialog( GTK_WIDGET( MainFrame_getWindow() ), colour );
+ color_dialog( MainFrame_getWindow(), colour );
m_set( colour );
}
};
-
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
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::from( 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 );
}
create_menu_item_with_mnemonic( menu_3, "Q3Radiant Original", "ColorSchemeQER" );
create_menu_item_with_mnemonic( menu_3, "Black and Green", "ColorSchemeBlackAndGreen" );
create_menu_item_with_mnemonic( menu_3, "Maya/Max/Lightwave Emulation", "ColorSchemeYdnar" );
+ create_menu_item_with_mnemonic(menu_3, "Adwaita Dark", "ColorSchemeAdwaitaDark");
menu_separator( menu_in_menu );
g_pParentWnd->OnSleep();
}
-void OpenUpdateURL(){
- OpenURL( "https://gitlab.com/xonotic/netradiant/tags" );
-}
-
-// open the Q3Rad manual
void OpenHelpURL(){
OpenURL( "https://gitlab.com/xonotic/xonotic/wikis/Mapping" );
}
}
-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 );
}
-
void SetClipMode( bool enable );
+
void ModeChangeNotify();
typedef void ( *ToolMode )();
+
ToolMode g_currentToolMode = 0;
bool g_currentToolModeSupportsComponentEditing = false;
ToolMode g_defaultToolMode = 0;
-
void SelectionSystem_DefaultMode(){
GlobalSelectionSystem().SetMode( SelectionSystem::ePrimitive );
GlobalSelectionSystem().SetComponentMode( SelectionSystem::eDefault );
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(){
public:
CloneSelected( bool d ) : doMakeUnique( d ), worldspawn( Map_FindOrInsertWorldspawn( g_map ) ){
}
+
bool pre( const scene::Path& path, scene::Instance& instance ) const {
if ( path.size() == 1 ) {
return true;
return true;
}
+
void post( const scene::Path& path, scene::Instance& instance ) const {
if ( path.size() == 1 ) {
return;
Vector3 x;
Vector3 y;
Vector3 z;
+
AxisBase( const Vector3& x_, const Vector3& y_, const Vector3& z_ )
: x( x_ ), y( y_ ), z( z_ ){
}
}
-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(){
SnappableSnapToGridSelected( float snap )
: m_snap( snap ){
}
+
bool pre( const scene::Path& path, scene::Instance& instance ) const {
if ( path.top().get().visible() ) {
Snappable* snappable = Node_getSnappable( path.top() );
ComponentSnappableSnapToGridSelected( float snap )
: m_snap( snap ){
}
+
bool pre( const scene::Path& path, scene::Instance& instance ) const {
if ( path.top().get().visible() ) {
ComponentSnappable* componentSnappable = Instance_getComponentSnappable( instance );
static gint qe_every_second( gpointer data ){
- GdkModifierType mask;
+ if (g_pParentWnd == nullptr)
+ return TRUE;
- gdk_window_get_pointer( 0, 0, 0, &mask );
+ GdkModifierType mask;
+ gdk_window_get_pointer( gtk_widget_get_window(g_pParentWnd->m_window), nullptr, nullptr, &mask );
if ( ( mask & ( GDK_BUTTON1_MASK | GDK_BUTTON2_MASK | GDK_BUTTON3_MASK ) ) == 0 ) {
QE_CheckAutoSave();
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 ) );
- gtk_widget_set_size_request( GTK_WIDGET( dialog.m_label ), 200, -1 );
+ dialog.m_label.show();
+ dialog.m_label.dimensions(200, -1);
- gtk_container_add( GTK_CONTAINER( dialog.m_window ), GTK_WIDGET( dialog.m_label ) );
+ dialog.m_window.add(dialog.m_label);
}
return dialog;
}
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;
}
}
void ScreenUpdates_process(){
- if ( redrawRequired() && GTK_WIDGET_VISIBLE( g_wait.m_window ) ) {
- process_gui();
+ if ( redrawRequired() && g_wait.m_window.visible() ) {
+ ui::process();
}
}
if ( g_wait_stack.empty() ) {
EverySecondTimer_disable();
- process_gui();
+ ui::process();
bool isActiveApp = MainFrame_isActiveApp();
g_wait = create_wait_dialog( title, message );
- 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();
+ gtk_grab_add( g_wait.m_window );
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);
+ if ( GTK_IS_WINDOW(g_wait.m_window) ) {
+ gtk_grab_add(g_wait.m_window);
+ }
ScreenUpdates_process();
}
g_wait_stack.push_back( message );
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 = 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();
}
}
-
void GlobalCamera_UpdateWindow(){
if ( g_pParentWnd != 0 ) {
CamWnd_Update( *g_pParentWnd->GetCamWnd() );
}
-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" );
-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::from( gtk_menu_item_get_submenu( file_menu_item ) );
if ( g_Layout_enableDetachableMenus.m_value ) {
menu_tearoff( 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 );
menu_separator( menu );
MRU_constructMenu( menu );
menu_separator( menu );
- create_menu_item_with_mnemonic( menu, "Check for NetRadiant update", "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::from( gtk_menu_item_get_submenu( edit_menu_item ) );
if ( g_Layout_enableDetachableMenus.m_value ) {
menu_tearoff( 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 );
}
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::from( gtk_menu_item_get_submenu( view_menu_item ) );
if ( g_Layout_enableDetachableMenus.m_value ) {
menu_tearoff( menu );
}
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 );
}
}
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 );
}
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 );
}
}
{
- 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 );
}
}
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 );
}
}
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 );
}
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::from( 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 );
}
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 );
}
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 );
}
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 );
}
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::from( gtk_menu_item_get_submenu( bsp_menu_item ) );
if ( g_Layout_enableDetachableMenus.m_value ) {
menu_tearoff( 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::from( gtk_menu_item_get_submenu( grid_menu_item ) );
if ( g_Layout_enableDetachableMenus.m_value ) {
menu_tearoff( 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::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
- 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" );
// 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;
}
-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::from( gtk_menu_item_get_submenu( entity_menu_item ) );
if ( g_Layout_enableDetachableMenus.m_value ) {
menu_tearoff( 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::from( gtk_menu_item_get_submenu( brush_menu_item ) );
if ( g_Layout_enableDetachableMenus.m_value ) {
menu_tearoff( 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::from( gtk_menu_item_get_submenu( patch_menu_item ) );
if ( g_Layout_enableDetachableMenus.m_value ) {
menu_tearoff( 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::from( gtk_menu_item_get_submenu( help_menu_item ) );
if ( g_Layout_enableDetachableMenus.m_value ) {
menu_tearoff( 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 ){
- GtkMenuBar* menu_bar = GTK_MENU_BAR( gtk_menu_bar_new() );
- gtk_widget_show( GTK_WIDGET( menu_bar ) );
+ui::MenuBar create_main_menu( MainFrame::EViewStyle style ){
+ auto menu_bar = ui::MenuBar::from( gtk_menu_bar_new() );
+ menu_bar.show();
- 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() ) );
+ 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;
}
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" );
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" );
+ toolbar_append_button( toolbar, "Make Hollow", "selection_makehollow.png", "CSGMakeHollow" );
+ toolbar_append_button( toolbar, "Make Room", "selection_makeroom.png", "CSGMakeRoom" );
}
-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" );
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::from( 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::ToolItem::from(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
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;
}
-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 ) );
- gtk_table_attach_defaults( table, GTK_WIDGET( label ), 0, 1, 0, 1 );
- pStatusLabel[c_command_status] = GTK_WIDGET( label );
+ label.show();
+ 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)
{
- GtkFrame* frame = GTK_FRAME( gtk_frame_new( 0 ) );
- gtk_widget_show( GTK_WIDGET( frame ) );
- gtk_table_attach_defaults( table, GTK_WIDGET( frame ), i, i + 1, 0, 1 );
+ auto frame = ui::Frame();
+ frame.show();
+ table.attach(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(label );
}
- return GTK_WIDGET( table );
+ return ui::Widget(table );
}
#if 0
{
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";
}
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 );
}
};
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 );
}
};
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;
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;
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 );
+#ifndef WORKAROUND_MACOS_GTK2_DESTROY
+ i->destroy();
+#endif
}
- gtk_widget_destroy( GTK_WIDGET( m_window ) );
+#ifndef WORKAROUND_MACOS_GTK2_DESTROY
+ m_window.destroy();
+#endif
}
void MainFrame::SetActiveXY( XYWnd* p ){
#endif
}
-#ifdef _DEBUG
+#if GDEF_DEBUG
//#define DBG_SLEEP
#endif
}
-GtkWindow* create_splash(){
- GtkWindow* window = GTK_WINDOW( gtk_window_new( GTK_WINDOW_TOPLEVEL ) );
- gtk_window_set_decorated( window, FALSE );
- gtk_window_set_resizable( window, FALSE );
- gtk_window_set_modal( window, TRUE );
+ui::Window create_splash(){
+ 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);
- 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.dimensions(-1, -1);
+ 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;
WindowPositionTracker g_posXZWnd;
WindowPositionTracker g_posYZWnd;
-static gint mainframe_delete( GtkWidget *widget, GdkEvent *event, gpointer data ){
- if ( ConfirmModified( "Exit Radiant" ) ) {
+static gint mainframe_delete( ui::Widget widget, GdkEvent *event, gpointer data ){
+ if ( ConfirmModified( "Exit " RADIANT_NAME ) ) {
gtk_main_quit();
}
}
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 );
+ 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 );
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 );
+ auto vbox = ui::VBox( FALSE, 0 );
+ window.add(vbox);
+ vbox.show();
global_accel_connect_window( window );
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 );
- GtkWidget* 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" ) );
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 );
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 );
+ vbox.pack_start( vsplit, TRUE, TRUE, 0 );
+ 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(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 ) {
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 );
}
}
}
}
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 ) );
+ WORKAROUND_GOBJECT_SET_GLWIDGET( window, CamWnd_getWidget( *m_pCamWnd ) );
+
+ 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 );
{
- 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 ) );
+ WORKAROUND_GOBJECT_SET_GLWIDGET( window, m_pXYWnd->GetWidget() );
+
+ 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 );
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 ) );
+ WORKAROUND_GOBJECT_SET_GLWIDGET( window, m_pXZWnd->GetWidget() );
+
+ 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 );
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 ) );
+ WORKAROUND_GOBJECT_SET_GLWIDGET( window, m_pYZWnd->GetWidget() );
+
+ 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() );
+ auto frame = create_framed_widget( TextureBrowser_constructWindow( GroupDialog_getWindow() ) );
+ g_page_textures = GroupDialog_addPage( "Textures", frame, TextureBrowserExportTitleCaller() );
+
+ WORKAROUND_GOBJECT_SET_GLWIDGET( GroupDialog_getWindow(), TextureBrowser_getGLWidget() );
}
GroupDialog_show();
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 );
+ 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", GTK_WIDGET( frame ), TextureBrowserExportTitleCaller() );
+ auto frame = create_framed_widget( TextureBrowser_constructWindow( window ) );
+ g_page_textures = GroupDialog_addPage( "Textures", frame, TextureBrowserExportTitleCaller() );
+
+ WORKAROUND_GOBJECT_SET_GLWIDGET( window, TextureBrowser_getGLWidget() );
}
}
SetActiveXY( m_pXYWnd );
AddGridChangeCallback( SetGridStatusCaller( *this ) );
- AddGridChangeCallback( ReferenceCaller<MainFrame, XY_UpdateAllWindows>( *this ) );
+ AddGridChangeCallback( ReferenceCaller<MainFrame, void(), XY_UpdateAllWindows>( *this ) );
g_defaultToolMode = DragMode;
g_defaultToolMode();
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(m_window ) );
}
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(){
}
void Sys_Status( const char* status ){
- if ( g_pParentWnd != 0 ) {
+ if ( g_pParentWnd != nullptr ) {
g_pParentWnd->SetStatusText( g_pParentWnd->m_command_status, status );
}
}
}
float ( *GridStatus_getGridSize )() = GetGridSize;
+
int ( *GridStatus_getRotateIncrement )() = getRotateIncrement;
+
int ( *GridStatus_getFarClipDistance )() = getFarClipDistance;
+
bool ( *GridStatus_getTextureLockEnabled )();
void MainFrame::SetGridStatus(){
}
void GridStatus_onTextureLockEnabledChanged(){
- if ( g_pParentWnd != 0 ) {
+ if ( g_pParentWnd != nullptr ) {
g_pParentWnd->SetGridStatus();
}
}
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() );
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 );
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 )
);
}
}
void Layout_registerPreferencesPage(){
- PreferencesDialog_addInterfacePage( FreeCaller1<PreferenceGroup&, Layout_constructPage>() );
+ PreferencesDialog_addInterfacePage( makeCallbackF(Layout_constructPage) );
}
#include "stringio.h"
void MainFrame_Construct(){
- GlobalCommands_insert( "OpenManual", FreeCaller<OpenHelpURL>(), Accelerator( GDK_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( "SaveSelected", FreeCaller<ExportMap>() );
- GlobalCommands_insert( "SaveRegion", FreeCaller<SaveRegion>() );
- GlobalCommands_insert( "RefreshReferences", FreeCaller<RefreshReferences>() );
- 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 ) );
- 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_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( "ParentSelection", FreeCaller<Scene_parentSelected>() );
- GlobalCommands_insert( "UnSelectSelection", FreeCaller<Selection_Deselect>(), Accelerator( GDK_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("ColorSchemeAdwaitaDark", makeCallbackF(ColorScheme_AdwaitaDark));
GlobalCommands_insert( "ChooseTextureBackgroundColor", makeCallback( g_ColoursMenu.m_textureback ) );
GlobalCommands_insert( "ChooseGridBackgroundColor", makeCallback( g_ColoursMenu.m_xyback ) );
GlobalCommands_insert( "ChooseGridMajorColor", makeCallback( g_ColoursMenu.m_gridmajor ) );
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( "CSGMakeHollow", makeCallbackF(CSG_MakeHollow) );
+ GlobalCommands_insert( "CSGMakeRoom", makeCallbackF(CSG_MakeRoom) );
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_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( "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_KP_Subtract ) );
- GlobalCommands_insert( "MoveSelectionUP", FreeCaller<Selection_MoveUp>(), Accelerator( GDK_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_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( "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"
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();
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;
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(){
}
+
+void Radiant_Restart(){
+ // preferences are expected to be already saved in any way
+ // this is just to be sure and be future proof
+ Preferences_Save();
+
+ // this asks user for saving if map is modified
+ // user can chose to not save, it's ok
+ ConfirmModified( "Restart " RADIANT_NAME );
+
+ int status;
+
+ char *argv[ 3 ];
+ char exe_file[ 256 ];
+ char map_file[ 256 ];
+ bool with_map = false;
+
+ strncpy( exe_file, g_strAppFilePath.c_str(), 256 );
+
+ if ( !Map_Unnamed( g_map ) ) {
+ strncpy( map_file, Map_Name( g_map ), 256 );
+ with_map = true;
+ }
+
+ argv[ 0 ] = exe_file;
+ argv[ 1 ] = with_map ? map_file : NULL;
+ argv[ 2 ] = NULL;
+
+#if GDEF_OS_WINDOWS
+ status = !_spawnvpe( P_NOWAIT, exe_file, argv, environ );
+#else
+ pid_t pid;
+
+ status = posix_spawn( &pid, exe_file, NULL, NULL, argv, environ );
+#endif
+
+ // quit if radiant successfully started
+ if ( status == 0 ) {
+ gtk_main_quit();
+ }
+}
projects / xonotic / netradiant.git / blobdiff