#include "map.h"
+#include <gtk/gtk.h>
+
#include "debugging/debugging.h"
#include "imap.h"
+
MapModules& ReferenceAPI_getMapModules();
+
#include "iselection.h"
#include "iundo.h"
#include "ibrush.h"
#include "ifilesystem.h"
#include "namespace.h"
#include "moduleobserver.h"
-#include "moduleobservers.h"
#include <set>
-#include <gtk/gtkmain.h>
-#include <gtk/gtkbox.h>
-#include <gtk/gtkentry.h>
-#include <gtk/gtklabel.h>
-#include <gtk/gtktable.h>
-#include <gtk/gtktreemodel.h>
-#include <gtk/gtktreeview.h>
-#include <gtk/gtkliststore.h>
-#include <gtk/gtkcellrenderertext.h>
+#include <gdk/gdkkeysyms.h>
+#include "uilib/uilib.h"
#include "scenelib.h"
#include "transformlib.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 "xywindow.h"
#include "mainframe.h"
#include "preferences.h"
+#include "preferencesystem.h"
#include "referencecache.h"
#include "mru.h"
#include "commands.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 );
-
-/* Map open/close observers */
-ModuleObservers g_mapPathObservers;
-
-class MapFileObserver : public ModuleObserver
-{
-void realise() {
- // Refresh VFS to apply new pak filtering based on mapname
- // needed for daemon dpk vfs
- VFS_Refresh();
-}
-void unrealise() { }
-};
-
-MapFileObserver g_mapFileObserver;
-
-void BindMapFileObservers(){
- g_mapPathObservers.attach( g_mapFileObserver );
-}
-
-void UnBindMapFileObservers(){
- g_mapPathObservers.detach( g_mapFileObserver );
-}
+void RemoveRegionBrushes( void );
/*
g_currentMap = 0;
Brush_unlatchPreferences();
- g_mapPathObservers.unrealise();
}
class EntityFindByClassname : public scene::Graph::Walker
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;
}
void DoMapInfo(){
ModalDialog dialog;
- GtkEntry* brushes_entry;
- GtkEntry* entities_entry;
- GtkListStore* EntityBreakdownWalker;
+ ui::Entry brushes_entry{ui::null};
+ ui::Entry entities_entry{ui::null};
+ ui::ListStore EntityBreakdownWalker{ui::null};
- GtkWindow* window = create_dialog_window( MainFrame_getWindow(), "Map Info", G_CALLBACK( dialog_delete_callback ), &dialog );
+ ui::Window window = MainFrame_getWindow().create_dialog_window("Map Info", G_CALLBACK(dialog_delete_callback ), &dialog );
window_set_position( window, g_posMapInfoWnd );
{
- GtkVBox* vbox = create_dialog_vbox( 4, 4 );
- gtk_container_add( GTK_CONTAINER( window ), GTK_WIDGET( vbox ) );
+ auto vbox = create_dialog_vbox( 4, 4 );
+ window.add(vbox);
{
- GtkHBox* hbox = create_dialog_hbox( 4 );
- gtk_box_pack_start( GTK_BOX( vbox ), GTK_WIDGET( hbox ), FALSE, TRUE, 0 );
+ auto hbox = create_dialog_hbox( 4 );
+ vbox.pack_start( hbox, FALSE, TRUE, 0 );
{
- GtkTable* table = create_dialog_table( 2, 2, 4, 4 );
- gtk_box_pack_start( GTK_BOX( hbox ), GTK_WIDGET( table ), TRUE, TRUE, 0 );
+ auto table = create_dialog_table( 2, 2, 4, 4 );
+ hbox.pack_start( table, TRUE, TRUE, 0 );
{
- GtkEntry* entry = GTK_ENTRY( gtk_entry_new() );
- gtk_widget_show( GTK_WIDGET( entry ) );
- gtk_table_attach( table, GTK_WIDGET( entry ), 1, 2, 0, 1,
- (GtkAttachOptions) ( GTK_EXPAND | GTK_FILL ),
- (GtkAttachOptions) ( 0 ), 0, 0 );
- gtk_entry_set_editable( entry, FALSE );
+ auto entry = ui::Entry(ui::New);
+ entry.show();
+ table.attach(entry, {1, 2, 0, 1}, {GTK_EXPAND | GTK_FILL, 0});
+ gtk_editable_set_editable( GTK_EDITABLE(entry), FALSE );
brushes_entry = entry;
}
{
- GtkEntry* entry = GTK_ENTRY( gtk_entry_new() );
- gtk_widget_show( GTK_WIDGET( entry ) );
- gtk_table_attach( table, GTK_WIDGET( entry ), 1, 2, 1, 2,
- (GtkAttachOptions) ( GTK_EXPAND | GTK_FILL ),
- (GtkAttachOptions) ( 0 ), 0, 0 );
- gtk_entry_set_editable( entry, FALSE );
+ auto entry = ui::Entry(ui::New);
+ entry.show();
+ table.attach(entry, {1, 2, 1, 2}, {GTK_EXPAND | GTK_FILL, 0});
+ gtk_editable_set_editable( GTK_EDITABLE(entry), FALSE );
entities_entry = entry;
}
{
- GtkWidget* label = gtk_label_new( "Total Brushes" );
- gtk_widget_show( label );
- gtk_table_attach( GTK_TABLE( table ), label, 0, 1, 0, 1,
- (GtkAttachOptions) ( GTK_FILL ),
- (GtkAttachOptions) ( 0 ), 0, 0 );
+ ui::Widget label = ui::Label( "Total Brushes" );
+ label.show();
+ table.attach(label, {0, 1, 0, 1}, {GTK_FILL, 0});
gtk_misc_set_alignment( GTK_MISC( label ), 0, 0.5 );
}
{
- GtkWidget* label = gtk_label_new( "Total Entities" );
- gtk_widget_show( label );
- gtk_table_attach( GTK_TABLE( table ), label, 0, 1, 1, 2,
- (GtkAttachOptions) ( GTK_FILL ),
- (GtkAttachOptions) ( 0 ), 0, 0 );
+ ui::Widget label = ui::Label( "Total Entities" );
+ label.show();
+ table.attach(label, {0, 1, 1, 2}, {GTK_FILL, 0});
gtk_misc_set_alignment( GTK_MISC( label ), 0, 0.5 );
}
}
{
- GtkVBox* vbox2 = create_dialog_vbox( 4 );
- gtk_box_pack_start( GTK_BOX( hbox ), GTK_WIDGET( vbox2 ), FALSE, FALSE, 0 );
+ auto vbox2 = create_dialog_vbox( 4 );
+ hbox.pack_start( vbox2, FALSE, FALSE, 0 );
{
- GtkButton* button = create_dialog_button( "Close", G_CALLBACK( dialog_button_ok ), &dialog );
- gtk_box_pack_start( GTK_BOX( vbox2 ), GTK_WIDGET( button ), FALSE, FALSE, 0 );
+ auto button = create_dialog_button( "Close", G_CALLBACK( dialog_button_ok ), &dialog );
+ vbox2.pack_start( button, FALSE, FALSE, 0 );
}
}
}
{
- GtkWidget* label = gtk_label_new( "Entity breakdown" );
- gtk_widget_show( label );
- gtk_box_pack_start( GTK_BOX( vbox ), GTK_WIDGET( label ), FALSE, TRUE, 0 );
+ ui::Widget label = ui::Label( "Entity breakdown" );
+ label.show();
+ vbox.pack_start( label, FALSE, TRUE, 0 );
gtk_misc_set_alignment( GTK_MISC( label ), 0, 0.5 );
}
{
- GtkScrolledWindow* scr = create_scrolled_window( GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC, 4 );
- gtk_box_pack_start( GTK_BOX( vbox ), GTK_WIDGET( scr ), TRUE, TRUE, 0 );
+ auto scr = create_scrolled_window( ui::Policy::NEVER, ui::Policy::AUTOMATIC, 4 );
+ vbox.pack_start( scr, TRUE, TRUE, 0 );
{
- GtkListStore* store = 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 ));
- GtkWidget* view = gtk_tree_view_new_with_model( 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 );
{
- GtkCellRenderer* renderer = gtk_cell_renderer_text_new();
- GtkTreeViewColumn* column = gtk_tree_view_column_new_with_attributes( "Entity", renderer, "text", 0, 0 );
- gtk_tree_view_append_column( GTK_TREE_VIEW( view ), column );
+ auto renderer = ui::CellRendererText(ui::New);
+ 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 );
}
{
- GtkCellRenderer* renderer = gtk_cell_renderer_text_new();
- GtkTreeViewColumn* column = gtk_tree_view_column_new_with_attributes( "Count", renderer, "text", 1, 0 );
- gtk_tree_view_append_column( GTK_TREE_VIEW( view ), column );
+ auto renderer = ui::CellRendererText(ui::New);
+ 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 );
}
- gtk_widget_show( view );
+ view.show();
- gtk_container_add( GTK_CONTAINER( scr ), view );
+ scr.add(view);
EntityBreakdownWalker = store;
}
{
char tmp[16];
sprintf( tmp, "%u", Unsigned( ( *i ).second ) );
- GtkTreeIter iter;
- gtk_list_store_append( GTK_LIST_STORE( EntityBreakdownWalker ), &iter );
- gtk_list_store_set( GTK_LIST_STORE( EntityBreakdownWalker ), &iter, 0, ( *i ).first.c_str(), 1, tmp, -1 );
+ EntityBreakdownWalker.append(0, (*i).first.c_str(), 1, tmp);
}
}
- g_object_unref( G_OBJECT( EntityBreakdownWalker ) );
+ EntityBreakdownWalker.unref();
char tmp[16];
sprintf( tmp, "%u", Unsigned( g_brushCount.get() ) );
- gtk_entry_set_text( GTK_ENTRY( brushes_entry ), tmp );
+ brushes_entry.text(tmp);
sprintf( tmp, "%u", Unsigned( g_entityCount.get() ) );
- gtk_entry_set_text( GTK_ENTRY( entities_entry ), tmp );
+ entities_entry.text(tmp);
modal_dialog_show( window, dialog );
// save before exit
window_get_position( window, g_posMapInfoWnd );
- gtk_widget_destroy( GTK_WIDGET( window ) );
+ window.destroy();
}
: 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_strLastMapFolder = "";
+
/*
================
Map_LoadFile
*/
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_strLastMapFolder = g_path_get_dirname( filename );
+
{
ScopeTimer timer( "map load" );
Map_Free();
}
Brush_toggleFormat( i );
- g_map.m_name = filename;
- g_mapPathObservers.realise();
Map_UpdateTitle( g_map );
+
g_map.m_resource = GlobalReferenceCache().capture( g_map.m_name.c_str() );
if ( format ) {
format->wrongFormat = false;
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 ){
g_map.m_resource->detach( g_map );
GlobalReferenceCache().release( g_map.m_name.c_str() );
- g_mapPathObservers.unrealise();
g_map.m_resource = resource;
g_map.m_name = absolute;
- g_mapPathObservers.realise();
Map_UpdateTitle( g_map );
g_map.m_resource->attach( g_map );
+ // refresh VFS to apply new pak filtering based on mapname
+ // needed for daemon DPK VFS
+ VFS_Refresh();
}
void Map_Rename( const char* filename ){
//globalOutputStream() << "Map_New\n";
g_map.m_name = "unnamed.map";
- g_mapPathObservers.realise();
Map_UpdateTitle( g_map );
{
FocusViews( g_vector3_identity, 0 );
g_currentMap = &g_map;
+
+ // restart VFS to apply new pak filtering based on mapname
+ // needed for daemon DPK VFS
+ VFS_Restart();
}
extern void ConstructRegionBrushes( scene::Node * brushes[6], const Vector3 ®ion_mins, const Vector3 ®ion_maxs );
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_strLastMapFolder = g_path_get_dirname( filename );
+
bool success = false;
if ( extension_equal( path_get_extension( filename ), "bsp" ) ) {
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
*/
bool Map_SaveFile( const char* filename ){
ScopeDisableScreenUpdates disableScreenUpdates( "Processing...", "Saving Map" );
- return MapResource_saveFile( MapFormat_forFile( filename ), GlobalSceneGraph().root(), Map_Traverse, filename );
+ bool success = MapResource_saveFile( MapFormat_forFile( filename ), GlobalSceneGraph().root(), Map_Traverse, filename );
+ if ( success ) {
+ // refresh VFS to apply new pak filtering based on mapname
+ // needed for daemon DPK VFS
+ VFS_Refresh();
+ }
+ return success;
}
//
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* 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_strLastMapFolder.c_str();
+}
+
const char* map_open( const char* title ){
- return file_dialog( GTK_WIDGET( MainFrame_getWindow() ), TRUE, title, getMapsPath(), 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 file_dialog( GTK_WIDGET( MainFrame_getWindow() ), TRUE, title, getMapsPath(), 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 file_dialog( GTK_WIDGET( MainFrame_getWindow() ), FALSE, title, getMapsPath(), MapFormat::Name(), false, false, true );
+ return MainFrame_getWindow().file_dialog( FALSE, title, getLastMapFolderPath(), MapFormat::Name(), false, false, true );
}
void OpenMap(){
const char* filename = map_open( "Open Map" );
- if ( filename != 0 ) {
+ if ( filename != NULL ) {
MRU_AddFile( filename );
Map_RegionOff();
Map_Free();
void ImportMap(){
const char* filename = map_import( "Import Map" );
- if ( filename != 0 ) {
+ if ( filename != NULL ) {
UndoableCommand undo( "mapImport" );
Map_ImportFile( filename );
}
bool Map_SaveAs(){
const char* filename = map_save( "Save Map" );
- if ( filename != 0 ) {
+ if ( filename != NULL ) {
+ g_strLastMapFolder = g_path_get_dirname( filename );
MRU_AddFile( filename );
Map_Rename( filename );
return Map_Save();
void ExportMap(){
const char* filename = map_save( "Export Selection" );
- if ( filename != 0 ) {
+ if ( filename != NULL ) {
+ g_strLastMapFolder = g_path_get_dirname( filename );
Map_SaveSelected( filename );
}
}
void SaveRegion(){
const char* filename = map_save( "Export Region" );
- if ( filename != 0 ) {
+ if ( filename != NULL ) {
+ 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() ) {
void DoFind(){
ModalDialog dialog;
- GtkEntry* entity;
- GtkEntry* brush;
+ ui::Entry entity{ui::null};
+ ui::Entry brush{ui::null};
- GtkWindow* window = create_dialog_window( MainFrame_getWindow(), "Find Brush", G_CALLBACK( dialog_delete_callback ), &dialog );
+ ui::Window window = MainFrame_getWindow().create_dialog_window("Find Brush", G_CALLBACK(dialog_delete_callback ), &dialog );
- GtkAccelGroup* accel = gtk_accel_group_new();
- gtk_window_add_accel_group( window, accel );
+ auto accel = ui::AccelGroup(ui::New);
+ window.add_accel_group( accel );
{
- GtkVBox* vbox = create_dialog_vbox( 4, 4 );
- gtk_container_add( GTK_CONTAINER( window ), GTK_WIDGET( vbox ) );
+ auto vbox = create_dialog_vbox( 4, 4 );
+ window.add(vbox);
{
- GtkTable* table = create_dialog_table( 2, 2, 4, 4 );
- gtk_box_pack_start( GTK_BOX( vbox ), GTK_WIDGET( table ), TRUE, TRUE, 0 );
+ auto table = create_dialog_table( 2, 2, 4, 4 );
+ vbox.pack_start( table, TRUE, TRUE, 0 );
{
- GtkWidget* label = gtk_label_new( "Entity number" );
- gtk_widget_show( label );
- gtk_table_attach( GTK_TABLE( table ), label, 0, 1, 0, 1,
- (GtkAttachOptions) ( 0 ),
- (GtkAttachOptions) ( 0 ), 0, 0 );
+ ui::Widget label = ui::Label( "Entity number" );
+ label.show();
+ (table).attach(label, {0, 1, 0, 1}, {0, 0});
}
{
- GtkWidget* label = gtk_label_new( "Brush number" );
- gtk_widget_show( label );
- gtk_table_attach( GTK_TABLE( table ), label, 0, 1, 1, 2,
- (GtkAttachOptions) ( 0 ),
- (GtkAttachOptions) ( 0 ), 0, 0 );
+ ui::Widget label = ui::Label( "Brush number" );
+ label.show();
+ (table).attach(label, {0, 1, 1, 2}, {0, 0});
}
{
- GtkEntry* entry = GTK_ENTRY( gtk_entry_new() );
- gtk_widget_show( GTK_WIDGET( entry ) );
- 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 ) );
+ auto entry = ui::Entry(ui::New);
+ entry.show();
+ table.attach(entry, {1, 2, 0, 1}, {GTK_EXPAND | GTK_FILL, 0});
+ gtk_widget_grab_focus( entry );
entity = entry;
}
{
- GtkEntry* entry = GTK_ENTRY( gtk_entry_new() );
- gtk_widget_show( GTK_WIDGET( entry ) );
- gtk_table_attach( table, GTK_WIDGET( entry ), 1, 2, 1, 2,
- (GtkAttachOptions) ( GTK_EXPAND | GTK_FILL ),
- (GtkAttachOptions) ( 0 ), 0, 0 );
+ auto entry = ui::Entry(ui::New);
+ entry.show();
+ table.attach(entry, {1, 2, 1, 2}, {GTK_EXPAND | GTK_FILL, 0});
brush = entry;
}
}
{
- GtkHBox* hbox = create_dialog_hbox( 4 );
- gtk_box_pack_start( GTK_BOX( vbox ), GTK_WIDGET( hbox ), TRUE, TRUE, 0 );
+ auto hbox = create_dialog_hbox( 4 );
+ vbox.pack_start( hbox, TRUE, TRUE, 0 );
{
- GtkButton* button = create_dialog_button( "Find", G_CALLBACK( dialog_button_ok ), &dialog );
- gtk_box_pack_start( GTK_BOX( hbox ), GTK_WIDGET( button ), FALSE, FALSE, 0 );
- widget_make_default( GTK_WIDGET( button ) );
- gtk_widget_add_accelerator( GTK_WIDGET( button ), "clicked", accel, GDK_Return, (GdkModifierType)0, (GtkAccelFlags)0 );
+ 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( button , "clicked", accel, GDK_KEY_Return, (GdkModifierType)0, (GtkAccelFlags)0 );
}
{
- GtkButton* button = create_dialog_button( "Close", G_CALLBACK( dialog_button_cancel ), &dialog );
- gtk_box_pack_start( GTK_BOX( hbox ), GTK_WIDGET( button ), FALSE, FALSE, 0 );
- gtk_widget_add_accelerator( GTK_WIDGET( button ), "clicked", accel, GDK_Escape, (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( button , "clicked", accel, GDK_KEY_Escape, (GdkModifierType)0, (GtkAccelFlags)0 );
}
}
}
GetSelectionIndex( &ent, &br );
sprintf( buf, "%i", ent );
- gtk_entry_set_text( entity, buf );
+ entity.text(buf);
sprintf( buf, "%i", br );
- gtk_entry_set_text( brush, buf );
+ brush.text(buf);
if ( modal_dialog_show( window, dialog ) == eIDOK ) {
const char *entstr = gtk_entry_get_text( entity );
SelectBrush( atoi( entstr ), atoi( brushstr ) );
}
- gtk_widget_destroy( GTK_WIDGET( window ) );
+ window.destroy();
}
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 = "";
MapModuleObserver g_MapModuleObserver;
-#include "preferencesystem.h"
-
CopiedString g_strLastMap;
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 );
projects / xonotic / netradiant.git / blobdiff