#include "debugging/debugging.h"
#include "imap.h"
+
MapModules& ReferenceAPI_getMapModules();
+
#include "iselection.h"
#include "iundo.h"
#include "ibrush.h"
#include "cmdlib.h"
#include "stream/textfilestream.h"
#include "os/path.h"
+#include "os/file.h"
#include "uniquenames.h"
#include "modulesystem/singletonmodule.h"
#include "modulesystem/moduleregistry.h"
#include "brushmodule.h"
#include "brush.h"
+bool g_writeMapComments = true;
+
class NameObserver
{
UniqueNames& m_names;
m_names.insert( name_read( c_str() ) );
}
}
+
void destroy(){
if ( !empty() ) {
//globalOutputStream() << "destroy " << makeQuoted(c_str()) << "\n";
}
NameObserver& operator=( const NameObserver& other );
+
public:
NameObserver( UniqueNames& names ) : m_names( names ){
construct();
NameObserver( const NameObserver& other ) : m_names( other.m_names ), m_name( other.m_name ){
construct();
}
+
~NameObserver(){
destroy();
}
+
bool empty() const {
return string_empty( c_str() );
}
+
const char* c_str() const {
return m_name.c_str();
}
+
void nameChanged( const char* name ){
destroy();
m_name = name;
construct();
}
-typedef MemberCaller1<NameObserver, const char*, &NameObserver::nameChanged> NameChangedCaller;
+
+typedef MemberCaller<NameObserver, void(const char*), &NameObserver::nameChanged> NameChangedCaller;
};
class BasicNamespace : public Namespace
~BasicNamespace(){
ASSERT_MESSAGE( m_names.empty(), "namespace: names still registered at shutdown" );
}
+
void attach( const NameCallback& setName, const NameCallbackCallback& attachObserver ){
std::pair<Names::iterator, bool> result = m_names.insert( Names::value_type( setName, m_uniqueNames ) );
ASSERT_MESSAGE( result.second, "cannot attach name" );
attachObserver( NameObserver::NameChangedCaller( ( *result.first ).second ) );
//globalOutputStream() << "attach: " << reinterpret_cast<const unsigned int&>(setName) << "\n";
}
+
void detach( const NameCallback& setName, const NameCallbackCallback& detachObserver ){
Names::iterator i = m_names.find( setName );
ASSERT_MESSAGE( i != m_names.end(), "cannot detach name" );
Namespace* m_namespace;
public:
typedef Namespace Type;
+
STRING_CONSTANT( Name, "*" );
NamespaceAPI(){
m_namespace = &g_defaultNamespace;
}
+
Namespace* getTable(){
return m_namespace;
}
WorldNode()
: m_node( 0 ){
}
+
void set( scene::Node* node ){
if ( m_node != 0 ) {
m_node->DecRef();
m_node->IncRef();
}
}
+
scene::Node* get() const {
return m_node;
}
class Map;
void Map_SetValid( Map& map, bool valid );
+
void Map_UpdateTitle( const Map& map );
+
void Map_SetWorldspawn( Map& map, scene::Node* node );
bool m_valid;
bool m_modified;
+
void ( *m_modified_changed )( const Map& );
Signal0 m_mapValidCallbacks;
Map_SetValid( g_map, true );
}
}
+
void unrealise(){
if ( m_resource != 0 ) {
Map_SetValid( g_map, false );
}
-
scene::Node* Map_GetWorldspawn( const Map& map ){
return map.m_world_node.get();
}
float g_MinWorldCoord = -64 * 1024;
void AddRegionBrushes( void );
-void RemoveRegionBrushes( void );
+void RemoveRegionBrushes( void );
/*
EntityFindByClassname( const char* name, Entity*& entity ) : m_name( name ), m_entity( entity ){
m_entity = 0;
}
+
bool pre( const scene::Path& path, scene::Instance& instance ) const {
if ( m_entity == 0 ) {
Entity* entity = Node_getEntity( path.top() );
public:
CollectAllWalker( scene::Node& root, UnsortedNodeSet& nodes ) : m_root( root ), m_nodes( nodes ){
}
+
bool pre( scene::Node& node ) const {
m_nodes.insert( NodeSmartReference( node ) );
Node_getTraversable( m_root )->erase( node );
MapMergeAll( const scene::Path& root )
: m_path( root ){
}
+
bool pre( scene::Node& node ) const {
Node_getTraversable( m_path.top() )->insert( node );
m_path.push( makeReference( node ) );
selectPath( m_path, true );
return false;
}
+
void post( scene::Node& node ) const {
m_path.pop();
}
MapMergeEntities( const scene::Path& root )
: m_path( root ){
}
+
bool pre( scene::Node& node ) const {
if ( node_is_worldspawn( node ) ) {
scene::Node* world_node = Map_FindWorldspawn( g_map );
}
return false;
}
+
void post( scene::Node& node ) const {
m_path.pop();
}
TypeCasts(){
NodeContainedCast<BasicContainer, scene::Traversable>::install( m_casts );
}
+
NodeTypeCastTable& get(){
return m_casts;
}
BasicContainer() : m_node( this, this, StaticTypeCasts::instance().get() ){
}
+
void release(){
delete this;
}
+
scene::Node& node(){
return m_node;
}
void MergeMap( scene::Node& node ){
Node_getTraversable( node )->traverse( MapMergeEntities( scene::Path( makeReference( GlobalSceneGraph().root() ) ) ) );
}
+
void Map_ImportSelected( TextInputStream& in, const MapFormat& format ){
NodeSmartReference node( ( new BasicContainer )->node() );
format.readGraph( node, in, GlobalEntityCreator() );
CloneAll( scene::Node& root )
: m_path( makeReference( root ) ){
}
+
bool pre( scene::Node& node ) const {
if ( node.isRoot() ) {
return false;
return true;
}
+
void post( scene::Node& node ) const {
if ( node.isRoot() ) {
return;
EntityBreakdownWalker( EntityBreakdown& entitymap )
: m_entitymap( entitymap ){
}
+
bool pre( const scene::Path& path, scene::Instance& instance ) const {
Entity* entity = Node_getEntity( path.top() );
if ( entity != 0 ) {
const EntityClass& eclass = entity->getEntityClass();
if ( m_entitymap.find( eclass.name() ) == m_entitymap.end() ) {
m_entitymap[eclass.name()] = 1;
+ } else
+ {
+ ++m_entitymap[eclass.name()];
}
- else{ ++m_entitymap[eclass.name()]; }
}
return true;
}
{
auto entry = ui::Entry(ui::New);
entry.show();
- gtk_table_attach( table, GTK_WIDGET( entry ), 1, 2, 0, 1,
- (GtkAttachOptions) ( GTK_EXPAND | GTK_FILL ),
- (GtkAttachOptions) ( 0 ), 0, 0 );
+ table.attach(entry, {1, 2, 0, 1}, {GTK_EXPAND | GTK_FILL, 0});
gtk_editable_set_editable( GTK_EDITABLE(entry), FALSE );
brushes_entry = entry;
{
auto entry = ui::Entry(ui::New);
entry.show();
- gtk_table_attach( table, GTK_WIDGET( entry ), 1, 2, 1, 2,
- (GtkAttachOptions) ( GTK_EXPAND | GTK_FILL ),
- (GtkAttachOptions) ( 0 ), 0, 0 );
+ table.attach(entry, {1, 2, 1, 2}, {GTK_EXPAND | GTK_FILL, 0});
gtk_editable_set_editable( GTK_EDITABLE(entry), FALSE );
entities_entry = entry;
{
ui::Widget label = ui::Label( "Total Brushes" );
label.show();
- gtk_table_attach( GTK_TABLE( table ), label, 0, 1, 0, 1,
- (GtkAttachOptions) ( GTK_FILL ),
- (GtkAttachOptions) ( 0 ), 0, 0 );
+ table.attach(label, {0, 1, 0, 1}, {GTK_FILL, 0});
gtk_misc_set_alignment( GTK_MISC( label ), 0, 0.5 );
}
{
ui::Widget label = ui::Label( "Total Entities" );
label.show();
- gtk_table_attach( GTK_TABLE( table ), label, 0, 1, 1, 2,
- (GtkAttachOptions) ( GTK_FILL ),
- (GtkAttachOptions) ( 0 ), 0, 0 );
+ table.attach(label, {0, 1, 1, 2}, {GTK_FILL, 0});
gtk_misc_set_alignment( GTK_MISC( label ), 0, 0.5 );
}
}
vbox.pack_start( scr, TRUE, TRUE, 0 );
{
- ui::ListStore store = ui::ListStore(gtk_list_store_new( 2, G_TYPE_STRING, G_TYPE_STRING ));
+ auto store = ui::ListStore::from(gtk_list_store_new( 2, G_TYPE_STRING, G_TYPE_STRING ));
- ui::Widget view = ui::TreeView(ui::TreeModel( GTK_TREE_MODEL( store ) ));
- gtk_tree_view_set_headers_clickable( GTK_TREE_VIEW( view ), TRUE );
+ auto view = ui::TreeView(ui::TreeModel::from(store._handle));
+ gtk_tree_view_set_headers_clickable(view, TRUE );
{
auto renderer = ui::CellRendererText(ui::New);
- GtkTreeViewColumn* column = ui::TreeViewColumn( "Entity", renderer, {{"text", 0}} );
- gtk_tree_view_append_column( GTK_TREE_VIEW( view ), column );
+ auto column = ui::TreeViewColumn( "Entity", renderer, {{"text", 0}} );
+ gtk_tree_view_append_column(view, column );
gtk_tree_view_column_set_sort_column_id( column, 0 );
}
{
auto renderer = ui::CellRendererText(ui::New);
- GtkTreeViewColumn* column = ui::TreeViewColumn( "Count", renderer, {{"text", 1}} );
- gtk_tree_view_append_column( GTK_TREE_VIEW( view ), column );
+ auto column = ui::TreeViewColumn( "Count", renderer, {{"text", 1}} );
+ gtk_tree_view_append_column(view, column );
gtk_tree_view_column_set_sort_column_id( column, 1 );
}
: m_message( message ){
m_timer.start();
}
+
~ScopeTimer(){
double elapsed_time = m_timer.elapsed_msec() / 1000.f;
globalOutputStream() << m_message << " timer: " << FloatFormat( elapsed_time, 5, 2 ) << " second(s) elapsed\n";
}
};
-CopiedString g_strLastFolder = "";
+CopiedString g_strLastMapFolder = "";
/*
================
*/
void Map_LoadFile( const char *filename ){
+ g_map.m_name = filename;
+
+ // refresh VFS to apply new pak filtering based on mapname
+ // needed for daemon DPK VFS
+ VFS_Refresh();
+
globalOutputStream() << "Loading map from " << filename << "\n";
ScopeDisableScreenUpdates disableScreenUpdates( "Processing...", "Loading Map" );
MRU_AddFile( filename );
- g_strLastFolder = g_path_get_dirname( filename );
+ g_strLastMapFolder = g_path_get_dirname( filename );
+
+ bool switch_format = false;
{
ScopeTimer timer( "map load" );
Map_Free();
}
Brush_toggleFormat( i );
- g_map.m_name = filename;
Map_UpdateTitle( g_map );
+
g_map.m_resource = GlobalReferenceCache().capture( g_map.m_name.c_str() );
if ( format ) {
format->wrongFormat = false;
if ( !format->wrongFormat ) {
break;
}
+ switch_format = !switch_format;
}
}
g_currentMap = &g_map;
- // restart VFS to apply new pak filtering based on mapname
- // needed for daemon DPK VFS
- VFS_Restart();
+ Brush_switchFormat( switch_format );
}
class Excluder
ExcludeWalker( const scene::Traversable::Walker& walker, const Excluder& exclude )
: m_walker( walker ), m_exclude( &exclude ), m_skip( false ){
}
+
bool pre( scene::Node& node ) const {
if ( m_exclude->excluded( node ) || node.isRoot() ) {
m_skip = true;
}
return true;
}
+
void post( scene::Node& node ) const {
if ( m_skip ) {
m_skip = false;
AnyInstanceSelected( bool& selected ) : m_selected( selected ){
m_selected = false;
}
+
void visit( scene::Instance& instance ) const {
Selectable* selectable = Instance_getSelectable( instance );
if ( selectable != 0
bool selectedParent() const {
return m_selected != 0;
}
+
public:
IncludeSelectedWalker( const scene::Traversable::Walker& walker )
: m_walker( walker ), m_selected( 0 ), m_skip( false ){
}
+
bool pre( scene::Node& node ) const {
// include node if:
// node is not a 'root' AND ( node is selected OR any child of node is selected OR any parent of node is selected )
return false;
}
}
+
void post( scene::Node& node ) const {
if ( m_skip ) {
m_skip = false;
}
void Map_ExportSelected( TextOutputStream& out, const MapFormat& format ){
- format.writeGraph( GlobalSceneGraph().root(), Map_Traverse_Selected, out );
+ format.writeGraph( GlobalSceneGraph().root(), Map_Traverse_Selected, out, g_writeMapComments );
}
void Map_Traverse( scene::Node& root, const scene::Traversable::Walker& walker ){
ExcludeAllWalker( bool exclude )
: m_exclude( exclude ){
}
+
bool pre( const scene::Path& path, scene::Instance& instance ) const {
exclude_node( path.top(), m_exclude );
ExcludeSelectedWalker( bool exclude )
: m_exclude( exclude ){
}
+
bool pre( const scene::Path& path, scene::Instance& instance ) const {
exclude_node( path.top(), ( instance.isSelected() || instance.childSelected() || instance.parentSelected() ) == m_exclude );
return true;
ExcludeRegionedWalker( bool exclude )
: m_exclude( exclude ){
}
+
bool pre( const scene::Path& path, scene::Instance& instance ) const {
exclude_node(
path.top(),
bool Map_ImportFile( const char* filename ){
ScopeDisableScreenUpdates disableScreenUpdates( "Processing...", "Loading Map" );
- g_strLastFolder = g_path_get_dirname( filename );
+ g_strLastMapFolder = g_path_get_dirname( filename );
bool success = false;
tryDecompile:
- const char *type = GlobalRadiant().getRequiredGameDescriptionKeyValue( "q3map2_type" );
+ const char *type = GlobalRadiant().getGameDescriptionKeyValue( "q3map2_type" );
int n = string_length( path_get_extension( filename ) );
if ( n && ( extension_equal( path_get_extension( filename ), "bsp" ) || extension_equal( path_get_extension( filename ), "map" ) ) ) {
- StringBuffer output;
- output.push_string( AppPath_get() );
- output.push_string( "q3map2." );
- output.push_string( RADIANT_EXECUTABLE );
- output.push_string( " -v -game " );
- output.push_string( ( type && *type ) ? type : "quake3" );
- output.push_string( " -fs_basepath \"" );
- output.push_string( EnginePath_get() );
- output.push_string( "\" -fs_homepath \"" );
- output.push_string( g_qeglobals.m_userEnginePath.c_str() );
- output.push_string( "\" -fs_game " );
- output.push_string( gamename_get() );
- output.push_string( " -convert -format " );
- output.push_string( Brush::m_type == eBrushTypeQuake3BP ? "map_bp" : "map" );
+ std::string output;
+ output += AppPath_get();
+ output += "q3map2";
+ output += GDEF_OS_EXE_EXT;
+
+ output += " -v -game ";
+ output += ( type && *type ) ? type : "quake3";
+ output += " -fs_basepath \"";
+ output += EnginePath_get();
+ output += "\" -fs_homepath \"";
+ output += g_qeglobals.m_userEnginePath.c_str();
+ output += "\"";
+
+ // extra pakpaths
+ for ( int i = 0; i < g_pakPathCount; i++ ) {
+ if ( g_strcmp0( g_strPakPath[i].c_str(), "") ) {
+ output += " -fs_pakpath \"";
+ output += g_strPakPath[i].c_str();
+ output += "\"";
+ }
+ }
+
+ // extra switches
+ if ( g_disableEnginePath ) {
+ output += " -fs_nobasepath ";
+ }
+
+ if ( g_disableHomePath ) {
+ output += " -fs_nohomepath ";
+ }
+
+ output += " -fs_game ";
+ output += gamename_get();
+ output += " -convert -format ";
+ output += Brush::m_type == eBrushTypeQuake3BP ? "map_bp" : "map";
if ( extension_equal( path_get_extension( filename ), "map" ) ) {
- output.push_string( " -readmap " );
+ output += " -readmap ";
}
- output.push_string( " \"" );
- output.push_string( filename );
- output.push_string( "\"" );
+ output += " \"";
+ output += filename;
+ output += "\"";
// run
Q_Exec( NULL, output.c_str(), NULL, false, true );
// rebuild filename as "filenamewithoutext_converted.map"
- output.clear();
- output.push_range( filename, filename + string_length( filename ) - ( n + 1 ) );
- output.push_string( "_converted.map" );
+ output = "";
+ output.append( filename, string_length( filename ) - ( n + 1 ) );
+ output += "_converted.map";
filename = output.c_str();
// open
public:
ParentSelectedBrushesToEntityWalker( scene::Node& parent ) : m_parent( parent ){
}
+
bool pre( const scene::Path& path, scene::Instance& instance ) const {
if ( path.top().get_pointer() != &m_parent
&& Node_isPrimitive( path.top() ) ) {
}
return true;
}
+
void post( const scene::Path& path, scene::Instance& instance ) const {
if ( path.top().get_pointer() != &m_parent
&& Node_isPrimitive( path.top() ) ) {
CountSelectedBrushes( std::size_t& count ) : m_count( count ), m_depth( 0 ){
m_count = 0;
}
+
bool pre( const scene::Path& path, scene::Instance& instance ) const {
if ( ++m_depth != 1 && path.top().get().isRoot() ) {
return false;
}
return true;
}
+
void post( const scene::Path& path, scene::Instance& instance ) const {
--m_depth;
}
public:
ParentSelectedBrushesToEntityWalker( const scene::Path& parent ) : m_parent( parent ){
}
+
void visit( scene::Instance& instance ) const {
if ( &m_parent != &instance.path() ) {
Path_parent( m_parent, instance.path() );
}
-
void NewMap(){
if ( ConfirmModified( "New Map" ) ) {
Map_RegionOff();
return g_mapsPath.c_str();
}
-const char* getLastFolderPath(){
- if (g_strLastFolder.empty()) {
- GlobalPreferenceSystem().registerPreference( "LastFolder", CopiedStringImportStringCaller( g_strLastFolder ), CopiedStringExportStringCaller( g_strLastFolder ) );
- if (g_strLastFolder.empty()) {
- g_strLastFolder = g_qeglobals.m_userGamePath;
+const char* getLastMapFolderPath(){
+ if (g_strLastMapFolder.empty()) {
+ GlobalPreferenceSystem().registerPreference( "LastMapFolder", make_property_string( g_strLastMapFolder ) );
+ if (g_strLastMapFolder.empty()) {
+ StringOutputStream buffer( 1024 );
+ buffer << getMapsPath();
+ if ( !file_readable( buffer.c_str() ) ) {
+ buffer.clear();
+ buffer << g_qeglobals.m_userGamePath.c_str() << "/";
+ }
+ g_strLastMapFolder = buffer.c_str();
}
}
- return g_strLastFolder.c_str();
+ return g_strLastMapFolder.c_str();
}
const char* map_open( const char* title ){
- return MainFrame_getWindow().file_dialog( TRUE, title, getLastFolderPath(), MapFormat::Name(), true, false, false );
+ return MainFrame_getWindow().file_dialog( TRUE, title, getLastMapFolderPath(), MapFormat::Name(), true, false, false );
}
const char* map_import( const char* title ){
- return MainFrame_getWindow().file_dialog( TRUE, title, getLastFolderPath(), MapFormat::Name(), false, true, false );
+ return MainFrame_getWindow().file_dialog( TRUE, title, getLastMapFolderPath(), MapFormat::Name(), false, true, false );
}
const char* map_save( const char* title ){
- return MainFrame_getWindow().file_dialog( FALSE, title, getLastFolderPath(), MapFormat::Name(), false, false, true );
+ return MainFrame_getWindow().file_dialog( FALSE, title, getLastMapFolderPath(), MapFormat::Name(), false, false, true );
}
void OpenMap(){
const char* filename = map_save( "Save Map" );
if ( filename != NULL ) {
- g_strLastFolder = g_path_get_dirname( filename );
+ g_strLastMapFolder = g_path_get_dirname( filename );
MRU_AddFile( filename );
Map_Rename( filename );
return Map_Save();
const char* filename = map_save( "Export Selection" );
if ( filename != NULL ) {
- g_strLastFolder = g_path_get_dirname( filename );
+ g_strLastMapFolder = g_path_get_dirname( filename );
Map_SaveSelected( filename );
}
}
const char* filename = map_save( "Export Region" );
if ( filename != NULL ) {
- g_strLastFolder = g_path_get_dirname( filename );
+ g_strLastMapFolder = g_path_get_dirname( filename );
Map_SaveRegion( filename );
}
}
BrushFindByIndexWalker( std::size_t index, scene::Path& path )
: m_index( index ), m_path( path ){
}
+
bool pre( scene::Node& node ) const {
if ( Node_isPrimitive( node ) && m_index-- == 0 ) {
m_path.push( makeReference( node ) );
EntityFindByIndexWalker( std::size_t index, scene::Path& path )
: m_index( index ), m_path( path ){
}
+
bool pre( scene::Node& node ) const {
if ( Node_isEntity( node ) && m_index-- == 0 ) {
m_path.push( makeReference( node ) );
BrushFindIndexWalker( const scene::Node& node, std::size_t& count )
: m_node( &node ), m_count( count ){
}
+
bool pre( const scene::Path& path, scene::Instance& instance ) const {
if ( Node_isPrimitive( path.top() ) ) {
if ( m_node == path.top().get_pointer() ) {
EntityFindIndexWalker( const scene::Node& node, std::size_t& count )
: m_node( &node ), m_count( count ){
}
+
bool pre( const scene::Path& path, scene::Instance& instance ) const {
if ( Node_isEntity( path.top() ) ) {
if ( m_node == path.top().get_pointer() ) {
{
ui::Widget label = ui::Label( "Entity number" );
label.show();
- gtk_table_attach( GTK_TABLE( table ), label, 0, 1, 0, 1,
- (GtkAttachOptions) ( 0 ),
- (GtkAttachOptions) ( 0 ), 0, 0 );
+ (table).attach(label, {0, 1, 0, 1}, {0, 0});
}
{
ui::Widget label = ui::Label( "Brush number" );
label.show();
- gtk_table_attach( GTK_TABLE( table ), label, 0, 1, 1, 2,
- (GtkAttachOptions) ( 0 ),
- (GtkAttachOptions) ( 0 ), 0, 0 );
+ (table).attach(label, {0, 1, 1, 2}, {0, 0});
}
{
auto entry = ui::Entry(ui::New);
entry.show();
- gtk_table_attach( table, GTK_WIDGET( entry ), 1, 2, 0, 1,
- (GtkAttachOptions) ( GTK_EXPAND | GTK_FILL ),
- (GtkAttachOptions) ( 0 ), 0, 0 );
- gtk_widget_grab_focus( GTK_WIDGET( entry ) );
+ table.attach(entry, {1, 2, 0, 1}, {GTK_EXPAND | GTK_FILL, 0});
+ gtk_widget_grab_focus( entry );
entity = entry;
}
{
auto entry = ui::Entry(ui::New);
entry.show();
- gtk_table_attach( table, GTK_WIDGET( entry ), 1, 2, 1, 2,
- (GtkAttachOptions) ( GTK_EXPAND | GTK_FILL ),
- (GtkAttachOptions) ( 0 ), 0, 0 );
+ table.attach(entry, {1, 2, 1, 2}, {GTK_EXPAND | GTK_FILL, 0});
brush = entry;
}
auto button = create_dialog_button( "Find", G_CALLBACK( dialog_button_ok ), &dialog );
hbox.pack_start( button, FALSE, FALSE, 0 );
widget_make_default( button );
- gtk_widget_add_accelerator( GTK_WIDGET( button ), "clicked", accel, GDK_KEY_Return, (GdkModifierType)0, (GtkAccelFlags)0 );
+ gtk_widget_add_accelerator( button , "clicked", accel, GDK_KEY_Return, (GdkModifierType)0, (GtkAccelFlags)0 );
}
{
auto button = create_dialog_button( "Close", G_CALLBACK( dialog_button_cancel ), &dialog );
hbox.pack_start( button, FALSE, FALSE, 0 );
- gtk_widget_add_accelerator( GTK_WIDGET( button ), "clicked", accel, GDK_KEY_Escape, (GdkModifierType)0, (GtkAccelFlags)0 );
+ gtk_widget_add_accelerator( button , "clicked", accel, GDK_KEY_Escape, (GdkModifierType)0, (GtkAccelFlags)0 );
}
}
}
}
void Map_constructPreferences( PreferencesPage& page ){
- page.appendCheckBox( "", "Load last map on open", g_bLoadLastMap );
+ page.appendCheckBox( "", "Load last map at startup", g_bLoadLastMap );
+ page.appendCheckBox( "", "Add entity and brush number comments on map write", g_writeMapComments );
}
public:
MapEntityClasses() : m_unrealised( 1 ){
}
+
void realise(){
if ( --m_unrealised == 0 ) {
if ( g_map.m_resource != 0 ) {
}
}
}
+
void unrealise(){
if ( ++m_unrealised == 1 ) {
if ( g_map.m_resource != 0 ) {
public:
MapModuleObserver() : m_unrealised( 1 ){
}
+
void realise(){
if ( --m_unrealised == 0 ) {
ASSERT_MESSAGE( !string_empty( g_qeglobals.m_userGamePath.c_str() ), "maps_directory: user-game-path is empty" );
g_mapsPath = buffer.c_str();
}
}
+
void unrealise(){
if ( ++m_unrealised == 1 ) {
g_mapsPath = "";
bool g_bLoadLastMap = false;
void Map_Construct(){
- GlobalCommands_insert( "RegionOff", FreeCaller<RegionOff>() );
- GlobalCommands_insert( "RegionSetXY", FreeCaller<RegionXY>() );
- GlobalCommands_insert( "RegionSetBrush", FreeCaller<RegionBrush>() );
- GlobalCommands_insert( "RegionSetSelection", FreeCaller<RegionSelected>(), Accelerator( 'R', (GdkModifierType)( GDK_SHIFT_MASK | GDK_CONTROL_MASK ) ) );
+ GlobalCommands_insert( "RegionOff", makeCallbackF(RegionOff) );
+ GlobalCommands_insert( "RegionSetXY", makeCallbackF(RegionXY) );
+ GlobalCommands_insert( "RegionSetBrush", makeCallbackF(RegionBrush) );
+ GlobalCommands_insert( "RegionSetSelection", makeCallbackF(RegionSelected), Accelerator( 'R', (GdkModifierType)( GDK_SHIFT_MASK | GDK_CONTROL_MASK ) ) );
- GlobalPreferenceSystem().registerPreference( "LastMap", CopiedStringImportStringCaller( g_strLastMap ), CopiedStringExportStringCaller( g_strLastMap ) );
- GlobalPreferenceSystem().registerPreference( "LoadLastMap", BoolImportStringCaller( g_bLoadLastMap ), BoolExportStringCaller( g_bLoadLastMap ) );
- GlobalPreferenceSystem().registerPreference( "MapInfoDlg", WindowPositionImportStringCaller( g_posMapInfoWnd ), WindowPositionExportStringCaller( g_posMapInfoWnd ) );
+ GlobalPreferenceSystem().registerPreference( "LastMap", make_property_string( g_strLastMap ) );
+ GlobalPreferenceSystem().registerPreference( "LoadLastMap", make_property_string( g_bLoadLastMap ) );
+ GlobalPreferenceSystem().registerPreference( "MapInfoDlg", make_property<WindowPosition_String>( g_posMapInfoWnd ) );
+ GlobalPreferenceSystem().registerPreference( "WriteMapComments", make_property_string( g_writeMapComments ) );
- PreferencesDialog_addSettingsPreferences( FreeCaller1<PreferencesPage&, Map_constructPreferences>() );
+ PreferencesDialog_addSettingsPreferences( makeCallbackF(Map_constructPreferences) );
GlobalEntityClassManager().attach( g_MapEntityClasses );
Radiant_attachHomePathsObserver( g_MapModuleObserver );