fixes

afwbkbc · afwbkbc · commit 4a3a947f529e · 2026-02-10T18:29:24.000+02:00
diff --git a/src/ui/dom/Container.cpp b/src/ui/dom/Container.cpp
@@ -161,13 +161,19 @@ void Container::UpdateMouseOver( GSE_CALLABLE ) {
 const bool Container::ProcessEvent( GSE_CALLABLE, const input::Event& event ) {
 	switch ( event.type ) {
 		case input::EV_MOUSE_OUT: {
+			if ( !m_is_mouse_over ) {
+				//return false; // TODO: why this breaks _hover styles?
+			}
+			m_is_mouse_over = false;
 			if ( m_mouse_over_object ) {
 				SetMouseOverChild( GSE_CALL, nullptr, { event.data.mouse.x, event.data.mouse.y } );
 			}
-			m_is_mouse_over = false;
 			break;
 		}
 		case input::EV_MOUSE_OVER: {
+			if ( m_is_mouse_over ) {
+				//return false; // TODO: why this breaks _hover styles?
+			}
 			m_is_mouse_over = true;
 			break;
 		}
@@ -440,5 +446,14 @@ void Container::RemoveChild( GSE_CALLABLE, Object* obj, const bool nodestroy ) {
 	}
 }
 
+void Container::DetachUI() {
+	for ( const auto& it : m_children ) {
+		it.second->DetachUI();
+	}
+	Object::DetachUI();
+}
+
+
+
 }
 }
