#include "feedback.h"
#include "referencecache.h"
#include "texwindow.h"
+#include "filterbar.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
+
+#define GARUX_DISABLE_GTKTHEME
+#ifndef GARUX_DISABLE_GTKTHEME
+#include "gtktheme.h"
+#endif
struct layout_globals_t
{
layout_globals_t() :
m_position( -1, -1, 640, 480 ),
- nXYHeight( 300 ),
- nXYWidth( 300 ),
- nCamWidth( 200 ),
- nCamHeight( 200 ),
- nState( GDK_WINDOW_STATE_MAXIMIZED ){
+ nXYHeight( 350 ),
+ nXYWidth( 600 ),
+ nCamWidth( 300 ),
+ nCamHeight( 210 ),
+ nState( 0 ){
}
};
layout_globals_t g_layout_globals;
-glwindow_globals_t g_glwindow_globals;
+//glwindow_globals_t g_glwindow_globals;
// VFS
GlobalFileSystem().initialise();
g_vfsInitialized = true;
}
+
void VFS_Shutdown(){
if ( !g_vfsInitialized ) return;
GlobalFileSystem().shutdown();
g_vfsInitialized = false;
}
+
void VFS_Refresh(){
if ( !g_vfsInitialized ) return;
GlobalFileSystem().clear();
QE_InitVFS();
GlobalFileSystem().refresh();
g_vfsInitialized = true;
- // also refresg models
+ // also refresh models
RefreshReferences();
// also refresh texture browser
TextureBrowser_RefreshShaders();
+ // also show textures (all or common)
+ TextureBrowser_ShowStartupShaders( GlobalTextureBrowser() );
}
+
void VFS_Restart(){
VFS_Shutdown();
VFS_Init();
public:
void realise(){
VFS_Init();
-}
+ }
+
void unrealise(){
VFS_Shutdown();
}
void VFS_Construct(){
Radiant_attachHomePathsObserver( g_VFSModuleObserver );
}
+
void VFS_Destroy(){
Radiant_detachHomePathsObserver( g_VFSModuleObserver );
}
typedef HRESULT ( WINAPI qSHGetKnownFolderPath_t )( qREFKNOWNFOLDERID rfid, DWORD dwFlags, HANDLE hToken, PWSTR *ppszPath );
static qSHGetKnownFolderPath_t *qSHGetKnownFolderPath;
#endif
+
void HomePaths_Realise(){
do
{
}
path.clear();
path << DirectoryCleaned( g_get_home_dir() ) << prefix << "/";
-#endif
-
-#if GDEF_OS_WINDOWS
+#elif GDEF_OS_WINDOWS
TCHAR mydocsdir[MAX_PATH + 1];
wchar_t *mydocsdirw;
HMODULE shfolder = LoadLibrary( "shfolder.dll" );
if ( shfolder ) {
FreeLibrary( shfolder );
}
- if ( SHGetFolderPath( NULL, CSIDL_PERSONAL, NULL, 0, mydocsdir ) ) {
+ if ( SUCCEEDED( SHGetFolderPath( NULL, CSIDL_PERSONAL, NULL, 0, mydocsdir ) ) ) {
path.clear();
path << DirectoryCleaned( mydocsdir ) << "My Games/" << ( prefix + 1 ) << "/";
// win32: only add it if it already exists
break;
}
}
-#endif
-
-#if GDEF_OS_POSIX
+#elif GDEF_OS_XDG
+ path.clear();
+ 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 ReferenceCaller<CopiedString, void(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( makeCallbackF(Paths_constructPage) );
}
{
public:
ui::Window BuildDialog(){
- auto frame = create_dialog_frame( "Path settings", ui::Shadow::ETCHED_IN );
+ auto frame = create_dialog_frame( "Path Settings", ui::Shadow::ETCHED_IN );
auto vbox2 = create_dialog_vbox( 0, 4 );
frame.add(vbox2);
+ const char* engine;
+#if defined( WIN32 )
+ engine = g_pGameDescription->getRequiredKeyValue( "engine_win32" );
+#elif defined( __linux__ ) || defined ( __FreeBSD__ )
+ engine = g_pGameDescription->getRequiredKeyValue( "engine_linux" );
+#elif defined( __APPLE__ )
+ engine = g_pGameDescription->getRequiredKeyValue( "engine_macos" );
+#else
+#error "unsupported platform"
+#endif
+ StringOutputStream text( 256 );
+ text << "Select directory, where game executable sits (typically \"" << engine << "\")\n";
+ GtkLabel* label = GTK_LABEL( gtk_label_new( text.c_str() ) );
+ gtk_widget_show( GTK_WIDGET( label ) );
+ gtk_container_add( GTK_CONTAINER( vbox2 ), GTK_WIDGET( label ) );
+
{
- PreferencesPage preferencesPage( *this, vbox2 );
- Paths_constructPreferences( preferencesPage );
+ PreferencesPage page( *this, vbox2 );
+ Paths_constructBasicPreferences( page );
}
- return ui::Window(create_simple_modal_dialog_window( "Engine Path Not Found", m_modal, frame ));
+ return ui::Window(create_simple_modal_dialog_window( "Engine Path Configuration", m_modal, frame ));
}
};
PathsDialog g_PathsDialog;
+bool g_strEnginePath_was_empty_1st_start = false;
+
void EnginePath_verify(){
- if ( !file_exists( g_strEnginePath.c_str() ) ) {
+ if ( !file_exists( g_strEnginePath.c_str() ) || g_strEnginePath_was_empty_1st_start ) {
g_PathsDialog.Create();
g_PathsDialog.DoModal();
g_PathsDialog.Destroy();
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();
}
}
g_xywindow_globals.color_gridback = Vector3( 1.0f, 1.0f, 1.0f );
g_xywindow_globals.color_gridminor = Vector3( 0.75f, 0.75f, 0.75f );
g_xywindow_globals.color_gridmajor = Vector3( 0.5f, 0.5f, 0.5f );
- g_xywindow_globals.color_gridminor_alt = Vector3( 0.5f, 0.0f, 0.0f );
- g_xywindow_globals.color_gridmajor_alt = Vector3( 1.0f, 0.0f, 0.0f );
g_xywindow_globals.color_gridblock = Vector3( 0.0f, 0.0f, 1.0f );
g_xywindow_globals.color_gridtext = Vector3( 0.0f, 0.0f, 0.0f );
g_xywindow_globals.color_selbrushes = Vector3( 1.0f, 0.0f, 0.0f );
XY_UpdateAllWindows();
}
+/* 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;
ChooseColour( const GetColourCallback& get, const SetColourCallback& set )
: m_get( get ), m_set( set ){
}
+
void operator()(){
Vector3 colour;
m_get( colour );
};
-
void Colour_get( const Vector3& colour, Vector3& other ){
other = colour;
}
+
typedef ConstReferenceCaller<Vector3, void(Vector3&), Colour_get> ColourGetCaller;
void Colour_set( Vector3& colour, const Vector3& other ){
colour = other;
SceneChangeNotify();
}
+
typedef ReferenceCaller<Vector3, void(const Vector3&), Colour_set> ColourSetCaller;
void BrushColour_set( const Vector3& other ){
SetWorldspawnColour( g_xywindow_globals.color_brushes );
SceneChangeNotify();
}
+
typedef FreeCaller<void(const Vector3&), BrushColour_set> BrushColourSetCaller;
void ClipperColour_set( const Vector3& other ){
Brush_clipperColourChanged();
SceneChangeNotify();
}
+
typedef FreeCaller<void(const Vector3&), ClipperColour_set> ClipperColourSetCaller;
void TextureBrowserColour_get( Vector3& other ){
other = TextureBrowser_getBackgroundColour( GlobalTextureBrowser() );
}
+
typedef FreeCaller<void(Vector3&), TextureBrowserColour_get> TextureBrowserColourGetCaller;
void TextureBrowserColour_set( const Vector3& other ){
TextureBrowser_setBackgroundColour( GlobalTextureBrowser(), other );
}
+
typedef FreeCaller<void(const Vector3&), TextureBrowserColour_set> TextureBrowserColourSetCaller;
ChooseColour m_xyback;
ChooseColour m_gridmajor;
ChooseColour m_gridminor;
-ChooseColour m_gridmajor_alt;
-ChooseColour m_gridminor_alt;
ChooseColour m_gridtext;
ChooseColour m_gridblock;
ChooseColour m_cameraback;
m_xyback( ColourGetCaller( g_xywindow_globals.color_gridback ), ColourSetCaller( g_xywindow_globals.color_gridback ) ),
m_gridmajor( ColourGetCaller( g_xywindow_globals.color_gridmajor ), ColourSetCaller( g_xywindow_globals.color_gridmajor ) ),
m_gridminor( ColourGetCaller( g_xywindow_globals.color_gridminor ), ColourSetCaller( g_xywindow_globals.color_gridminor ) ),
- m_gridmajor_alt( ColourGetCaller( g_xywindow_globals.color_gridmajor_alt ), ColourSetCaller( g_xywindow_globals.color_gridmajor_alt ) ),
- m_gridminor_alt( ColourGetCaller( g_xywindow_globals.color_gridminor_alt ), ColourSetCaller( g_xywindow_globals.color_gridminor_alt ) ),
m_gridtext( ColourGetCaller( g_xywindow_globals.color_gridtext ), ColourSetCaller( g_xywindow_globals.color_gridtext ) ),
m_gridblock( ColourGetCaller( g_xywindow_globals.color_gridblock ), ColourSetCaller( g_xywindow_globals.color_gridblock ) ),
m_cameraback( ColourGetCaller( g_camwindow_globals.color_cameraback ), ColourSetCaller( g_camwindow_globals.color_cameraback ) ),
ui::MenuItem create_colours_menu(){
auto colours_menu_item = new_sub_menu_item_with_mnemonic( "Colors" );
- auto menu_in_menu = ui::Menu(GTK_MENU( gtk_menu_item_get_submenu( colours_menu_item ) ));
+ auto menu_in_menu = ui::Menu::from( gtk_menu_item_get_submenu( colours_menu_item ) );
if ( g_Layout_enableDetachableMenus.m_value ) {
menu_tearoff( menu_in_menu );
}
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");
+
+#ifndef GARUX_DISABLE_GTKTHEME
+ create_menu_item_with_mnemonic( menu_in_menu, "GTK Theme...", "gtkThemeDlg" );
+#endif
menu_separator( menu_in_menu );
create_menu_item_with_mnemonic( menu_in_menu, "_Texture Background...", "ChooseTextureBackgroundColor" );
+ create_menu_item_with_mnemonic( menu_in_menu, "Camera Background...", "ChooseCameraBackgroundColor" );
create_menu_item_with_mnemonic( menu_in_menu, "Grid Background...", "ChooseGridBackgroundColor" );
create_menu_item_with_mnemonic( menu_in_menu, "Grid Major...", "ChooseGridMajorColor" );
create_menu_item_with_mnemonic( menu_in_menu, "Grid Minor...", "ChooseGridMinorColor" );
- create_menu_item_with_mnemonic( menu_in_menu, "Grid Major Small...", "ChooseSmallGridMajorColor" );
- create_menu_item_with_mnemonic( menu_in_menu, "Grid Minor Small...", "ChooseSmallGridMinorColor" );
create_menu_item_with_mnemonic( menu_in_menu, "Grid Text...", "ChooseGridTextColor" );
create_menu_item_with_mnemonic( menu_in_menu, "Grid Block...", "ChooseGridBlockColor" );
- create_menu_item_with_mnemonic( menu_in_menu, "Default Brush...", "ChooseBrushColor" );
- create_menu_item_with_mnemonic( menu_in_menu, "Camera Background...", "ChooseCameraBackgroundColor" );
- create_menu_item_with_mnemonic( menu_in_menu, "Selected Brush...", "ChooseSelectedBrushColor" );
+ create_menu_item_with_mnemonic( menu_in_menu, "Default Brush (2D)...", "ChooseBrushColor" );
+ create_menu_item_with_mnemonic( menu_in_menu, "Selected Brush and Sizing (2D)...", "ChooseSelectedBrushColor" );
create_menu_item_with_mnemonic( menu_in_menu, "Selected Brush (Camera)...", "ChooseCameraSelectedBrushColor" );
create_menu_item_with_mnemonic( menu_in_menu, "Clipper...", "ChooseClipperColor" );
- create_menu_item_with_mnemonic( menu_in_menu, "Active View name...", "ChooseOrthoViewNameColor" );
+ create_menu_item_with_mnemonic( menu_in_menu, "Active View Name and Outline...", "ChooseOrthoViewNameColor" );
return colours_menu_item;
}
}
-
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 FreeCaller<void(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 FreeCaller<void(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 FreeCaller<void(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;
&& selectable->isSelected() ) {
return false;
}
+ if( doMakeUnique && instance.childSelected() ){
+ NodeSmartReference clone( Node_Clone_Selected( path.top() ) );
+ Map_gatherNamespaced( clone );
+ Node_getTraversable( path.parent().get() )->insert( clone );
+ return false;
+ }
}
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_ ){
}
return Vector3( 0, 0, 0 );
}
+bool g_bNudgeAfterClone = false;
+
+void Nudge_constructPreferences( PreferencesPage& page ){
+ page.appendCheckBox( "", "Nudge selected after duplication", g_bNudgeAfterClone );
+}
+
void NudgeSelection( ENudgeDirection direction, float fAmount, VIEWTYPE viewtype ){
AxisBase axes( AxisBase_forViewType( viewtype ) );
Vector3 view_direction( vector3_negated( axes.z ) );
Scene_Clone_Selected( GlobalSceneGraph(), false );
- //NudgeSelection(eNudgeRight, GetGridSize(), GlobalXYWnd_getCurrentViewType());
- //NudgeSelection(eNudgeDown, GetGridSize(), GlobalXYWnd_getCurrentViewType());
+ if( g_bNudgeAfterClone ){
+ NudgeSelection(eNudgeRight, GetGridSize(), GlobalXYWnd_getCurrentViewType());
+ NudgeSelection(eNudgeDown, GetGridSize(), GlobalXYWnd_getCurrentViewType());
+ }
}
}
Scene_Clone_Selected( GlobalSceneGraph(), true );
- //NudgeSelection(eNudgeRight, GetGridSize(), GlobalXYWnd_getCurrentViewType());
- //NudgeSelection(eNudgeDown, GetGridSize(), GlobalXYWnd_getCurrentViewType());
+ if( g_bNudgeAfterClone ){
+ NudgeSelection(eNudgeRight, GetGridSize(), GlobalXYWnd_getCurrentViewType());
+ NudgeSelection(eNudgeDown, GetGridSize(), GlobalXYWnd_getCurrentViewType());
+ }
}
}
}
-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 );
}
-FreeCaller<void(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 );
-FreeCaller<void(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 );
-FreeCaller<void(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 );
-FreeCaller<void(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 );
-FreeCaller<void(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(){
}
+void ToggleRotateScaleModes(){
+ if ( g_currentToolMode == RotateMode ) {
+ ScaleMode();
+ }
+ else
+ {
+ RotateMode();
+ }
+}
+
+void ToggleDragScaleModes(){
+ if ( g_currentToolMode == DragMode ) {
+ ScaleMode();
+ }
+ else
+ {
+ DragMode();
+ }
+}
+
+
void Texdef_Rotate( float angle ){
StringOutputStream command;
command << "brushRotateTexture -angle " << angle;
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();
bool isActiveApp = MainFrame_isActiveApp();
g_wait = create_wait_dialog( title, message );
- gtk_grab_add( g_wait.m_window );
if ( isActiveApp ) {
g_wait.m_window.show();
+ gtk_grab_add( g_wait.m_window );
ScreenUpdates_process();
}
}
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 );
}
-
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_enableMainToolbar( true, "Main Toolbar" );
+LatchedValue<bool> g_Layout_enablePatchToolbar( true, "Patch Toolbar" );
+LatchedValue<bool> g_Layout_enablePluginToolbar( true, "Plugin Toolbar" );
+LatchedValue<bool> g_Layout_enableFilterToolbar( true, "Filter Toolbar" );
ui::MenuItem create_file_menu(){
// File menu
auto file_menu_item = new_sub_menu_item_with_mnemonic( "_File" );
- auto menu = ui::Menu(GTK_MENU( gtk_menu_item_get_submenu( file_menu_item ) ));
+ auto menu = ui::Menu::from( gtk_menu_item_get_submenu( file_menu_item ) );
if ( g_Layout_enableDetachableMenus.m_value ) {
menu_tearoff( menu );
}
#endif
create_menu_item_with_mnemonic( menu, "_Open...", "OpenMap" );
-
create_menu_item_with_mnemonic( menu, "_Import...", "ImportMap" );
+ menu_separator( menu );
create_menu_item_with_mnemonic( menu, "_Save", "SaveMap" );
create_menu_item_with_mnemonic( menu, "Save _as...", "SaveMapAs" );
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 );
- create_menu_item_with_mnemonic( menu, "_Refresh models", "RefreshReferences" );
- menu_separator( menu );
+// menu_separator( menu );
+// create_menu_item_with_mnemonic( menu, "_Refresh models", "RefreshReferences" );
+// menu_separator( menu );
create_menu_item_with_mnemonic( menu, "Pro_ject settings...", "ProjectSettings" );
- menu_separator( menu );
- create_menu_item_with_mnemonic( menu, "_Pointfile...", "TogglePointfile" );
+ //menu_separator( menu );
+ create_menu_item_with_mnemonic( menu, "_Pointfile", "TogglePointfile" );
menu_separator( menu );
MRU_constructMenu( menu );
menu_separator( menu );
+// create_menu_item_with_mnemonic( menu, "Check for NetRadiant update (web)", "CheckForUpdate" ); // FIXME
create_menu_item_with_mnemonic( menu, "E_xit", "Exit" );
return file_menu_item;
ui::MenuItem create_edit_menu(){
// Edit menu
auto edit_menu_item = new_sub_menu_item_with_mnemonic( "_Edit" );
- auto menu = ui::Menu(GTK_MENU( gtk_menu_item_get_submenu( edit_menu_item ) ));
+ auto menu = ui::Menu::from( gtk_menu_item_get_submenu( edit_menu_item ) );
if ( g_Layout_enableDetachableMenus.m_value ) {
menu_tearoff( menu );
}
create_menu_item_with_mnemonic( menu, "_Duplicate", "CloneSelection" );
create_menu_item_with_mnemonic( menu, "Duplicate, make uni_que", "CloneSelectionAndMakeUnique" );
create_menu_item_with_mnemonic( menu, "D_elete", "DeleteSelection" );
- menu_separator( menu );
- create_menu_item_with_mnemonic( menu, "Pa_rent", "ParentSelection" );
+ //create_menu_item_with_mnemonic( menu, "Pa_rent", "ParentSelection" );
menu_separator( menu );
create_menu_item_with_mnemonic( menu, "C_lear Selection", "UnSelectSelection" );
create_menu_item_with_mnemonic( menu, "_Invert Selection", "InvertSelection" );
create_menu_item_with_mnemonic( menu, "Select i_nside", "SelectInside" );
create_menu_item_with_mnemonic( menu, "Select _touching", "SelectTouching" );
- auto convert_menu = create_sub_menu_with_mnemonic( menu, "E_xpand Selection" );
- if ( g_Layout_enableDetachableMenus.m_value ) {
- menu_tearoff( convert_menu );
- }
- create_menu_item_with_mnemonic( convert_menu, "To Whole _Entities", "ExpandSelectionToEntities" );
+ menu_separator( menu );
+
+// auto convert_menu = create_sub_menu_with_mnemonic( menu, "E_xpand Selection" );
+// if ( g_Layout_enableDetachableMenus.m_value ) {
+// menu_tearoff( convert_menu );
+// }
+ create_menu_item_with_mnemonic( menu, "Select All Of Type", "SelectAllOfType" );
+ create_menu_item_with_mnemonic( menu, "_Expand Selection To Entities", "ExpandSelectionToEntities" );
+ create_menu_item_with_mnemonic( menu, "Select Connected Entities", "SelectConnectedEntities" );
menu_separator( menu );
create_menu_item_with_mnemonic( menu, "Pre_ferences...", "Preferences" );
return edit_menu_item;
}
-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( ui::Menu menu ){
- create_check_menu_item_with_mnemonic( menu, "YZ (Side) View", "ToggleSideView" );
-}
-
-
-void fill_view_xz_front_menu( ui::Menu menu ){
- create_check_menu_item_with_mnemonic( menu, "XZ (Front) View", "ToggleFrontView" );
-}
-
ui::Widget g_toggle_z_item{ui::null};
ui::Widget g_toggle_console_item{ui::null};
ui::MenuItem create_view_menu( MainFrame::EViewStyle style ){
// View menu
auto view_menu_item = new_sub_menu_item_with_mnemonic( "Vie_w" );
- auto menu = ui::Menu(GTK_MENU( gtk_menu_item_get_submenu( view_menu_item ) ));
+ auto menu = ui::Menu::from( gtk_menu_item_get_submenu( view_menu_item ) );
if ( g_Layout_enableDetachableMenus.m_value ) {
menu_tearoff( menu );
}
if ( style == MainFrame::eFloating ) {
- fill_view_camera_menu( menu );
- fill_view_xy_top_menu( menu );
- fill_view_yz_side_menu( menu );
- fill_view_xz_front_menu( menu );
+ create_check_menu_item_with_mnemonic( menu, "Camera View", "ToggleCamera" );
+ create_check_menu_item_with_mnemonic( menu, "XY (Top) View", "ToggleView" );
+ create_check_menu_item_with_mnemonic( menu, "XZ (Front) View", "ToggleFrontView" );
+ create_check_menu_item_with_mnemonic( menu, "YZ (Side) View", "ToggleSideView" );
}
if ( style == MainFrame::eFloating || style == MainFrame::eSplit ) {
- create_menu_item_with_mnemonic( menu, "Console View", "ToggleConsole" );
+ create_menu_item_with_mnemonic( menu, "Console", "ToggleConsole" );
create_menu_item_with_mnemonic( menu, "Texture Browser", "ToggleTextures" );
create_menu_item_with_mnemonic( menu, "Entity Inspector", "ToggleEntityInspector" );
}
create_menu_item_with_mnemonic( menu, "Entity Inspector", "ViewEntityInfo" );
}
create_menu_item_with_mnemonic( menu, "_Surface Inspector", "SurfaceInspector" );
+ create_menu_item_with_mnemonic( menu, "_Patch Inspector", "PatchInspector" );
create_menu_item_with_mnemonic( menu, "Entity List", "EntityList" );
menu_separator( menu );
if ( g_Layout_enableDetachableMenus.m_value ) {
menu_tearoff( camera_menu );
}
+ create_menu_item_with_mnemonic( camera_menu, "Focus on Selected", "CameraFocusOnSelected" );
create_menu_item_with_mnemonic( camera_menu, "_Center", "CenterView" );
create_menu_item_with_mnemonic( camera_menu, "_Up Floor", "UpFloor" );
create_menu_item_with_mnemonic( camera_menu, "_Down Floor", "DownFloor" );
create_menu_item_with_mnemonic( camera_menu, "Far Clip Plane In", "CubicClipZoomIn" );
create_menu_item_with_mnemonic( camera_menu, "Far Clip Plane Out", "CubicClipZoomOut" );
menu_separator( camera_menu );
+ create_menu_item_with_mnemonic( camera_menu, "Decrease FOV", "FOVDec" );
+ create_menu_item_with_mnemonic( camera_menu, "Increase FOV", "FOVInc" );
+ menu_separator( camera_menu );
create_menu_item_with_mnemonic( camera_menu, "Next leak spot", "NextLeakSpot" );
create_menu_item_with_mnemonic( camera_menu, "Previous leak spot", "PrevLeakSpot" );
- menu_separator( camera_menu );
- create_menu_item_with_mnemonic( camera_menu, "Look Through Selected", "LookThroughSelected" );
- create_menu_item_with_mnemonic( camera_menu, "Look Through Camera", "LookThroughCamera" );
+ //cameramodel is not implemented in instances, thus useless
+// menu_separator( camera_menu );
+// create_menu_item_with_mnemonic( camera_menu, "Look Through Selected", "LookThroughSelected" );
+// create_menu_item_with_mnemonic( camera_menu, "Look Through Camera", "LookThroughCamera" );
}
menu_separator( menu );
{
if ( style == MainFrame::eRegular || style == MainFrame::eRegularLeft || style == MainFrame::eFloating ) {
create_menu_item_with_mnemonic( orthographic_menu, "_Next (XY, YZ, XY)", "NextView" );
create_menu_item_with_mnemonic( orthographic_menu, "XY (Top)", "ViewTop" );
- create_menu_item_with_mnemonic( orthographic_menu, "YZ", "ViewSide" );
- create_menu_item_with_mnemonic( orthographic_menu, "XZ", "ViewFront" );
+ create_menu_item_with_mnemonic( orthographic_menu, "XZ (Front)", "ViewFront" );
+ create_menu_item_with_mnemonic( orthographic_menu, "YZ (Side)", "ViewSide" );
menu_separator( orthographic_menu );
}
+ else{
+ create_menu_item_with_mnemonic( orthographic_menu, "Center on Selected", "NextView" );
+ }
+ create_menu_item_with_mnemonic( orthographic_menu, "Focus on Selected", "XYFocusOnSelected" );
+ create_menu_item_with_mnemonic( orthographic_menu, "Center on Selected", "CenterXYView" );
+ menu_separator( orthographic_menu );
create_menu_item_with_mnemonic( orthographic_menu, "_XY 100%", "Zoom100" );
create_menu_item_with_mnemonic( orthographic_menu, "XY Zoom _In", "ZoomIn" );
create_menu_item_with_mnemonic( orthographic_menu, "XY Zoom _Out", "ZoomOut" );
if ( g_Layout_enableDetachableMenus.m_value ) {
menu_tearoff( menu_in_menu );
}
- create_check_menu_item_with_mnemonic( menu_in_menu, "Show _Angles", "ShowAngles" );
- create_check_menu_item_with_mnemonic( menu_in_menu, "Show _Names", "ShowNames" );
+ create_check_menu_item_with_mnemonic( menu_in_menu, "Show Entity _Angles", "ShowAngles" );
+ create_check_menu_item_with_mnemonic( menu_in_menu, "Show Entity _Names", "ShowNames" );
+ create_check_menu_item_with_mnemonic( menu_in_menu, "Entity Names = Targetnames", "ShowTargetNames" );
+ create_check_menu_item_with_mnemonic( menu_in_menu, "Show Light Radiuses", "ShowLightRadiuses" );
+
+ menu_separator( menu_in_menu );
+
+ create_check_menu_item_with_mnemonic( menu_in_menu, "Show Size Info", "ToggleSizePaint" );
+ create_check_menu_item_with_mnemonic( menu_in_menu, "Show Crosshair", "ToggleCrosshairs" );
+ create_check_menu_item_with_mnemonic( menu_in_menu, "Show Grid", "ToggleGrid" );
create_check_menu_item_with_mnemonic( menu_in_menu, "Show Blocks", "ShowBlocks" );
create_check_menu_item_with_mnemonic( menu_in_menu, "Show C_oordinates", "ShowCoordinates" );
create_check_menu_item_with_mnemonic( menu_in_menu, "Show Window Outline", "ShowWindowOutline" );
create_check_menu_item_with_mnemonic( menu_in_menu, "Show Axes", "ShowAxes" );
create_check_menu_item_with_mnemonic( menu_in_menu, "Show Workzone", "ShowWorkzone" );
- create_check_menu_item_with_mnemonic( menu_in_menu, "Show Stats", "ShowStats" );
+ create_check_menu_item_with_mnemonic( menu_in_menu, "Show Camera Stats", "ShowStats" );
}
{
}
menu_separator( menu );
{
- auto menu_in_menu = create_sub_menu_with_mnemonic( menu, "Hide/Show" );
- if ( g_Layout_enableDetachableMenus.m_value ) {
- menu_tearoff( menu_in_menu );
- }
- create_menu_item_with_mnemonic( menu_in_menu, "Hide Selected", "HideSelected" );
- create_menu_item_with_mnemonic( menu_in_menu, "Show Hidden", "ShowHidden" );
+ create_check_menu_item_with_mnemonic( menu, "Hide Selected", "HideSelected" );
+ create_menu_item_with_mnemonic( menu, "Show Hidden", "ShowHidden" );
}
menu_separator( menu );
{
create_menu_item_with_mnemonic( menu_in_menu, "_Off", "RegionOff" );
create_menu_item_with_mnemonic( menu_in_menu, "_Set XY", "RegionSetXY" );
create_menu_item_with_mnemonic( menu_in_menu, "Set _Brush", "RegionSetBrush" );
- create_menu_item_with_mnemonic( menu_in_menu, "Set Se_lected Brushes", "RegionSetSelection" );
+ create_check_menu_item_with_mnemonic( menu_in_menu, "Set Se_lected Brushes", "RegionSetSelection" );
}
- command_connect_accelerator( "CenterXYView" );
+ //command_connect_accelerator( "CenterXYView" );
return view_menu_item;
}
ui::MenuItem create_selection_menu(){
// Selection menu
auto selection_menu_item = new_sub_menu_item_with_mnemonic( "M_odify" );
- auto menu = ui::Menu(GTK_MENU( gtk_menu_item_get_submenu( selection_menu_item ) ));
+ auto menu = ui::Menu::from( gtk_menu_item_get_submenu( selection_menu_item ) );
if ( g_Layout_enableDetachableMenus.m_value ) {
menu_tearoff( menu );
}
create_check_menu_item_with_mnemonic( menu_in_menu, "_Faces", "DragFaces" );
}
+ menu_separator( menu );
+ create_menu_item_with_mnemonic( menu, "Snap To Grid", "SnapToGrid" );
+
menu_separator( menu );
{
create_menu_item_with_mnemonic( menu_in_menu, "Nudge Right", "SelectNudgeRight" );
create_menu_item_with_mnemonic( menu_in_menu, "Nudge Up", "SelectNudgeUp" );
create_menu_item_with_mnemonic( menu_in_menu, "Nudge Down", "SelectNudgeDown" );
+ menu_separator( menu_in_menu );
+ create_menu_item_with_mnemonic( menu_in_menu, "Nudge +Z", "MoveSelectionUP" );
+ create_menu_item_with_mnemonic( menu_in_menu, "Nudge -Z", "MoveSelectionDOWN" );
}
{
auto menu_in_menu = create_sub_menu_with_mnemonic( menu, "Rotate" );
create_menu_item_with_mnemonic( menu_in_menu, "Rotate X", "RotateSelectionX" );
create_menu_item_with_mnemonic( menu_in_menu, "Rotate Y", "RotateSelectionY" );
create_menu_item_with_mnemonic( menu_in_menu, "Rotate Z", "RotateSelectionZ" );
+ menu_separator( menu_in_menu );
+ create_menu_item_with_mnemonic( menu_in_menu, "Rotate Clockwise", "RotateSelectionClockwise" );
+ create_menu_item_with_mnemonic( menu_in_menu, "Rotate Anticlockwise", "RotateSelectionAnticlockwise" );
}
{
auto menu_in_menu = create_sub_menu_with_mnemonic( menu, "Flip" );
create_menu_item_with_mnemonic( menu_in_menu, "Flip _X", "MirrorSelectionX" );
create_menu_item_with_mnemonic( menu_in_menu, "Flip _Y", "MirrorSelectionY" );
create_menu_item_with_mnemonic( menu_in_menu, "Flip _Z", "MirrorSelectionZ" );
+ menu_separator( menu_in_menu );
+ create_menu_item_with_mnemonic( menu_in_menu, "Flip Horizontally", "MirrorSelectionHorizontally" );
+ create_menu_item_with_mnemonic( menu_in_menu, "Flip Vertically", "MirrorSelectionVertically" );
}
menu_separator( menu );
create_menu_item_with_mnemonic( menu, "Arbitrary rotation...", "ArbitraryRotation" );
ui::MenuItem create_bsp_menu(){
// BSP menu
auto bsp_menu_item = new_sub_menu_item_with_mnemonic( "_Build" );
- auto menu = ui::Menu(GTK_MENU( gtk_menu_item_get_submenu( bsp_menu_item ) ));
+ auto menu = ui::Menu::from( gtk_menu_item_get_submenu( bsp_menu_item ) );
if ( g_Layout_enableDetachableMenus.m_value ) {
menu_tearoff( menu );
}
create_menu_item_with_mnemonic( menu, "Customize...", "BuildMenuCustomize" );
+ create_menu_item_with_mnemonic( menu, "Run recent build", "Build_runRecentExecutedBuild" );
menu_separator( menu );
ui::MenuItem create_grid_menu(){
// Grid menu
auto grid_menu_item = new_sub_menu_item_with_mnemonic( "_Grid" );
- auto menu = ui::Menu(GTK_MENU( gtk_menu_item_get_submenu( grid_menu_item ) ));
+ auto menu = ui::Menu::from( gtk_menu_item_get_submenu( grid_menu_item ) );
if ( g_Layout_enableDetachableMenus.m_value ) {
menu_tearoff( menu );
}
ui::MenuItem create_misc_menu(){
// Misc menu
auto misc_menu_item = new_sub_menu_item_with_mnemonic( "M_isc" );
- auto menu = ui::Menu(GTK_MENU( gtk_menu_item_get_submenu( misc_menu_item ) ));
+ auto menu = ui::Menu::from( gtk_menu_item_get_submenu( misc_menu_item ) );
if ( g_Layout_enableDetachableMenus.m_value ) {
menu_tearoff( menu );
}
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<void(), WXY_Print>());
- create_menu_item_with_mnemonic( menu, "_Background select", makeCallbackF(WXY_BackgroundSelect) );
+// create_menu_item_with_mnemonic(menu, "_Print XY View", makeCallbackF( WXY_Print ));
+ create_menu_item_with_mnemonic( menu, "_Background image...", makeCallbackF(WXY_BackgroundSelect) );
+ create_menu_item_with_mnemonic( menu, "Fullscreen", "Fullscreen" );
+ create_menu_item_with_mnemonic( menu, "Maximize view", "MaximizeView" );
return misc_menu_item;
}
ui::MenuItem create_entity_menu(){
// Brush menu
auto entity_menu_item = new_sub_menu_item_with_mnemonic( "E_ntity" );
- auto menu = ui::Menu(GTK_MENU( gtk_menu_item_get_submenu( entity_menu_item ) ));
+ auto menu = ui::Menu::from( gtk_menu_item_get_submenu( entity_menu_item ) );
if ( g_Layout_enableDetachableMenus.m_value ) {
menu_tearoff( menu );
}
ui::MenuItem create_brush_menu(){
// Brush menu
auto brush_menu_item = new_sub_menu_item_with_mnemonic( "B_rush" );
- auto menu = ui::Menu(GTK_MENU( gtk_menu_item_get_submenu( brush_menu_item ) ));
+ auto menu = ui::Menu::from( gtk_menu_item_get_submenu( brush_menu_item ) );
if ( g_Layout_enableDetachableMenus.m_value ) {
menu_tearoff( menu );
}
ui::MenuItem create_patch_menu(){
// Curve menu
auto patch_menu_item = new_sub_menu_item_with_mnemonic( "_Curve" );
- auto menu = ui::Menu(GTK_MENU( gtk_menu_item_get_submenu( patch_menu_item ) ));
+ auto menu = ui::Menu::from( gtk_menu_item_get_submenu( patch_menu_item ) );
if ( g_Layout_enableDetachableMenus.m_value ) {
menu_tearoff( menu );
}
ui::MenuItem create_help_menu(){
// Help menu
auto help_menu_item = new_sub_menu_item_with_mnemonic( "_Help" );
- auto menu = ui::Menu(GTK_MENU( gtk_menu_item_get_submenu( help_menu_item ) ));
+ auto menu = ui::Menu::from( gtk_menu_item_get_submenu( help_menu_item ) );
if ( g_Layout_enableDetachableMenus.m_value ) {
menu_tearoff( menu );
}
- create_menu_item_with_mnemonic( menu, "Manual", "OpenManual" );
+// create_menu_item_with_mnemonic( menu, "Manual", "OpenManual" );
// this creates all the per-game drop downs for the game pack helps
// it will take care of hooking the Sys_OpenURL calls etc.
create_game_help_menu( menu );
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) );
+ create_menu_item_with_mnemonic( menu, "Shortcuts", makeCallbackF(DoCommandListDlg) );
+ create_menu_item_with_mnemonic( menu, "_About...", makeCallbackF(DoAbout) );
return help_menu_item;
}
ui::MenuBar create_main_menu( MainFrame::EViewStyle style ){
- auto menu_bar = ui::MenuBar(GTK_MENU_BAR( gtk_menu_bar_new() ));
+ auto menu_bar = ui::MenuBar::from( gtk_menu_bar_new() );
menu_bar.show();
menu_bar.add(create_file_menu());
command_connect_accelerator( "PatchDeleteLastColumn" );
command_connect_accelerator( "PatchDeleteLastRow" );
command_connect_accelerator( "NaturalizePatch" );
- //command_connect_accelerator("CapCurrentCurve");
+ command_connect_accelerator( "CapCurrentCurve");
}
void Manipulators_registerShortcuts(){
}
void SelectNudge_registerShortcuts(){
- command_connect_accelerator( "MoveSelectionDOWN" );
- command_connect_accelerator( "MoveSelectionUP" );
+ //command_connect_accelerator( "MoveSelectionDOWN" );
+ //command_connect_accelerator( "MoveSelectionUP" );
//command_connect_accelerator("SelectNudgeLeft");
//command_connect_accelerator("SelectNudgeRight");
//command_connect_accelerator("SelectNudgeUp");
//command_connect_accelerator("SelectNudgeDown");
+ command_connect_accelerator( "UnSelectSelection2" );
+ command_connect_accelerator( "DeleteSelection2" );
}
void SnapToGrid_registerShortcuts(){
command_connect_accelerator( "FitTexture" );
}
+void TexBro_registerShortcuts(){
+ command_connect_accelerator( "FindReplaceTextures" );
+ command_connect_accelerator( "RefreshShaders" );
+}
+
+void Misc_registerShortcuts(){
+ //refresh models
+ command_connect_accelerator( "RefreshReferences" );
+ command_connect_accelerator( "MouseRotateOrScale" );
+ command_connect_accelerator( "MouseDragOrScale" );
+}
+
void register_shortcuts(){
- PatchInspector_registerShortcuts();
- Patch_registerShortcuts();
+// PatchInspector_registerShortcuts();
+ //Patch_registerShortcuts();
Grid_registerShortcuts();
- XYWnd_registerShortcuts();
+// XYWnd_registerShortcuts();
CamWnd_registerShortcuts();
Manipulators_registerShortcuts();
SurfaceInspector_registerShortcuts();
TexdefNudge_registerShortcuts();
SelectNudge_registerShortcuts();
- SnapToGrid_registerShortcuts();
- SelectByType_registerShortcuts();
+// SnapToGrid_registerShortcuts();
+// SelectByType_registerShortcuts();
+ TexBro_registerShortcuts();
+ Misc_registerShortcuts();
}
void File_constructToolbar( ui::Toolbar 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, "y-axis Rotate", "brush_rotatey.png", "RotateSelectionY" );
- toolbar_append_button( toolbar, "z-axis Flip", "brush_flipz.png", "MirrorSelectionZ" );
- toolbar_append_button( toolbar, "z-axis Rotate", "brush_rotatez.png", "RotateSelectionZ" );
+// 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, "y-axis Rotate", "brush_rotatey.png", "RotateSelectionY" );
+// toolbar_append_button( toolbar, "z-axis Flip", "brush_flipz.png", "MirrorSelectionZ" );
+// toolbar_append_button( toolbar, "z-axis Rotate", "brush_rotatez.png", "RotateSelectionZ" );
+ toolbar_append_button( toolbar, "Flip Horizontally", "brush_flip_hor.png", "MirrorSelectionHorizontally" );
+ toolbar_append_button( toolbar, "Flip Vertically", "brush_flip_vert.png", "MirrorSelectionVertically" );
+
+ toolbar_append_button( toolbar, "Rotate Clockwise", "brush_rotate_clock.png", "RotateSelectionClockwise" );
+ toolbar_append_button( toolbar, "Rotate Anticlockwise", "brush_rotate_anti.png", "RotateSelectionAnticlockwise" );
}
void Select_constructToolbar( ui::Toolbar 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 Room", "selection_makeroom.png", "CSGRoom" );
+ toolbar_append_button( toolbar, "CSG Tool", "ellipsis.png", "CSGTool" );
}
void ComponentModes_constructToolbar( ui::Toolbar toolbar ){
}
void XYWnd_constructToolbar( ui::Toolbar toolbar ){
- toolbar_append_button( toolbar, "Change views", "view_change.png", "NextView" );
+ toolbar_append_button( toolbar, "Change views (CTRL + TAB)", "view_change.png", "NextView" );
}
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" );
+ toolbar_append_toggle_button( toolbar, "Scale (Q)", "select_mousescale.png", "MouseScale" );
toolbar_append_toggle_button( toolbar, "Resize (Q)", "select_mouseresize.png", "MouseDrag" );
Clipper_constructToolbar( toolbar );
}
ui::Toolbar create_main_toolbar( MainFrame::EViewStyle style ){
- auto toolbar = ui::Toolbar(GTK_TOOLBAR( gtk_toolbar_new() ));
+ auto toolbar = ui::Toolbar::from( gtk_toolbar_new() );
gtk_orientable_set_orientation( GTK_ORIENTABLE(toolbar), GTK_ORIENTATION_HORIZONTAL );
gtk_toolbar_set_style( toolbar, GTK_TOOLBAR_ICONS );
-
+// gtk_toolbar_set_show_arrow( toolbar, TRUE );
+ //gtk_orientable_set_orientation( GTK_ORIENTABLE( toolbar ), GTK_ORIENTATION_HORIZONTAL );
+ //toolbar_append_space( toolbar );
toolbar.show();
auto space = [&]() {
- auto btn = ui::ToolItem(gtk_separator_tool_item_new());
+ auto btn = ui::ToolItem::from(gtk_separator_tool_item_new());
btn.show();
toolbar.add(btn);
};
ComponentModes_constructToolbar( toolbar );
- if ( style == MainFrame::eRegular || style == MainFrame::eRegularLeft || style == MainFrame::eFloating ) {
+ if ( style != MainFrame::eSplit ) {
space();
XYWnd_constructToolbar( toolbar );
space();
- toolbar_append_toggle_button( toolbar, "Texture Lock (SHIFT +T)", "texture_lock.png", "TogTexLock" );
+ toolbar_append_toggle_button( toolbar, "Texture Lock (SHIFT + T)", "texture_lock.png", "TogTexLock" );
space();
- /*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" );
+ toolbar_append_button( toolbar, "Entities (N)", "entities.png", "ToggleEntityInspector" );
+ // disable the console and texture button in the regular layouts
+ if ( style != MainFrame::eRegular && style != MainFrame::eRegularLeft ) {
+ toolbar_append_button( toolbar, "Console (O)", "console.png", "ToggleConsole" );
+ 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");
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( g_view_console_button , FALSE );
- gtk_widget_set_sensitive( g_view_textures_button , FALSE );
- }
+ toolbar_append_button( toolbar, "Refresh Models", "refresh_models.png", "RefreshReferences" );
return toolbar;
}
gtk_frame_set_shadow_type( frame, GTK_SHADOW_IN );
auto label = ui::Label( "Label" );
- gtk_label_set_ellipsize( label, PANGO_ELLIPSIZE_END );
+ if( i == c_texture_status )
+ gtk_label_set_ellipsize( label, PANGO_ELLIPSIZE_START );
+ else
+ 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 );
label.show();
return FALSE;
}
+
public:
void connect( ui::Window toplevel_window ){
toplevel_window.connect( "notify::is-active", G_CALLBACK( notify ), this );
for ( std::vector<ui::Widget>::iterator i = g_floating_windows.begin(); i != g_floating_windows.end(); ++i )
{
+#ifndef WORKAROUND_MACOS_GTK2_DESTROY
i->destroy();
+#endif
}
+#ifndef WORKAROUND_MACOS_GTK2_DESTROY
m_window.destroy();
+#endif
}
void MainFrame::SetActiveXY( XYWnd* p ){
ui::Window create_splash(){
- ui::Window window = ui::Window( ui::window_type::TOP );
- gtk_window_set_decorated( window, FALSE );
- gtk_window_set_resizable( window, FALSE );
- gtk_window_set_modal( window, TRUE );
+ auto window = ui::Window( ui::window_type::TOP );
+ gtk_window_set_decorated(window, false);
+ gtk_window_set_resizable(window, false);
+ gtk_window_set_modal(window, true);
gtk_window_set_default_size( window, -1, -1 );
gtk_window_set_position( window, GTK_WIN_POS_CENTER );
- gtk_container_set_border_width( GTK_CONTAINER( window ), 0 );
+ gtk_container_set_border_width(window, 0);
auto image = new_local_image( "splash.png" );
image.show();
window.add(image);
+#if GTK_TARGET == 2
+ if( gtk_image_get_storage_type( image ) == GTK_IMAGE_PIXBUF ){
+ GdkBitmap* mask;
+ GdkPixbuf* pix = gtk_image_get_pixbuf( image );
+ gdk_pixbuf_render_pixmap_and_mask( pix, NULL, &mask, 255 );
+ gtk_widget_shape_combine_mask ( GTK_WIDGET( window ), mask, 0, 0 );
+ }
+#endif
+
window.dimensions(-1, -1);
window.show();
WindowPositionTracker g_posYZWnd;
static gint mainframe_delete( ui::Widget widget, GdkEvent *event, gpointer data ){
- if ( ConfirmModified( "Exit Radiant" ) ) {
+ if ( ConfirmModified( "Exit " RADIANT_NAME ) ) {
gtk_main_quit();
}
return TRUE;
}
+PanedState g_single_hpaned = { 0.75f, -1, };
+PanedState g_single_vpaned = { 0.75f, -1, };
+
void MainFrame::Create(){
ui::Window window = ui::Window( ui::window_type::TOP );
auto vbox = ui::VBox( FALSE, 0 );
window.add(vbox);
vbox.show();
+ gtk_container_set_focus_chain( GTK_CONTAINER( vbox ), NULL );
global_accel_connect_window( window );
auto main_menu = create_main_menu( CurrentStyle() );
vbox.pack_start( main_menu, FALSE, FALSE, 0 );
- auto main_toolbar = create_main_toolbar( CurrentStyle() );
- vbox.pack_start( main_toolbar, FALSE, FALSE, 0 );
+ if( g_Layout_enableMainToolbar.m_value ){
+ GtkToolbar* main_toolbar = create_main_toolbar( CurrentStyle() );
+ gtk_box_pack_start( GTK_BOX( vbox ), GTK_WIDGET( main_toolbar ), FALSE, FALSE, 0 );
+ }
+
+ if ( g_Layout_enablePluginToolbar.m_value || g_Layout_enableFilterToolbar.m_value ){
+ auto PFbox = ui::HBox( FALSE, 3 );
+ vbox.pack_start( PFbox, FALSE, FALSE, 0 );
+ PFbox.show();
+ if ( g_Layout_enablePluginToolbar.m_value ){
+ auto plugin_toolbar = create_plugin_toolbar();
+ if ( g_Layout_enableFilterToolbar.m_value ){
+ PFbox.pack_start( plugin_toolbar, FALSE, FALSE, 0 );
+ // Force the toolbar to display all childrens
+ // without collapsing them to a menu.
+ gtk_toolbar_set_show_arrow( plugin_toolbar, FALSE );
+ }
+ else{
+ PFbox.pack_start( plugin_toolbar, TRUE, TRUE, 0 );
+ }
+ }
+ if ( g_Layout_enableFilterToolbar.m_value ){
+ ui::Toolbar filter_toolbar = create_filter_toolbar();
+ PFbox.pack_start( filter_toolbar, TRUE, TRUE, 0 );
+ }
+ }
- auto plugin_toolbar = create_plugin_toolbar();
+ /*GtkToolbar* plugin_toolbar = create_plugin_toolbar();
if ( !g_Layout_enablePluginToolbar.m_value ) {
- plugin_toolbar.hide();
- }
- vbox.pack_start( plugin_toolbar, FALSE, FALSE, 0 );
+ gtk_widget_hide( GTK_WIDGET( plugin_toolbar ) );
+ }*/
ui::Widget main_statusbar = create_main_statusbar(reinterpret_cast<ui::Widget *>(m_pStatusLabel));
vbox.pack_end(main_statusbar, FALSE, TRUE, 2);
GroupDialog_constructWindow( window );
+
+ /* want to realize it immediately; otherwise gtk paned splits positions wont be set correctly for floating group dlg */
+ gtk_widget_realize ( GTK_WIDGET( GroupDialog_getWindow() ) );
+
g_page_entity = GroupDialog_addPage( "Entities", EntityInspector_constructWindow( GroupDialog_getWindow() ), RawStringExportCaller( "Entities" ) );
if ( FloatingGroupDialog() ) {
#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 );
}
- else
#endif
- if ( g_layout_globals.nState & GDK_WINDOW_STATE_MAXIMIZED ) {
- gtk_window_maximize( window );
- WindowPosition default_position( -1, -1, 640, 480 );
- window_set_position( window, default_position );
- }
- else
- {
- window_set_position( window, g_layout_globals.m_position );
- }
+ window_set_position( window, g_layout_globals.m_position );
m_window = window;
window.show();
- if ( CurrentStyle() == eRegular || CurrentStyle() == eRegularLeft ) {
+ if ( CurrentStyle() == eRegular || CurrentStyle() == eRegularLeft )
+ {
{
- ui::Widget vsplit = ui::VPaned(ui::New);
- m_vSplit = vsplit;
- vbox.pack_start( vsplit, TRUE, TRUE, 0 );
- vsplit.show();
+ ui::Widget hsplit = ui::HPaned(ui::New);
+ m_hSplit = hsplit;
- // console
- ui::Widget console_window = Console_constructWindow( window );
- gtk_paned_pack2( GTK_PANED( vsplit ), console_window, FALSE, TRUE );
+ vbox.pack_start( hsplit, TRUE, TRUE, 0 );
+ hsplit.show();
{
- ui::Widget hsplit = ui::HPaned(ui::New);
- hsplit.show();
- m_hSplit = hsplit;
- gtk_paned_add1( GTK_PANED( vsplit ), hsplit );
+ ui::Widget vsplit = ui::VPaned(ui::New);
+ vsplit.show();
+ m_vSplit = vsplit;
+ ui::Widget vsplit2 = ui::VPaned(ui::New);
+ vsplit2.show();
+ m_vSplit2 = vsplit2;
+
+ if ( CurrentStyle() == eRegular ){
+ gtk_paned_pack1( GTK_PANED( hsplit ), vsplit, TRUE, TRUE );
+ gtk_paned_pack2( GTK_PANED( hsplit ), vsplit2, TRUE, TRUE );
+ }
+ else{
+ gtk_paned_pack2( GTK_PANED( hsplit ), vsplit, TRUE, TRUE );
+ gtk_paned_pack1( GTK_PANED( hsplit ), vsplit2, TRUE, TRUE );
+ }
+
+ // console
+ ui::Widget console_window = Console_constructWindow( window );
+ gtk_paned_pack2( GTK_PANED( vsplit ), console_window, TRUE, TRUE );
+
// xy
m_pXYWnd = new XYWnd();
m_pXYWnd->SetViewType( XY );
ui::Widget xy_window = ui::Widget(create_framed_widget( m_pXYWnd->GetWidget( ) ));
+ gtk_paned_pack1( GTK_PANED( vsplit ), xy_window, TRUE, TRUE );
{
- ui::Widget vsplit2 = ui::VPaned(ui::New);
- vsplit2.show();
- m_vSplit2 = vsplit2;
-
- if ( CurrentStyle() == eRegular ) {
- gtk_paned_add1( GTK_PANED( hsplit ), xy_window );
- gtk_paned_add2( GTK_PANED( hsplit ), vsplit2 );
- }
- else
- {
- gtk_paned_add1( GTK_PANED( hsplit ), vsplit2 );
- gtk_paned_add2( GTK_PANED( hsplit ), xy_window );
- }
-
-
// camera
m_pCamWnd = NewCamWnd();
GlobalCamera_setCamWnd( *m_pCamWnd );
CamWnd_setParent( *m_pCamWnd, window );
auto camera_window = create_framed_widget( CamWnd_getWidget( *m_pCamWnd ) );
- gtk_paned_add1( GTK_PANED( vsplit2 ), camera_window );
+ gtk_paned_pack1( GTK_PANED( vsplit2 ), GTK_WIDGET( camera_window ) , TRUE, TRUE);
// textures
auto texture_window = create_framed_widget( TextureBrowser_constructWindow( window ) );
- gtk_paned_add2( GTK_PANED( vsplit2 ), texture_window );
+ gtk_paned_pack2( GTK_PANED( vsplit2 ), GTK_WIDGET( texture_window ), TRUE, TRUE );
}
}
}
-
- gtk_paned_set_position( GTK_PANED( m_vSplit ), g_layout_globals.nXYHeight );
-
- if ( CurrentStyle() == eRegular ) {
- gtk_paned_set_position( GTK_PANED( m_hSplit ), g_layout_globals.nXYWidth );
- }
- else
- {
- gtk_paned_set_position( GTK_PANED( m_hSplit ), g_layout_globals.nCamWidth );
- }
-
- gtk_paned_set_position( GTK_PANED( m_vSplit2 ), g_layout_globals.nCamHeight );
}
- else if ( CurrentStyle() == eFloating ) {
+ else if ( CurrentStyle() == eFloating )
+ {
{
ui::Window window = ui::Window(create_persistent_floating_window( "Camera", m_window ));
global_accel_connect_window( window );
}
CamWnd_setParent( *m_pCamWnd, window );
+ WORKAROUND_GOBJECT_SET_GLWIDGET( window, CamWnd_getWidget( *m_pCamWnd ) );
+
g_floating_windows.push_back( window );
}
}
XY_Top_Shown_Construct( window );
+ WORKAROUND_GOBJECT_SET_GLWIDGET( window, m_pXYWnd->GetWidget() );
+
g_floating_windows.push_back( window );
}
XZ_Front_Shown_Construct( window );
+ WORKAROUND_GOBJECT_SET_GLWIDGET( window, m_pXZWnd->GetWidget() );
+
g_floating_windows.push_back( window );
}
YZ_Side_Shown_Construct( window );
+ WORKAROUND_GOBJECT_SET_GLWIDGET( window, m_pYZWnd->GetWidget() );
+
g_floating_windows.push_back( window );
}
{
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() );
}
+ // FIXME: find a way to do it with newer syntax
+ // m_vSplit = 0;
+ // m_hSplit = 0;
+ // m_vSplit2 = 0;
+
GroupDialog_show();
}
- else // 4 way
+ else if ( CurrentStyle() == eSplit )
{
m_pCamWnd = NewCamWnd();
GlobalCamera_setCamWnd( *m_pCamWnd );
ui::Widget xz = m_pXZWnd->GetWidget();
- auto split = create_split_views( camera, yz, xy, xz );
- vbox.pack_start( split, TRUE, TRUE, 0 );
+ m_hSplit = create_split_views( camera, xy, yz, xz, m_vSplit, m_vSplit2 );
+ vbox.pack_start( m_hSplit, TRUE, TRUE, 0 );
{
- auto frame = create_framed_widget( TextureBrowser_constructWindow( window ) );
+ auto frame = create_framed_widget( TextureBrowser_constructWindow( GroupDialog_getWindow() ) );
g_page_textures = GroupDialog_addPage( "Textures", frame, TextureBrowserExportTitleCaller() );
+
+ WORKAROUND_GOBJECT_SET_GLWIDGET( window, TextureBrowser_getGLWidget() );
}
}
+ else // single window
+ {
+ m_pCamWnd = NewCamWnd();
+ GlobalCamera_setCamWnd( *m_pCamWnd );
+ CamWnd_setParent( *m_pCamWnd, window );
+
+ ui::Widget camera = CamWnd_getWidget( *m_pCamWnd );
+
+ m_pYZWnd = new XYWnd();
+ m_pYZWnd->SetViewType( YZ );
+
+ ui::Widget yz = m_pYZWnd->GetWidget();
+
+ m_pXYWnd = new XYWnd();
+ m_pXYWnd->SetViewType( XY );
+
+ ui::Widget xy = m_pXYWnd->GetWidget();
+
+ m_pXZWnd = new XYWnd();
+ m_pXZWnd->SetViewType( XZ );
+
+ ui::Widget xz = m_pXZWnd->GetWidget();
+
+ ui::Widget hsplit = ui::HPaned(ui::New);
+ vbox.pack_start( hsplit, TRUE, TRUE, 0 );
+ hsplit.show();
+
+ /* Before merging NetRadiantCustom:
+ ui::Widget split = create_split_views( camera, xy, yz, xz ); */
+ m_hSplit = create_split_views( camera, xy, yz, xz, m_vSplit, m_vSplit2 );
+
+ ui::Widget vsplit = ui::VPaned(ui::New);
+ vsplit.show();
+
+ // textures
+ ui::Widget texture_window = create_framed_widget( TextureBrowser_constructWindow( window ) );
+
+ // console
+ ui::Widget console_window = create_framed_widget( Console_constructWindow( window ) );
+
+ /* Before merging NetRadiantCustom:
+ gtk_paned_add1( GTK_PANED( hsplit ), m_hSplit );
+ gtk_paned_add2( GTK_PANED( hsplit ), vsplit );
+
+ gtk_paned_add1( GTK_PANED( vsplit ), texture_window );
+ gtk_paned_add2( GTK_PANED( vsplit ), console_window );
+ */
+
+ gtk_paned_pack1( GTK_PANED( hsplit ), m_hSplit, TRUE, TRUE );
+ gtk_paned_pack2( GTK_PANED( hsplit ), vsplit, TRUE, TRUE);
+
+ gtk_paned_pack1( GTK_PANED( vsplit ), texture_window, TRUE, TRUE );
+ gtk_paned_pack2( GTK_PANED( vsplit ), console_window, TRUE, TRUE );
+
+ hsplit.connect( "size_allocate", G_CALLBACK( hpaned_allocate ), &g_single_hpaned );
+ hsplit.connect( "notify::position", G_CALLBACK( paned_position ), &g_single_hpaned );
+
+ vsplit.connect( "size_allocate", G_CALLBACK( vpaned_allocate ), &g_single_vpaned );
+ vsplit.connect( "notify::position", G_CALLBACK( paned_position ), &g_single_vpaned );
+ }
EntityList_constructWindow( window );
PreferencesDialog_constructWindow( window );
EverySecondTimer_enable();
+ if ( g_layout_globals.nState & GDK_WINDOW_STATE_MAXIMIZED ||
+ g_layout_globals.nState & GDK_WINDOW_STATE_ICONIFIED ) {
+ gtk_window_maximize( window );
+ }
+ if ( g_layout_globals.nState & GDK_WINDOW_STATE_FULLSCREEN ) {
+ gtk_window_fullscreen( window );
+ }
+
+ if ( !FloatingGroupDialog() ) {
+ gtk_paned_set_position( GTK_PANED( m_vSplit ), g_layout_globals.nXYHeight );
+
+ if ( CurrentStyle() == eRegular ) {
+ gtk_paned_set_position( GTK_PANED( m_hSplit ), g_layout_globals.nXYWidth );
+ }
+ else
+ {
+ gtk_paned_set_position( GTK_PANED( m_hSplit ), g_layout_globals.nCamWidth );
+ }
+
+ gtk_paned_set_position( GTK_PANED( m_vSplit2 ), g_layout_globals.nCamHeight );
+ }
//GlobalShortcuts_reportUnregistered();
}
g_layout_globals.nCamHeight = gtk_paned_get_position( GTK_PANED( m_vSplit2 ) );
}
- g_layout_globals.m_position = m_position_tracker.getPosition();
+ if( gdk_window_get_state( gtk_widget_get_window( GTK_WIDGET( m_window ) ) ) == 0 ){
+ g_layout_globals.m_position = m_position_tracker.getPosition();
+ }
g_layout_globals.nState = gdk_window_get_state( gtk_widget_get_window(m_window ) );
}
}
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();
}
}
void Layout_constructPreferences( PreferencesPage& page ){
{
- const char* layouts[] = { "window1.png", "window2.png", "window3.png", "window4.png" };
+ const char* layouts[] = { "window1.png", "window2.png", "window3.png", "window4.png", "window5.png" };
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 )
+ );
+ page.appendCheckBox(
+ "", "Main Toolbar",
+ make_property( g_Layout_enableMainToolbar )
);
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 )
+ );
+ page.appendCheckBox(
+ "", "Filter Toolbar",
+ make_property( g_Layout_enableFilterToolbar )
);
}
PreferencesDialog_addInterfacePage( makeCallbackF(Layout_constructPage) );
}
+void MainFrame_toggleFullscreen(){
+ GtkWindow* wnd = MainFrame_getWindow();
+ if( gdk_window_get_state( gtk_widget_get_window( GTK_WIDGET( wnd ) ) ) & GDK_WINDOW_STATE_FULLSCREEN ){
+ //some portion of buttsex, because gtk_window_unfullscreen doesn't work correctly after calling some modal window
+ bool maximize = ( gdk_window_get_state( gtk_widget_get_window( GTK_WIDGET( wnd ) ) ) & GDK_WINDOW_STATE_MAXIMIZED );
+ gtk_window_unfullscreen( wnd );
+ if( maximize ){
+ gtk_window_unmaximize( wnd );
+ gtk_window_maximize( wnd );
+ }
+ else{
+ gtk_window_move( wnd, g_layout_globals.m_position.x, g_layout_globals.m_position.y );
+ gtk_window_resize( wnd, g_layout_globals.m_position.w, g_layout_globals.m_position.h );
+ }
+ }
+ else{
+ gtk_window_fullscreen( wnd );
+ }
+}
+class MaximizeView
+{
+public:
+ MaximizeView(): m_maximized( false ){
+ }
+ void toggle(){
+ return m_maximized ? restore() : maximize();
+ }
+private:
+ bool m_maximized;
+ int m_vSplitPos;
+ int m_vSplit2Pos;
+ int m_hSplitPos;
+
+ void restore(){
+ m_maximized = false;
+ gtk_paned_set_position( GTK_PANED( g_pParentWnd->m_vSplit ), m_vSplitPos );
+ gtk_paned_set_position( GTK_PANED( g_pParentWnd->m_vSplit2 ), m_vSplit2Pos );
+ gtk_paned_set_position( GTK_PANED( g_pParentWnd->m_hSplit ), m_hSplitPos );
+ }
+
+ void maximize(){
+ m_maximized = true;
+ m_vSplitPos = gtk_paned_get_position( GTK_PANED( g_pParentWnd->m_vSplit ) );
+ m_vSplit2Pos = gtk_paned_get_position( GTK_PANED( g_pParentWnd->m_vSplit2 ) );
+ m_hSplitPos = gtk_paned_get_position( GTK_PANED( g_pParentWnd->m_hSplit ) );
+
+ int vSplitX, vSplitY, vSplit2X, vSplit2Y, hSplitX, hSplitY;
+ gdk_window_get_origin( gtk_widget_get_window( GTK_WIDGET( g_pParentWnd->m_vSplit ) ), &vSplitX, &vSplitY );
+ gdk_window_get_origin( gtk_widget_get_window( GTK_WIDGET( g_pParentWnd->m_vSplit2 ) ), &vSplit2X, &vSplit2Y );
+ gdk_window_get_origin( gtk_widget_get_window( GTK_WIDGET( g_pParentWnd->m_hSplit ) ), &hSplitX, &hSplitY );
+
+ vSplitY += m_vSplitPos;
+ vSplit2Y += m_vSplit2Pos;
+ hSplitX += m_hSplitPos;
+
+ int cur_x, cur_y;
+ Sys_GetCursorPos( MainFrame_getWindow(), &cur_x, &cur_y );
+
+ if( cur_x > hSplitX ){
+ gtk_paned_set_position( GTK_PANED( g_pParentWnd->m_hSplit ), 0 );
+ }
+ else{
+ gtk_paned_set_position( GTK_PANED( g_pParentWnd->m_hSplit ), 9999 );
+ }
+ if( cur_y > vSplitY ){
+ gtk_paned_set_position( GTK_PANED( g_pParentWnd->m_vSplit ), 0 );
+ }
+ else{
+ gtk_paned_set_position( GTK_PANED( g_pParentWnd->m_vSplit ), 9999 );
+ }
+ if( cur_y > vSplit2Y ){
+ gtk_paned_set_position( GTK_PANED( g_pParentWnd->m_vSplit2 ), 0 );
+ }
+ else{
+ gtk_paned_set_position( GTK_PANED( g_pParentWnd->m_vSplit2 ), 9999 );
+ }
+ }
+};
+
+MaximizeView g_maximizeview;
+
+void Maximize_View(){
+ if( g_pParentWnd != 0 && g_pParentWnd->m_vSplit != 0 && g_pParentWnd->m_vSplit2 != 0 && g_pParentWnd->m_hSplit != 0 )
+ g_maximizeview.toggle();
+}
+
+void FocusAllViews(){
+ XY_Centralize(); //using centralizing here, not focusing function
+ GlobalCamera_FocusOnSelected();
+}
#include "preferencesystem.h"
#include "stringio.h"
+#include "transformpath/transformpath.h"
void MainFrame_Construct(){
GlobalCommands_insert( "OpenManual", makeCallbackF(OpenHelpURL), Accelerator( GDK_KEY_F1 ) );
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( "DeleteSelection", makeCallbackF(deleteSelection), Accelerator( GDK_KEY_BackSpace ) );
+ GlobalCommands_insert( "DeleteSelection2", makeCallbackF(deleteSelection), Accelerator( GDK_KEY_BackSpace ) );
+ GlobalCommands_insert( "DeleteSelection", makeCallbackF(deleteSelection), Accelerator( 'Z' ) );
GlobalCommands_insert( "ParentSelection", makeCallbackF(Scene_parentSelected) );
- GlobalCommands_insert( "UnSelectSelection", makeCallbackF(Selection_Deselect), Accelerator( GDK_KEY_Escape ) );
+// GlobalCommands_insert( "UnSelectSelection", makeCallbackF(Selection_Deselect), Accelerator( GDK_KEY_Escape ) );
+ GlobalCommands_insert( "UnSelectSelection2", makeCallbackF(Selection_Deselect), Accelerator( GDK_KEY_Escape ) );
+ GlobalCommands_insert( "UnSelectSelection", makeCallbackF(Selection_Deselect), Accelerator( 'C' ) );
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( "SelectConnectedEntities", makeCallbackF(SelectConnectedEntities), Accelerator( 'E', (GdkModifierType)( GDK_SHIFT_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' ) );
+// GlobalCommands_insert( "ShowHidden", makeCallbackF( Select_ShowAllHidden ), Accelerator( 'H', (GdkModifierType)GDK_SHIFT_MASK ) );
+// GlobalCommands_insert( "HideSelected", makeCallbackF( HideSelected ), Accelerator( 'H' ) );
+
+ Select_registerCommands();
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( "ArbitraryRotation", makeCallbackF(DoRotateDlg), Accelerator( 'R', (GdkModifierType)GDK_SHIFT_MASK ) );
+ GlobalCommands_insert( "ArbitraryScale", makeCallbackF(DoScaleDlg), Accelerator( 'S', (GdkModifierType)( GDK_SHIFT_MASK | GDK_CONTROL_MASK ) ) );
GlobalCommands_insert( "BuildMenuCustomize", makeCallbackF(DoBuildMenu) );
+ GlobalCommands_insert( "Build_runRecentExecutedBuild", makeCallbackF(Build_runRecentExecutedBuild), Accelerator( GDK_KEY_F5 ) );
GlobalCommands_insert( "FindBrush", makeCallbackF(DoFind) );
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' ) );
+ GlobalToggles_insert( "MouseDrag", makeCallbackF(DragMode), ToggleItem::AddCallbackCaller( g_dragmode_button ) );
+ GlobalCommands_insert( "MouseRotateOrScale", makeCallbackF(ToggleRotateScaleModes) );
+ GlobalCommands_insert( "MouseDragOrScale", makeCallbackF(ToggleDragScaleModes), Accelerator( 'Q' ) );
+#ifndef GARUX_DISABLE_GTKTHEME
+ GlobalCommands_insert( "gtkThemeDlg", makeCallbackF(gtkThemeDlg) );
+#endif
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( "ChooseGridMinorColor", makeCallback( g_ColoursMenu.m_gridminor ) );
- GlobalCommands_insert( "ChooseSmallGridMajorColor", makeCallback( g_ColoursMenu.m_gridmajor_alt ) );
- GlobalCommands_insert( "ChooseSmallGridMinorColor", makeCallback( g_ColoursMenu.m_gridminor_alt ) );
GlobalCommands_insert( "ChooseGridTextColor", makeCallback( g_ColoursMenu.m_gridtext ) );
GlobalCommands_insert( "ChooseGridBlockColor", makeCallback( g_ColoursMenu.m_gridblock ) );
GlobalCommands_insert( "ChooseBrushColor", makeCallback( g_ColoursMenu.m_brush ) );
GlobalCommands_insert( "ChooseClipperColor", makeCallback( g_ColoursMenu.m_clipper ) );
GlobalCommands_insert( "ChooseOrthoViewNameColor", makeCallback( g_ColoursMenu.m_viewname ) );
+ GlobalCommands_insert( "Fullscreen", makeCallbackF( MainFrame_toggleFullscreen ), Accelerator( GDK_KEY_F11 ) );
+ GlobalCommands_insert( "MaximizeView", makeCallbackF( Maximize_View ), Accelerator( GDK_KEY_F12 ) );
+
GlobalCommands_insert( "CSGSubtract", makeCallbackF(CSG_Subtract), Accelerator( 'U', (GdkModifierType)GDK_SHIFT_MASK ) );
- GlobalCommands_insert( "CSGMerge", makeCallbackF(CSG_Merge), Accelerator( 'U', (GdkModifierType)GDK_CONTROL_MASK ) );
- GlobalCommands_insert( "CSGHollow", makeCallbackF(CSG_MakeHollow) );
+ GlobalCommands_insert( "CSGMerge", makeCallbackF(CSG_Merge), Accelerator( 'U', (GdkModifierType) GDK_CONTROL_MASK ) );
+ GlobalCommands_insert( "CSGRoom", makeCallbackF(CSG_MakeRoom) );
+ GlobalCommands_insert( "CSGTool", makeCallbackF(CSG_Tool) );
Grid_registerCommands();
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( "MainToolBar", make_property_string( g_Layout_enableMainToolbar.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( "FilterToolBar", make_property_string( g_Layout_enableFilterToolbar.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) );
+
+ GlobalPreferenceSystem().registerPreference( "EnginePath", make_property_string( g_strEnginePath ) );
+
+ GlobalPreferenceSystem().registerPreference( "NudgeAfterClone", make_property_string( g_bNudgeAfterClone ) );
+ if ( g_strEnginePath.empty() )
{
+ g_strEnginePath_was_empty_1st_start = true;
const char* ENGINEPATH_ATTRIBUTE =
#if GDEF_OS_WINDOWS
"enginepath_win32"
#error "unknown platform"
#endif
;
+
StringOutputStream path( 256 );
path << DirectoryCleaned( g_pGameDescription->getRequiredKeyValue( ENGINEPATH_ATTRIBUTE ) );
- g_strEnginePath = path.c_str();
+
+ g_strEnginePath = transformPath( path.c_str() ).c_str();
+ GlobalPreferenceSystem().registerPreference( "EnginePath", make_property_string( g_strEnginePath ) );
}
- GlobalPreferenceSystem().registerPreference( "EnginePath", CopiedStringImportStringCaller( g_strEnginePath ), CopiedStringExportStringCaller( 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();
+ g_Layout_enableMainToolbar.useLatched();
g_Layout_enablePatchToolbar.useLatched();
g_Layout_enablePluginToolbar.useLatched();
+ g_Layout_enableFilterToolbar.useLatched();
Layout_registerPreferencesPage();
Paths_registerPreferencesPage();
+ PreferencesDialog_addSettingsPreferences( FreeCaller<void(PreferencesPage&), Nudge_constructPreferences>() );
g_brushCount.setCountChangedCallback( makeCallbackF(QE_brushCountChanged) );
g_entityCount.setCountChangedCallback( makeCallbackF(QE_entityCountChanged) );
GlobalEntityCreator().setCounter( &g_entityCount );
- GLWidget_sharedContextCreated = GlobalGL_sharedContextCreated;
- GLWidget_sharedContextDestroyed = GlobalGL_sharedContextDestroyed;
+ glwidget_set_shared_context_constructors( GlobalGL_sharedContextCreated, GlobalGL_sharedContextDestroyed);
GlobalEntityClassManager().attach( g_WorldspawnColourEntityClassObserver );
}
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(){
}
+
+/* HACK: If ui::main is not called yet,
+gtk_main_quit will not quit, so tell main
+to not call ui::main. This happens when a
+map is loaded from command line and require
+a restart because of wrong format.
+Delete this when the code to not have to
+restart to load another format is merged. */
+extern bool g_dontStart;
+
+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();
+ /* HACK: If ui::main is not called yet,
+ gtk_main_quit will not quit, so tell main
+ to not call ui::main. This happens when a
+ map is loaded from command line and require
+ a restart because of wrong format.
+ Delete this when the code to not have to
+ restart to load another format is merged. */
+ g_dontStart = true;
+ }
+}
projects / xonotic / netradiant.git / blobdiff