diff --git a/src/ui/dom/Container.h b/src/ui/dom/Container.h
@@ -14,6 +14,9 @@ class Cache;
 }
 
 namespace ui {
+
+class UI;
+
 namespace dom {
 
 #define FACTORY( _name, _class ) Factory( GSE_CALL, _name, [ this ]( GSE_CALLABLE, const properties_t& p ) { return new _class( GSE_CALL, m_ui, m_factory_owner, p ); })
@@ -88,6 +91,10 @@ class Container : public Area {
 	void AddChild( GSE_CALLABLE, Object* obj, const bool is_visible );
 	void RemoveChild( GSE_CALLABLE, Object* obj, const bool nodestroy = false );
 
+protected:
+	friend class ui::UI;
+	void DetachUI() override;
+
 };
 
 }
diff --git a/src/ui/dom/Drawable.cpp b/src/ui/dom/Drawable.cpp
@@ -108,22 +108,6 @@ void Drawable::GeometryHandler( const geometry_handler_type_t type, const std::f
 	m_geometry_handler_ids.push_back( m_geometry->AddHandler( type, f ) );
 }
 
-const bool Drawable::ProcessEvent( GSE_CALLABLE, const input::Event& event ) {
-	switch ( event.type ) {
-		case input::EV_MOUSE_OVER: {
-			m_is_mouse_over = true;
-			break;
-		}
-		case input::EV_MOUSE_OUT: {
-			m_is_mouse_over = false;
-			break;
-		}
-		default: {
-		}
-	}
-	return Object::ProcessEvent( GSE_CALL, event );
-}
-
 void Drawable::Show() {
 	if ( !m_is_visible ) {
 		Object::Show();
diff --git a/src/ui/dom/Drawable.h b/src/ui/dom/Drawable.h
@@ -22,8 +22,6 @@ class Drawable : public Object {
 
 	void GeometryHandler( const geometry_handler_type_t type, const std::function< void() >& f );
 
-	virtual const bool ProcessEvent( GSE_CALLABLE, const input::Event& event ) override;
-
 	void Show() override;
 	void Hide() override;
 
diff --git a/src/ui/dom/Object.cpp b/src/ui/dom/Object.cpp
@@ -204,12 +204,14 @@ void Object::Destroy( GSE_CALLABLE ) {
 	}
 	Hide();
 	SetClasses( GSE_CALL, {} );
-	if ( m_is_iterable_set ) {
-		m_ui->RemoveIterable( this );
+	if ( m_ui ) {
+		if ( m_is_iterable_set ) {
+			m_ui->RemoveIterable( this );
+		}
 	}
 	{
-		std::lock_guard guard( m_actors_mutex );
 		auto* const scene = m_ui->GetScene();
+		std::lock_guard guard( m_actors_mutex );
 		for ( const auto& actor : m_actors ) {
 			scene->RemoveActor( actor );
 		}
@@ -324,6 +326,7 @@ void Object::Actor( scene::actor::Actor* actor ) {
 		scene::actor::Actor::RF_IGNORE_CAMERA |
 		scene::actor::Actor::RF_IGNORE_LIGHTING
 	);
+	ASSERT( m_ui, "ui detached" );
 	m_ui->GetScene()->AddActor( actor );
 	{
 		std::lock_guard guard( m_actors_mutex );
@@ -337,15 +340,17 @@ void Object::ClearActors() {
 	if ( g ) {
 		g = g->AsRectangle();
 	}
-	auto* const scene = m_ui->GetScene();
-	for ( const auto& actor : m_actors ) {
-		scene->RemoveActor( actor );
-		if ( g ) {
-			((geometry::Rectangle*)g)->Clear();
+	if ( m_ui ) {
+		auto* const scene = m_ui->GetScene();
+		for ( const auto& actor : m_actors ) {
+			scene->RemoveActor( actor );
+			if ( g ) {
+				( (geometry::Rectangle*)g )->Clear();
+			}
+			delete actor;
 		}
-		delete actor;
+		m_actors.clear();
 	}
-	m_actors.clear();
 }
 
 void Object::Property( GSE_CALLABLE, const std::string& name, const gse::value_type_t& type, gse::Value* const default_value, const property_flag_t flags, const f_on_set_t& f_on_set, const f_on_unset_t& f_on_unset ) {
@@ -402,6 +407,7 @@ void Object::Iterable( const std::function< void() >& f ) {
 	ASSERT( !m_is_destroyed, "Iterable: object is destroyed" );
 	ASSERT( !m_is_iterable_set, "iterable already set" );
 	m_is_iterable_set = true;
+	ASSERT( m_ui, "ui detached" );
 	m_ui->AddIterable( this, f );
 }
 
@@ -542,13 +548,15 @@ void Object::Globalize( GSE_CALLABLE, const std::function< void() >& f_on_deglob
 	if ( m_is_globalized ) {
 		Deglobalize( GSE_CALL );
 	}
+	ASSERT( m_ui, "ui detached" );
 	ASSERT( m_parent == m_ui->GetRoot(), "can only globalize children of root object" );
 	m_ui->SetGlobalSingleton( GSE_CALL, this, f_on_deglobalize );
 	m_is_globalized = true;
 }
 
 void Object::Deglobalize( GSE_CALLABLE ) {
 	if ( m_is_globalized ) {
+		ASSERT( m_ui, "ui detached" );
 		ASSERT( m_parent == m_ui->GetRoot(), "can only deglobalize children of root object" );
 		m_ui->RemoveGlobalSingleton( GSE_CALL, this );
 		m_is_globalized = false;
@@ -644,6 +652,7 @@ void Object::SetClasses( GSE_CALLABLE, const std::vector< std::string >& names )
 		ASSERT( m_classes.empty(), "not initialized but classes not empty" );
 	}
 	m_classes.reserve( names.size() );
+	ASSERT( m_ui, "ui detached" );
 	for ( const auto& name : names ) {
 		auto* c = m_ui->GetClass( name );
 		if ( !c ) {
@@ -714,5 +723,10 @@ void Object::UnsetPropertyFromClass( GSE_CALLABLE, const std::string& key ) {
 	}
 }
 
+void Object::DetachUI() {
+	ASSERT( m_ui, "ui already detached" );
+	m_ui = nullptr;
+}
+
 }
 }
diff --git a/src/ui/dom/Object.h b/src/ui/dom/Object.h
@@ -99,7 +99,7 @@ class Object : public gse::GCWrappable {
 
 	void UpdateProperty( const std::string& name, gse::Value* const v );
 
-	UI* const m_ui;
+	UI* m_ui;
 	gc::Space* const m_gc_space;
 	const properties_t m_initial_properties;
 
@@ -179,6 +179,9 @@ class Object : public gse::GCWrappable {
 	virtual void SetPropertyFromClass( GSE_CALLABLE, const std::string& key, gse::Value* const value, const class_modifier_t modifier );
 	virtual void UnsetPropertyFromClass( GSE_CALLABLE, const std::string& key );
 
+protected:
+	friend class ui::UI;
+	virtual void DetachUI();
 };
 
 }
diff --git a/src/ui/dom/Panel.cpp b/src/ui/dom/Panel.cpp
@@ -70,30 +70,29 @@ void Panel::UpdateBorderTexture() {
 	m_surface->GetGeometry()->SetPadding( std::ceil( m_border_corners / 2 ) );
 	auto* texture = m_border_surface->GetOwnedTexturePtr();
 	const auto& a = m_geometry->AsRectangle()->m_area;
-	if ( texture->Resize( std::round( a.width ), std::round( a.height ) ) ) {
-		auto* bitmap = texture->GetBitmap();
-		if ( bitmap ) {
-			memset( bitmap, 0, texture->GetBitmapSize() );
-			if ( m_border_color != types::Color{} ) {
-				long int r = std::ceil( std::fmin( m_border_corners, std::min( a.width, a.height ) / 2 - 1 ) );
-				for ( auto x = r ; x < a.width - r ; x++ ) {
-					texture->SetPixel( x, 0, m_border_color );
-					texture->SetPixel( x, a.height - 1, m_border_color );
-				}
-				for ( auto y = r ; y < a.height - r ; y++ ) {
-					texture->SetPixel( 0, y, m_border_color );
-					texture->SetPixel( a.width - 1, y, m_border_color );
-				}
-				for ( auto i = 0 ; i < r ; i++ ) {
-					texture->SetPixel( i, r - i, m_border_color );
-					texture->SetPixel( r - i, i, m_border_color );
-					texture->SetPixel( a.width - 1 - i, r - i, m_border_color );
-					texture->SetPixel( a.width - 1 - ( r - i ), i, m_border_color );
-					texture->SetPixel( a.width - 1 - i, a.height - 1 - ( r - i ), m_border_color );
-					texture->SetPixel( a.width - 1 - ( r - i ), a.height - 1 - i, m_border_color );
-					texture->SetPixel( i, a.height - 1 - ( r - i ), m_border_color );
-					texture->SetPixel( r - i, a.height - 1 - i, m_border_color );
-				}
+	texture->Resize( std::round( a.width ), std::round( a.height ) );
+	auto* bitmap = texture->GetBitmap();
+	if ( bitmap ) {
+		memset( bitmap, 0, texture->GetBitmapSize() );
+		if ( m_border_color != types::Color{} ) {
+			long int r = std::ceil( std::fmin( m_border_corners, std::min( a.width, a.height ) / 2 - 1 ) );
+			for ( auto x = r ; x < a.width - r ; x++ ) {
+				texture->SetPixel( x, 0, m_border_color );
+				texture->SetPixel( x, a.height - 1, m_border_color );
+			}
+			for ( auto y = r ; y < a.height - r ; y++ ) {
+				texture->SetPixel( 0, y, m_border_color );
+				texture->SetPixel( a.width - 1, y, m_border_color );
+			}
+			for ( auto i = 0 ; i < r ; i++ ) {
+				texture->SetPixel( i, r - i, m_border_color );
+				texture->SetPixel( r - i, i, m_border_color );
+				texture->SetPixel( a.width - 1 - i, r - i, m_border_color );
+				texture->SetPixel( a.width - 1 - ( r - i ), i, m_border_color );
+				texture->SetPixel( a.width - 1 - i, a.height - 1 - ( r - i ), m_border_color );
+				texture->SetPixel( a.width - 1 - ( r - i ), a.height - 1 - i, m_border_color );
+				texture->SetPixel( i, a.height - 1 - ( r - i ), m_border_color );
+				texture->SetPixel( r - i, a.height - 1 - i, m_border_color );
 			}
 		}
 		texture->FullUpdate(); // TODO: optimize?
diff --git a/src/ui/dom/Root.cpp b/src/ui/dom/Root.cpp
@@ -17,6 +17,10 @@ Root::Root( GSE_CALLABLE, UI* const ui )
 	Show();
 }
 
+Root::~Root() {
+	Container::DetachUI();
+}
+
 void Root::Resize( const uint16_t window_width, const uint16_t window_height ) {
 	m_geometry->SetWidth( window_width );
 	m_geometry->SetHeight( window_height );
diff --git a/src/ui/dom/Root.h b/src/ui/dom/Root.h
@@ -11,6 +11,7 @@ namespace dom {
 class Root : public Container {
 public:
 	Root( GSE_CALLABLE, UI* const ui );
+	virtual ~Root();
 
 private:
 	friend class ui::UI;
diff --git a/src/ui/dom/Scrollview.cpp b/src/ui/dom/Scrollview.cpp
@@ -26,6 +26,8 @@ Scrollview::Scrollview( DOM_ARGS_T, const bool factories_allowed )
 		auto* g = m_inner->GetGeometry();
 		g->SetParent( m_geometry );
 		g->SetOverflowMode( geometry::Geometry::OM_RESIZE );
+		g->SetLeft( 0 );
+		g->SetTop( 0 );
 		g->m_on_resize = [ this ]( const size_t width, const size_t height ) {
 			if ( !m_is_updating ) {
 				m_is_updating = true;
@@ -175,6 +177,9 @@ void Scrollview::UpdateScrollbars( size_t width, size_t height ) {
 		height = g->GetInnerHeight();
 	}
 
+	ASSERT( width < VERY_BIG_NUMBER, "scrollbars width overflow" );
+	ASSERT( height < VERY_BIG_NUMBER, "scrollbars height overflow" );
+
 	const auto vscroll_w = m_vscroll->GetGeometry()->m_area.width;
 	const auto hscroll_h = m_hscroll->GetGeometry()->m_area.height;
 	auto outer_w = m_geometry->m_area.width;
diff --git a/src/ui/geometry/Geometry.cpp b/src/ui/geometry/Geometry.cpp
@@ -17,7 +17,6 @@ Geometry::Geometry( const UI* const ui, Geometry* const parent, const geometry_t
 	UpdateArea();
 	if ( m_parent ) {
 		m_parent->m_children.insert( this );
-		m_parent->UpdateEffectiveArea( false );
 	}
 }
 
@@ -454,35 +453,41 @@ void Geometry::UpdateArea() {
 void Geometry::UpdateEffectiveArea( const bool is_update_from_parent ) {
 	area_t effective_area = {};
 	if ( m_is_visible ) {
-		effective_area = m_area;
-		if ( m_overflow_mode != OM_HIDDEN ) {
-			for ( const auto& child : m_children ) {
-				if ( child->m_is_visible ) {
-					effective_area.EnlargeTo( child->GetEffectiveArea() );
+		if ( m_overflow_mode == OM_RESIZE ) { // for scrollviews
+			ASSERT( m_parent, "overflow resize without parent" );
+			effective_area = m_parent->m_effective_area;
+		}
+		else {
+			effective_area = m_area;
+			if ( m_overflow_mode != OM_HIDDEN ) {
+				for ( const auto& child : m_children ) {
+					if ( child->m_is_visible ) {
+						effective_area.EnlargeTo( child->GetEffectiveArea() );
+					}
 				}
 			}
+			FixArea( effective_area );
 		}
-		FixArea( effective_area );
-	}
-	if ( effective_area != m_effective_area ) {
+		if ( effective_area != m_effective_area ) {
 #if defined( DEBUG ) || defined( FASTDEBUG )
-		const auto& g = g_engine->GetGraphics();
-		const auto maxx = g->GetViewportWidth() - 1;
-		const auto maxy = g->GetViewportHeight() - 1;
+			const auto& g = g_engine->GetGraphics();
+			const auto maxx = g->GetViewportWidth() - 1;
+			const auto maxy = g->GetViewportHeight() - 1;
 #endif
-		ASSERT( effective_area.left >= 0 && effective_area.left <= maxx, "effective area left overflow" );
-		ASSERT( effective_area.top >= 0 && effective_area.top <= maxy, "effective area top overflow" );
-		ASSERT( effective_area.right >= 0 && effective_area.right <= maxx, "effective area right overflow" );
-		ASSERT( effective_area.bottom >= 0 && effective_area.bottom <= maxy, "effective area bottom overflow" );
-		const bool should_resize = std::round( effective_area.width ) != std::round( m_effective_area.width ) || std::round( effective_area.height ) != std::round( m_effective_area.height );
-		m_effective_area = effective_area;
-		if ( should_resize && m_on_resize ) {
-			m_on_resize( m_effective_area.width, m_effective_area.height );
-		}
-		if ( m_parent && !is_update_from_parent ) {
-			m_parent->OnChildUpdate();
+			ASSERT( effective_area.left >= 0 && effective_area.left <= maxx, "effective area left overflow" );
+			ASSERT( effective_area.top >= 0 && effective_area.top <= maxy, "effective area top overflow" );
+			ASSERT( effective_area.right >= 0 && effective_area.right <= maxx, "effective area right overflow" );
+			ASSERT( effective_area.bottom >= 0 && effective_area.bottom <= maxy, "effective area bottom overflow" );
+			const bool should_resize = std::round( effective_area.width ) != std::round( m_effective_area.width ) || std::round( effective_area.height ) != std::round( m_effective_area.height );
+			if ( should_resize && m_on_resize ) {
+				m_on_resize( effective_area.width, effective_area.height );
+			}
+			m_effective_area = effective_area;
+			if ( m_parent && !is_update_from_parent ) {
+				m_parent->OnChildUpdate();
+			}
+			RunHandlers( GH_ON_EFFECTIVE_AREA_UPDATE );
 		}
-		RunHandlers( GH_ON_EFFECTIVE_AREA_UPDATE );
 	}
 }
 
@@ -561,6 +566,9 @@ void Geometry::RemoveBoundaries( Geometry* const g ) {
     if ( m_boundaries._a._b.child == g ) { \
         m_boundaries._a._b = {}; \
         for ( const auto& c : m_children ) { \
+            if ( c->m_is_destroying ) { \
+                continue; \
+            } \
             const auto& v = _get; \
             if ( !m_boundaries._a._b.child || m_boundaries._a._b.value _op v ) { \
                 m_boundaries._a._b = { c, v }; \
@@ -591,7 +599,6 @@ void Geometry::ResizeAreaFromChildren() {
 			m_area.EnlargeTo( child->m_area );
 		}
 	}
-	FixArea( m_area );
 }
 
 }
diff --git a/src/ui/geometry/Rectangle.cpp b/src/ui/geometry/Rectangle.cpp
@@ -11,7 +11,11 @@ namespace ui {
 namespace geometry {
 
 Rectangle::Rectangle( const UI* const ui, Geometry* const parent )
-	: Geometry( ui, parent, GT_RECTANGLE ) {}
+	: Geometry( ui, parent, GT_RECTANGLE ) {
+	if ( m_parent ) {
+		m_parent->UpdateEffectiveArea( false );
+	}
+}
 
 Rectangle::~Rectangle() {
 	Clear();

Original file line number	Diff line number	Diff line change
`@@ -161,13 +161,19 @@ void Container::UpdateMouseOver( GSE_CALLABLE ) {`
`161`	`161`	`const bool Container::ProcessEvent( GSE_CALLABLE, const input::Event& event ) {`
`162`	`162`	`switch ( event.type ) {`
`163`	`163`	`case input::EV_MOUSE_OUT: {`
	`164`	`+ if ( !m_is_mouse_over ) {`
	`165`	`+ //return false; // TODO: why this breaks _hover styles?`
	`166`	`+ }`
	`167`	`+ m_is_mouse_over = false;`
`164`	`168`	`if ( m_mouse_over_object ) {`
`165`	`169`	`SetMouseOverChild( GSE_CALL, nullptr, { event.data.mouse.x, event.data.mouse.y } );`
`166`	`170`	`}`
`167`		`- m_is_mouse_over = false;`
`168`	`171`	`break;`
`169`	`172`	`}`
`170`	`173`	`case input::EV_MOUSE_OVER: {`
	`174`	`+ if ( m_is_mouse_over ) {`
	`175`	`+ //return false; // TODO: why this breaks _hover styles?`
	`176`	`+ }`
`171`	`177`	`m_is_mouse_over = true;`
`172`	`178`	`break;`
`173`	`179`	`}`
`@@ -440,5 +446,14 @@ void Container::RemoveChild( GSE_CALLABLE, Object* obj, const bool nodestroy ) {`
`440`	`446`	`}`
`441`	`447`	`}`
`442`	`448`
	`449`	`+void Container::DetachUI() {`
	`450`	`+ for ( const auto& it : m_children ) {`
	`451`	`+ it.second->DetachUI();`
	`452`	`+ }`
	`453`	`+ Object::DetachUI();`
	`454`	`+}`
	`455`	`+`
	`456`	`+`
	`457`	`+`
`443`	`458`	`}`
`444`	`459`	`}`
Original file line number	Diff line number	Diff line change
`@@ -204,12 +204,14 @@ void Object::Destroy( GSE_CALLABLE ) {`
`204`	`204`	`}`
`205`	`205`	`Hide();`
`206`	`206`	`SetClasses( GSE_CALL, {} );`
`207`		`- if ( m_is_iterable_set ) {`
`208`		`- m_ui->RemoveIterable( this );`
	`207`	`+ if ( m_ui ) {`
	`208`	`+ if ( m_is_iterable_set ) {`
	`209`	`+ m_ui->RemoveIterable( this );`
	`210`	`+ }`
`209`	`211`	`}`
`210`	`212`	`{`
`211`		`- std::lock_guard guard( m_actors_mutex );`
`212`	`213`	`auto* const scene = m_ui->GetScene();`
	`214`	`+ std::lock_guard guard( m_actors_mutex );`
`213`	`215`	`for ( const auto& actor : m_actors ) {`
`214`	`216`	`scene->RemoveActor( actor );`
`215`	`217`	`}`
`@@ -324,6 +326,7 @@ void Object::Actor( scene::actor::Actor* actor ) {`
`324`	`326`	`scene::actor::Actor::RF_IGNORE_CAMERA \|`
`325`	`327`	`scene::actor::Actor::RF_IGNORE_LIGHTING`
`326`	`328`	`);`
	`329`	`+ ASSERT( m_ui, "ui detached" );`
`327`	`330`	`m_ui->GetScene()->AddActor( actor );`
`328`	`331`	`{`
`329`	`332`	`std::lock_guard guard( m_actors_mutex );`
`@@ -337,15 +340,17 @@ void Object::ClearActors() {`
`337`	`340`	`if ( g ) {`
`338`	`341`	`g = g->AsRectangle();`
`339`	`342`	`}`
`340`		`- auto* const scene = m_ui->GetScene();`
`341`		`- for ( const auto& actor : m_actors ) {`
`342`		`- scene->RemoveActor( actor );`
`343`		`- if ( g ) {`
`344`		`- ((geometry::Rectangle*)g)->Clear();`
	`343`	`+ if ( m_ui ) {`
	`344`	`+ auto* const scene = m_ui->GetScene();`
	`345`	`+ for ( const auto& actor : m_actors ) {`
	`346`	`+ scene->RemoveActor( actor );`
	`347`	`+ if ( g ) {`
	`348`	`+ ( (geometry::Rectangle*)g )->Clear();`
	`349`	`+ }`
	`350`	`+ delete actor;`
`345`	`351`	`}`
`346`		`- delete actor;`
	`352`	`+ m_actors.clear();`
`347`	`353`	`}`
`348`		`- m_actors.clear();`
`349`	`354`	`}`
`350`	`355`
`351`	`356`	`void Object::Property( GSE_CALLABLE, const std::string& name, const gse::value_type_t& type, gse::Value* const default_value, const property_flag_t flags, const f_on_set_t& f_on_set, const f_on_unset_t& f_on_unset ) {`
`@@ -402,6 +407,7 @@ void Object::Iterable( const std::function< void() >& f ) {`
`402`	`407`	`ASSERT( !m_is_destroyed, "Iterable: object is destroyed" );`
`403`	`408`	`ASSERT( !m_is_iterable_set, "iterable already set" );`
`404`	`409`	`m_is_iterable_set = true;`
	`410`	`+ ASSERT( m_ui, "ui detached" );`
`405`	`411`	`m_ui->AddIterable( this, f );`
`406`	`412`	`}`
`407`	`413`
`@@ -542,13 +548,15 @@ void Object::Globalize( GSE_CALLABLE, const std::function< void() >& f_on_deglob`
`542`	`548`	`if ( m_is_globalized ) {`
`543`	`549`	`Deglobalize( GSE_CALL );`
`544`	`550`	`}`
	`551`	`+ ASSERT( m_ui, "ui detached" );`
`545`	`552`	`ASSERT( m_parent == m_ui->GetRoot(), "can only globalize children of root object" );`
`546`	`553`	`m_ui->SetGlobalSingleton( GSE_CALL, this, f_on_deglobalize );`
`547`	`554`	`m_is_globalized = true;`
`548`	`555`	`}`
`549`	`556`
`550`	`557`	`void Object::Deglobalize( GSE_CALLABLE ) {`
`551`	`558`	`if ( m_is_globalized ) {`
	`559`	`+ ASSERT( m_ui, "ui detached" );`
`552`	`560`	`ASSERT( m_parent == m_ui->GetRoot(), "can only deglobalize children of root object" );`
`553`	`561`	`m_ui->RemoveGlobalSingleton( GSE_CALL, this );`
`554`	`562`	`m_is_globalized = false;`
`@@ -644,6 +652,7 @@ void Object::SetClasses( GSE_CALLABLE, const std::vector< std::string >& names )`
`644`	`652`	`ASSERT( m_classes.empty(), "not initialized but classes not empty" );`
`645`	`653`	`}`
`646`	`654`	`m_classes.reserve( names.size() );`
	`655`	`+ ASSERT( m_ui, "ui detached" );`
`647`	`656`	`for ( const auto& name : names ) {`
`648`	`657`	`auto* c = m_ui->GetClass( name );`
`649`	`658`	`if ( !c ) {`
`@@ -714,5 +723,10 @@ void Object::UnsetPropertyFromClass( GSE_CALLABLE, const std::string& key ) {`
`714`	`723`	`}`
`715`	`724`	`}`
`716`	`725`
	`726`	`+void Object::DetachUI() {`
	`727`	`+ ASSERT( m_ui, "ui already detached" );`
	`728`	`+ m_ui = nullptr;`
	`729`	`+}`
	`730`	`+`
`717`	`731`	`}`
`718`	`732`	`}`