From ce76f870fd09edb1dd05ddba399c599c210b2d34 Mon Sep 17 00:00:00 2001
From: JoeZane <joezane.cn@gmail.com>
Date: Sun, 20 Apr 2025 00:33:17 +0800
Subject: [PATCH 1/7] add: complete `remove chidlren` function in split_pane

---
 tmui/src/split_pane.rs | 11 +++++++++--
 1 file changed, 9 insertions(+), 2 deletions(-)

diff --git a/tmui/src/split_pane.rs b/tmui/src/split_pane.rs
index 6b9ae27..e1bbec5 100644
--- a/tmui/src/split_pane.rs
+++ b/tmui/src/split_pane.rs
@@ -82,8 +82,15 @@ impl ContainerImplExt for SplitPane {
         self.update();
     }
 
-    fn remove_children(&mut self, _id: ObjectId) {
-        // TODO
+    fn remove_children(&mut self, id: ObjectId) {
+        if let Some(index) = self.container.children.iter().position(|w| w.id() == id) {
+            let removed = self.container.children.remove(index);
+            self.close_pane(removed.id());
+
+            let window = ApplicationWindow::window();
+            window._add_removed_widget(removed);
+            window.layout_change(self);
+        }
     }
 }
 

From 4944dc9ed91d625a75ef26d3d51cda857c6b446c Mon Sep 17 00:00:00 2001
From: JoeZane <joezane.cn@gmail.com>
Date: Sun, 20 Apr 2025 01:54:12 +0800
Subject: [PATCH 2/7] upd: Add unified pointer prototype.

---
 tmui/src/application_window.rs   |  4 +-
 tmui/src/prelude.rs              |  1 +
 tmui/src/primitive/mod.rs        |  3 +-
 tmui/src/primitive/obj/alloc.rs  | 37 ++++++++++++++++++
 tmui/src/primitive/obj/dyn_tr.rs | 59 +++++++++++++++++++++++++++++
 tmui/src/primitive/obj/mod.rs    |  7 ++++
 tmui/src/primitive/obj/tr.rs     | 65 ++++++++++++++++++++++++++++++++
 7 files changed, 174 insertions(+), 2 deletions(-)
 create mode 100644 tmui/src/primitive/obj/alloc.rs
 create mode 100644 tmui/src/primitive/obj/dyn_tr.rs
 create mode 100644 tmui/src/primitive/obj/mod.rs
 create mode 100644 tmui/src/primitive/obj/tr.rs

diff --git a/tmui/src/application_window.rs b/tmui/src/application_window.rs
index c787906..a5ebf0c 100644
--- a/tmui/src/application_window.rs
+++ b/tmui/src/application_window.rs
@@ -11,7 +11,7 @@ use crate::{
     loading::LoadingMgr,
     platform::{ipc_bridge::IpcBridge, PlatformType},
     prelude::*,
-    primitive::{global_watch::GlobalWatchEvent, Message},
+    primitive::{global_watch::GlobalWatchEvent, obj::TrAllocater, Message},
     runtime::{wed, window_context::OutputSender},
     shortcut::mgr::ShortcutMgr,
     tooltip::TooltipStrat,
@@ -772,6 +772,8 @@ impl ApplicationWindow {
                 FocusMgr::with(|mgr| mgr.borrow_mut().remove(id));
                 ShortcutMgr::with(|mgr| mgr.borrow_mut().remove_shortcut_all(id));
                 CloseHandlerMgr::remove(id);
+
+                TrAllocater::remove(id);
             }
         }
 
diff --git a/tmui/src/prelude.rs b/tmui/src/prelude.rs
index 131e686..6570c35 100644
--- a/tmui/src/prelude.rs
+++ b/tmui/src/prelude.rs
@@ -49,6 +49,7 @@ pub use crate::primitive::close_handler::{
 pub use crate::primitive::global_watch::{
     GlobalWatch, GlobalWatchEvent, GlobalWatchImpl, ReflectGlobalWatch,
 };
+pub use crate::primitive::obj::*;
 pub use crate::scroll_area::{
     LayoutMode, ReflectScrollAreaExt, ScrollArea, ScrollAreaExt, ScrollAreaGenericExt,
     ScrollAreaSlots,
diff --git a/tmui/src/primitive/mod.rs b/tmui/src/primitive/mod.rs
index 871b1c2..b590c1b 100644
--- a/tmui/src/primitive/mod.rs
+++ b/tmui/src/primitive/mod.rs
@@ -3,8 +3,9 @@ pub mod close_handler;
 pub mod cpu_balance;
 pub mod frame;
 pub mod global_watch;
+pub mod obj;
 
 pub(crate) mod message;
 pub(crate) mod shared_channel;
 
-pub(crate) use message::*;
\ No newline at end of file
+pub(crate) use message::*;
diff --git a/tmui/src/primitive/obj/alloc.rs b/tmui/src/primitive/obj/alloc.rs
new file mode 100644
index 0000000..72eaf25
--- /dev/null
+++ b/tmui/src/primitive/obj/alloc.rs
@@ -0,0 +1,37 @@
+use super::Tr;
+use crate::widget::WidgetImpl;
+use nohash_hasher::IntMap;
+use std::cell::RefCell;
+use tlib::{
+    object::{ObjectId, ObjectSubclass},
+    Object,
+};
+
+thread_local! {
+    static OWNER_STORAGE: RefCell<IntMap<ObjectId, Box<dyn WidgetImpl>>> = RefCell::new(IntMap::default());
+}
+
+pub(crate) struct TrAllocater;
+impl TrAllocater {
+    #[inline]
+    pub(crate) fn insert(owner: Box<dyn WidgetImpl>) {
+        OWNER_STORAGE.with_borrow_mut(|map| map.insert(owner.id(), owner));
+    }
+
+    #[inline]
+    pub(crate) fn remove(id: ObjectId) {
+        OWNER_STORAGE.with_borrow_mut(|map| map.remove(&id));
+    }
+}
+
+pub trait TrAlloc<T: WidgetImpl + ObjectSubclass + Default> {
+    #[inline]
+    fn new_alloc() -> Tr<T> {
+        let mut obj: Box<T> = Object::new(&[]);
+        let tr = Tr::from_raw(obj.as_mut());
+        TrAllocater::insert(obj);
+        tr
+    }
+}
+
+impl<T: WidgetImpl + ObjectSubclass + Default> TrAlloc<T> for T {}
diff --git a/tmui/src/primitive/obj/dyn_tr.rs b/tmui/src/primitive/obj/dyn_tr.rs
new file mode 100644
index 0000000..edd009e
--- /dev/null
+++ b/tmui/src/primitive/obj/dyn_tr.rs
@@ -0,0 +1,59 @@
+use super::Tr;
+use crate::widget::WidgetImpl;
+use std::ops::{Deref, DerefMut};
+
+#[repr(transparent)]
+#[derive(Debug, PartialEq, Eq, Clone, Copy)]
+pub struct DynTr {
+    raw: *mut dyn WidgetImpl,
+}
+
+impl DynTr {
+    /// # SAFETY
+    ///
+    /// The raw pointer becomes invalid when the widget is removed.
+    #[inline]
+    pub fn bind(&self) -> &dyn WidgetImpl {
+        unsafe {
+            self.raw
+                .as_ref()
+                .expect("Fatal error, try to access the removed reference.")
+        }
+    }
+
+    /// # SAFETY
+    ///
+    /// The raw pointer becomes invalid when the widget is removed.
+    #[inline]
+    pub fn bind_mut(&mut self) -> &mut dyn WidgetImpl {
+        unsafe {
+            self.raw
+                .as_mut()
+                .expect("Fatal error, try to access the removed reference.")
+        }
+    }
+}
+
+impl<R: WidgetImpl> From<Tr<R>> for DynTr {
+    fn from(mut value: Tr<R>) -> Self {
+        let dyn_mut = value.as_dyn_mut();
+
+        Self { raw: dyn_mut }
+    }
+}
+
+impl Deref for DynTr {
+    type Target = dyn WidgetImpl;
+
+    #[inline]
+    fn deref(&self) -> &Self::Target {
+        self.bind()
+    }
+}
+
+impl DerefMut for DynTr {
+    #[inline]
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        self.bind_mut()
+    }
+}
diff --git a/tmui/src/primitive/obj/mod.rs b/tmui/src/primitive/obj/mod.rs
new file mode 100644
index 0000000..752fead
--- /dev/null
+++ b/tmui/src/primitive/obj/mod.rs
@@ -0,0 +1,7 @@
+pub mod alloc;
+pub mod dyn_tr;
+pub mod tr;
+
+pub use alloc::*;
+pub use dyn_tr::*;
+pub use tr::*;
diff --git a/tmui/src/primitive/obj/tr.rs b/tmui/src/primitive/obj/tr.rs
new file mode 100644
index 0000000..0738920
--- /dev/null
+++ b/tmui/src/primitive/obj/tr.rs
@@ -0,0 +1,65 @@
+use crate::widget::WidgetImpl;
+use std::ops::{Deref, DerefMut};
+
+#[repr(transparent)]
+#[derive(Debug, PartialEq, Eq, Clone, Copy)]
+pub struct Tr<R: WidgetImpl> {
+    raw: *mut R,
+}
+
+impl<R: WidgetImpl> Tr<R> {
+    #[inline]
+    pub(crate) fn from_raw(raw: *mut R) -> Tr<R> {
+        Tr { raw }
+    }
+
+    /// # SAFETY
+    ///
+    /// The raw pointer becomes invalid when the widget is removed.
+    #[inline]
+    pub fn bind(&self) -> &R {
+        unsafe {
+            self.raw
+                .as_ref()
+                .expect("Fatal error, try to access the removed reference.")
+        }
+    }
+
+    /// # SAFETY
+    ///
+    /// The raw pointer becomes invalid when the widget is removed.
+    #[inline]
+    pub fn bind_mut(&mut self) -> &mut R {
+        unsafe {
+            self.raw
+                .as_mut()
+                .expect("Fatal error, try to access the removed reference.")
+        }
+    }
+
+    #[inline]
+    pub fn as_dyn(&self) -> &dyn WidgetImpl {
+        self.bind() as &dyn WidgetImpl
+    }
+
+    #[inline]
+    pub fn as_dyn_mut(&mut self) -> &mut dyn WidgetImpl {
+        self.bind_mut() as &mut dyn WidgetImpl
+    }
+}
+
+impl<R: WidgetImpl> Deref for Tr<R> {
+    type Target = R;
+
+    #[inline]
+    fn deref(&self) -> &Self::Target {
+        self.bind()
+    }
+}
+
+impl<R: WidgetImpl> DerefMut for Tr<R> {
+    #[inline]
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        self.bind_mut()
+    }
+}

From 28e4adc33a96d2df6d4e93cc809a7de5bad74c2a Mon Sep 17 00:00:00 2001
From: JoeZane <joezane.cn@gmail.com>
Date: Sun, 20 Apr 2025 18:46:39 +0800
Subject: [PATCH 3/7] upd: Add `ref_count` to `Tr`, `DynTr`

---
 tmui/src/application_window.rs   |  4 +-
 tmui/src/primitive/obj/alloc.rs  |  2 +-
 tmui/src/primitive/obj/dyn_tr.rs | 52 ++++++++++++++++++++----
 tmui/src/primitive/obj/tr.rs     | 69 +++++++++++++++++++++++++++++---
 tmui/src/widget/widget_inner.rs  | 13 +++---
 5 files changed, 114 insertions(+), 26 deletions(-)

diff --git a/tmui/src/application_window.rs b/tmui/src/application_window.rs
index a5ebf0c..c787906 100644
--- a/tmui/src/application_window.rs
+++ b/tmui/src/application_window.rs
@@ -11,7 +11,7 @@ use crate::{
     loading::LoadingMgr,
     platform::{ipc_bridge::IpcBridge, PlatformType},
     prelude::*,
-    primitive::{global_watch::GlobalWatchEvent, obj::TrAllocater, Message},
+    primitive::{global_watch::GlobalWatchEvent, Message},
     runtime::{wed, window_context::OutputSender},
     shortcut::mgr::ShortcutMgr,
     tooltip::TooltipStrat,
@@ -772,8 +772,6 @@ impl ApplicationWindow {
                 FocusMgr::with(|mgr| mgr.borrow_mut().remove(id));
                 ShortcutMgr::with(|mgr| mgr.borrow_mut().remove_shortcut_all(id));
                 CloseHandlerMgr::remove(id);
-
-                TrAllocater::remove(id);
             }
         }
 
diff --git a/tmui/src/primitive/obj/alloc.rs b/tmui/src/primitive/obj/alloc.rs
index 72eaf25..443ac7b 100644
--- a/tmui/src/primitive/obj/alloc.rs
+++ b/tmui/src/primitive/obj/alloc.rs
@@ -11,7 +11,7 @@ thread_local! {
     static OWNER_STORAGE: RefCell<IntMap<ObjectId, Box<dyn WidgetImpl>>> = RefCell::new(IntMap::default());
 }
 
-pub(crate) struct TrAllocater;
+pub(crate) struct TrAllocater {}
 impl TrAllocater {
     #[inline]
     pub(crate) fn insert(owner: Box<dyn WidgetImpl>) {
diff --git a/tmui/src/primitive/obj/dyn_tr.rs b/tmui/src/primitive/obj/dyn_tr.rs
index edd009e..98c4378 100644
--- a/tmui/src/primitive/obj/dyn_tr.rs
+++ b/tmui/src/primitive/obj/dyn_tr.rs
@@ -1,17 +1,21 @@
-use super::Tr;
+use super::{Tr, TrAllocater};
 use crate::widget::WidgetImpl;
-use std::ops::{Deref, DerefMut};
+use std::{
+    cell::Cell,
+    ops::{Deref, DerefMut},
+    rc::Rc,
+};
 
-#[repr(transparent)]
-#[derive(Debug, PartialEq, Eq, Clone, Copy)]
+#[derive(Debug, PartialEq, Eq)]
 pub struct DynTr {
     raw: *mut dyn WidgetImpl,
+    ref_count: Rc<Cell<i32>>,
 }
 
 impl DynTr {
     /// # SAFETY
     ///
-    /// The raw pointer becomes invalid when the widget is removed.
+    /// Destruction of the underlying object is managed by reference counting, and exceptions should never occur.
     #[inline]
     pub fn bind(&self) -> &dyn WidgetImpl {
         unsafe {
@@ -23,7 +27,7 @@ impl DynTr {
 
     /// # SAFETY
     ///
-    /// The raw pointer becomes invalid when the widget is removed.
+    /// Destruction of the underlying object is managed by reference counting, and exceptions should never occur.
     #[inline]
     pub fn bind_mut(&mut self) -> &mut dyn WidgetImpl {
         unsafe {
@@ -35,10 +39,42 @@ impl DynTr {
 }
 
 impl<R: WidgetImpl> From<Tr<R>> for DynTr {
+    #[inline]
     fn from(mut value: Tr<R>) -> Self {
-        let dyn_mut = value.as_dyn_mut();
+        let ref_count = value.clone_ref_count();
+        ref_count.set(ref_count.get() + 1);
+
+        Self {
+            raw: value.as_dyn_mut(),
+            ref_count,
+        }
+    }
+}
+
+impl Clone for DynTr {
+    #[inline]
+    fn clone(&self) -> Self {
+        let ref_count = self.ref_count.clone();
+        ref_count.set(ref_count.get() + 1);
 
-        Self { raw: dyn_mut }
+        Self {
+            raw: self.raw,
+            ref_count,
+        }
+    }
+}
+
+impl Drop for DynTr {
+    #[inline]
+    fn drop(&mut self) {
+        self.ref_count.set(self.ref_count.get() - 1);
+
+        let ref_cnt = self.ref_count.get();
+        debug_assert!(ref_cnt >= 0);
+
+        if ref_cnt == 0 {
+            TrAllocater::remove(self.id());
+        }
     }
 }
 
diff --git a/tmui/src/primitive/obj/tr.rs b/tmui/src/primitive/obj/tr.rs
index 0738920..089b15d 100644
--- a/tmui/src/primitive/obj/tr.rs
+++ b/tmui/src/primitive/obj/tr.rs
@@ -1,21 +1,34 @@
+use super::TrAllocater;
 use crate::widget::WidgetImpl;
-use std::ops::{Deref, DerefMut};
+use std::{
+    cell::Cell,
+    ops::{Deref, DerefMut},
+    rc::Rc,
+};
 
-#[repr(transparent)]
-#[derive(Debug, PartialEq, Eq, Clone, Copy)]
+#[derive(Debug, PartialEq, Eq)]
 pub struct Tr<R: WidgetImpl> {
     raw: *mut R,
+    ref_count: Rc<Cell<i32>>,
 }
 
 impl<R: WidgetImpl> Tr<R> {
     #[inline]
     pub(crate) fn from_raw(raw: *mut R) -> Tr<R> {
-        Tr { raw }
+        Tr {
+            raw,
+            ref_count: Rc::new(Cell::new(1)),
+        }
+    }
+
+    #[inline]
+    pub(crate) fn clone_ref_count(&self) -> Rc<Cell<i32>> {
+        self.ref_count.clone()
     }
 
     /// # SAFETY
     ///
-    /// The raw pointer becomes invalid when the widget is removed.
+    /// Destruction of the underlying object is managed by reference counting, and exceptions should never occur.
     #[inline]
     pub fn bind(&self) -> &R {
         unsafe {
@@ -27,7 +40,7 @@ impl<R: WidgetImpl> Tr<R> {
 
     /// # SAFETY
     ///
-    /// The raw pointer becomes invalid when the widget is removed.
+    /// Destruction of the underlying object is managed by reference counting, and exceptions should never occur.
     #[inline]
     pub fn bind_mut(&mut self) -> &mut R {
         unsafe {
@@ -48,6 +61,33 @@ impl<R: WidgetImpl> Tr<R> {
     }
 }
 
+impl<R: WidgetImpl> Clone for Tr<R> {
+    #[inline]
+    fn clone(&self) -> Self {
+        let ref_count = self.ref_count.clone();
+        ref_count.set(ref_count.get() + 1);
+
+        Self {
+            raw: self.raw,
+            ref_count,
+        }
+    }
+}
+
+impl<R: WidgetImpl> Drop for Tr<R> {
+    #[inline]
+    fn drop(&mut self) {
+        self.ref_count.set(self.ref_count.get() - 1);
+
+        let ref_cnt = self.ref_count.get();
+        debug_assert!(ref_cnt >= 0);
+
+        if ref_cnt == 0 {
+            TrAllocater::remove(self.id());
+        }
+    }
+}
+
 impl<R: WidgetImpl> Deref for Tr<R> {
     type Target = R;
 
@@ -63,3 +103,20 @@ impl<R: WidgetImpl> DerefMut for Tr<R> {
         self.bind_mut()
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use crate::{
+        prelude::{DynTr, TrAlloc},
+        widget::Widget,
+    };
+
+    #[test]
+    fn test_tr() {
+        let tr = Widget::new_alloc();
+        {
+            let dyn_tr: DynTr = tr.clone().into();
+            let _ = dyn_tr.clone();
+        }
+    }
+}
diff --git a/tmui/src/widget/widget_inner.rs b/tmui/src/widget/widget_inner.rs
index 4673c3d..b61200f 100644
--- a/tmui/src/widget/widget_inner.rs
+++ b/tmui/src/widget/widget_inner.rs
@@ -264,20 +264,17 @@ macro_rules! widget_inner_ext_impl {
         fn set_redraw_shadow_box(&mut self, redraw: bool) {
             self.widget_props_mut().redraw_shadow_box = redraw
         }
+
+        #[inline]
+        fn set_in_tree(&mut self) {
+            self.widget_props_mut().in_tree = true;
+        }
     };
 }
 
 impl<T: WidgetImpl> WidgetInnerExt for T {
     widget_inner_ext_impl!();
-
-    fn set_in_tree(&mut self) {
-        self.widget_props_mut().in_tree = true;
-    }
 }
 impl WidgetInnerExt for dyn WidgetImpl {
     widget_inner_ext_impl!();
-
-    fn set_in_tree(&mut self) {
-        self.widget_props_mut().in_tree = true;
-    }
 }

From 36bf14517d70b49858065209bd94416f2df3bab2 Mon Sep 17 00:00:00 2001
From: JoeZane <joezane.cn@gmail.com>
Date: Sun, 20 Apr 2025 20:31:44 +0800
Subject: [PATCH 4/7] upd: refactor tr alloc

---
 tmui/src/primitive/obj/alloc.rs  | 76 +++++++++++++++++++++++++++++---
 tmui/src/primitive/obj/dyn_tr.rs | 10 +++++
 tmui/src/primitive/obj/tr.rs     | 29 +++++-------
 3 files changed, 90 insertions(+), 25 deletions(-)

diff --git a/tmui/src/primitive/obj/alloc.rs b/tmui/src/primitive/obj/alloc.rs
index 443ac7b..fe68973 100644
--- a/tmui/src/primitive/obj/alloc.rs
+++ b/tmui/src/primitive/obj/alloc.rs
@@ -1,21 +1,27 @@
 use super::Tr;
+use crate::prelude::*;
 use crate::widget::WidgetImpl;
 use nohash_hasher::IntMap;
-use std::cell::RefCell;
+use std::{
+    cell::{Cell, RefCell},
+    rc::Rc,
+};
 use tlib::{
     object::{ObjectId, ObjectSubclass},
     Object,
 };
 
+type OwnerMap = IntMap<ObjectId, (Box<dyn WidgetImpl>, Rc<Cell<i32>>)>;
+
 thread_local! {
-    static OWNER_STORAGE: RefCell<IntMap<ObjectId, Box<dyn WidgetImpl>>> = RefCell::new(IntMap::default());
+    static OWNER_STORAGE: RefCell<OwnerMap> = RefCell::new(IntMap::default());
 }
 
 pub(crate) struct TrAllocater {}
 impl TrAllocater {
     #[inline]
-    pub(crate) fn insert(owner: Box<dyn WidgetImpl>) {
-        OWNER_STORAGE.with_borrow_mut(|map| map.insert(owner.id(), owner));
+    pub(crate) fn insert(owner: Box<dyn WidgetImpl>, ref_count: Rc<Cell<i32>>) {
+        OWNER_STORAGE.with_borrow_mut(|map| map.insert(owner.id(), (owner, ref_count)));
     }
 
     #[inline]
@@ -24,14 +30,70 @@ impl TrAllocater {
     }
 }
 
-pub trait TrAlloc<T: WidgetImpl + ObjectSubclass + Default> {
+pub trait TrAlloc<T: WidgetImpl + ObjectSubclass + Default>: ObjectOperation {
     #[inline]
     fn new_alloc() -> Tr<T> {
         let mut obj: Box<T> = Object::new(&[]);
         let tr = Tr::from_raw(obj.as_mut());
-        TrAllocater::insert(obj);
+        let ref_count = tr.clone_ref_count();
+        TrAllocater::insert(obj, ref_count);
         tr
     }
-}
 
+    #[inline]
+    fn to_tr(&self) -> Tr<T> {
+        let id = self.id();
+        OWNER_STORAGE.with_borrow_mut(|map| {
+            if let Some((widget, ref_count)) = map.get_mut(&id) {
+                Tr::new_directly(widget.downcast_mut::<T>().unwrap(), ref_count.clone())
+            } else {
+                panic!("The widget is not managed internally by `tmui`.")
+            }
+        })
+    }
+
+    #[inline]
+    fn to_dyn_tr(&self) -> DynTr {
+        let id = self.id();
+        OWNER_STORAGE.with_borrow_mut(|map| {
+            if let Some((widget, ref_count)) = map.get_mut(&id) {
+                DynTr::new_directly(widget.as_mut(), ref_count.clone())
+            } else {
+                panic!("The widget is not managed internally by `tmui`.")
+            }
+        })
+    }
+}
 impl<T: WidgetImpl + ObjectSubclass + Default> TrAlloc<T> for T {}
+
+pub trait DynTrAlloc: WidgetImpl {
+    #[inline]
+    fn to_tr(&self) -> DynTr {
+        let id = self.id();
+        OWNER_STORAGE.with_borrow_mut(|map| {
+            if let Some((widget, ref_count)) = map.get_mut(&id) {
+                DynTr::new_directly(widget.as_mut(), ref_count.clone())
+            } else {
+                panic!("The widget is not managed internally by `tmui`.")
+            }
+        })
+    }
+}
+impl DynTrAlloc for dyn WidgetImpl {}
+
+#[cfg(test)]
+mod tests {
+    use crate::{
+        prelude::{DynTr, TrAlloc},
+        widget::Widget,
+    };
+
+    #[test]
+    fn test_tr() {
+        let tr = Widget::new_alloc();
+        {
+            let dyn_tr: DynTr = tr.clone().into();
+            let _ = dyn_tr.clone();
+        }
+    }
+}
diff --git a/tmui/src/primitive/obj/dyn_tr.rs b/tmui/src/primitive/obj/dyn_tr.rs
index 98c4378..3495152 100644
--- a/tmui/src/primitive/obj/dyn_tr.rs
+++ b/tmui/src/primitive/obj/dyn_tr.rs
@@ -13,6 +13,11 @@ pub struct DynTr {
 }
 
 impl DynTr {
+    #[inline]
+    pub(crate) fn new_directly(raw: *mut dyn WidgetImpl, ref_count: Rc<Cell<i32>>) -> Self {
+        Self { raw, ref_count }
+    }
+
     /// # SAFETY
     ///
     /// Destruction of the underlying object is managed by reference counting, and exceptions should never occur.
@@ -36,6 +41,11 @@ impl DynTr {
                 .expect("Fatal error, try to access the removed reference.")
         }
     }
+
+    #[inline]
+    pub fn get_ref_count(&self) -> usize {
+        self.ref_count.get() as usize
+    }
 }
 
 impl<R: WidgetImpl> From<Tr<R>> for DynTr {
diff --git a/tmui/src/primitive/obj/tr.rs b/tmui/src/primitive/obj/tr.rs
index 089b15d..0667981 100644
--- a/tmui/src/primitive/obj/tr.rs
+++ b/tmui/src/primitive/obj/tr.rs
@@ -15,12 +15,17 @@ pub struct Tr<R: WidgetImpl> {
 impl<R: WidgetImpl> Tr<R> {
     #[inline]
     pub(crate) fn from_raw(raw: *mut R) -> Tr<R> {
-        Tr {
+        Self {
             raw,
             ref_count: Rc::new(Cell::new(1)),
         }
     }
 
+    #[inline]
+    pub(crate) fn new_directly(raw: *mut R, ref_count: Rc<Cell<i32>>) -> Tr<R> {
+        Self { raw, ref_count }
+    }
+
     #[inline]
     pub(crate) fn clone_ref_count(&self) -> Rc<Cell<i32>> {
         self.ref_count.clone()
@@ -59,6 +64,11 @@ impl<R: WidgetImpl> Tr<R> {
     pub fn as_dyn_mut(&mut self) -> &mut dyn WidgetImpl {
         self.bind_mut() as &mut dyn WidgetImpl
     }
+
+    #[inline]
+    pub fn get_ref_count(&self) -> usize {
+        self.ref_count.get() as usize
+    }
 }
 
 impl<R: WidgetImpl> Clone for Tr<R> {
@@ -103,20 +113,3 @@ impl<R: WidgetImpl> DerefMut for Tr<R> {
         self.bind_mut()
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use crate::{
-        prelude::{DynTr, TrAlloc},
-        widget::Widget,
-    };
-
-    #[test]
-    fn test_tr() {
-        let tr = Widget::new_alloc();
-        {
-            let dyn_tr: DynTr = tr.clone().into();
-            let _ = dyn_tr.clone();
-        }
-    }
-}

From 140571b6561b95abd247b6bc06e39a88cc461de8 Mon Sep 17 00:00:00 2001
From: JoeZane <joezane.cn@gmail.com>
Date: Mon, 21 Apr 2025 02:53:26 +0800
Subject: [PATCH 5/7] upd: all reference change to `Tr`,`DynTr`.

---
 benchmark/benches/size_probe_benchmark.rs     |   4 +-
 examples/async_task/async_task_widget.rs      |   4 +-
 examples/border/main.rs                       |   4 +-
 examples/box_layout/hbox_layout.rs            |   6 +-
 examples/box_layout/vbox_layout.rs            |  10 +-
 examples/box_shadow/main.rs                   |   2 +-
 .../child_attr_widget/child_attr_widget.rs    |   6 +-
 examples/complex_layout/ctx_menu.rs           |   6 +-
 .../complex_layout/layouts/central_panel.rs   |   6 +-
 examples/complex_layout/layouts/left_panel.rs |   6 +-
 .../complex_layout/layouts/right_panel/mod.rs |   4 +-
 .../layouts/right_panel/split_pane.rs         |   4 +-
 .../layouts/right_panel/stack.rs              |  11 +-
 examples/complex_layout/layouts/title_bar.rs  |   8 +-
 examples/complex_layout/layouts/view.rs       |  10 +-
 .../complex_layout/layouts/win_ctrl_btns.rs   |   6 +-
 .../complex_layout/layouts/workspace_panel.rs |   2 +-
 examples/custom_diff_handle/my_diff_widget.rs |   4 +-
 examples/custom_diff_handle/my_split_pane.rs  |   6 +-
 examples/custom_popup/my_box.rs               |   8 +-
 examples/custom_popup/my_widget.rs            |  16 +--
 examples/custom_popup/popups/rba_popup.rs     |   6 +-
 examples/custom_popup/popups/tba_popup.rs     |   6 +-
 examples/event_bubble/my_widget.rs            |   8 +-
 examples/event_bus/widget.rs                  |   4 +-
 examples/icon_list/ctrl_button.rs             |   6 +-
 examples/icon_list/font_icons.rs              |  14 +-
 examples/icon_list/icons.rs                   |   8 +-
 examples/icon_list/svg_icons.rs               |  17 ++-
 examples/input_element/holder.rs              |  23 ++--
 examples/input_element/popup.rs               |   6 +-
 examples/key_event/key_widget.rs              |   4 +-
 examples/layout_widget/layout_widget.rs       |  13 +-
 examples/list_view/list_view_holder.rs        |  14 +-
 examples/mouse_evt/test_widget.rs             |   6 +-
 examples/multi_window/input_dialog.rs         |  10 +-
 examples/multi_window/my_widget.rs            |   6 +-
 examples/multi_window/password_bundle.rs      |   8 +-
 examples/multi_window/text_bundle.rs          |   8 +-
 .../non_strict_clip/non_strict_clip_widget.rs |   4 +-
 examples/pane_layout/central_pane.rs          |  19 +--
 examples/pane_layout/pane_layout.rs           |  13 +-
 examples/remove_demo/child_widget.rs          |   8 +-
 examples/remove_demo/remove_widget.rs         |  12 +-
 examples/remove_demo/stack_widget.rs          |   4 +-
 examples/run_after/run_after_layout_widget.rs |   6 +-
 examples/run_after/run_after_widget.rs        |   4 +-
 .../scroll_area_layout/scroll_area_layout.rs  |   4 +-
 examples/scrolled/main.rs                     |   3 +-
 examples/scrolled/scroll_window.rs            |   2 +-
 .../self_adaption_widget.rs                   |   4 +-
 .../shared_window_master/shared_widget.rs     |   4 +-
 examples/shared_window_slave/test_widget.rs   |   4 +-
 examples/skia_paint/main.rs                   |   5 +-
 examples/split_pane_layout/main.rs            |   5 +-
 examples/tree_view/ctx_menu.rs                |   6 +-
 examples/tree_view/tree_view_holder.rs        |  12 +-
 examples/win_widget/main.rs                   |   7 +-
 examples/window/test_widget.rs                |   4 +-
 macros/src/childable.rs                       | 119 +++++++++++++----
 macros/src/extend_container.rs                |  57 +++++---
 macros/src/extend_widget.rs                   |  12 +-
 macros/src/layout.rs                          |  22 ++--
 macros/src/pane.rs                            |   4 +-
 macros/src/popupable.rs                       |  13 +-
 macros/src/scroll_area.rs                     |  16 +--
 macros/src/split_pane.rs                      |  23 ++--
 macros/src/stack.rs                           |   4 +-
 macros/src/win_widget.rs                      |   8 +-
 tmui/src/application_window.rs                |  60 +++++----
 tmui/src/button.rs                            |   8 +-
 tmui/src/container.rs                         |  76 ++---------
 tmui/src/graphics/board.rs                    |   4 +-
 tmui/src/graphics/element.rs                  |  43 +++++-
 tmui/src/hbox.rs                              |  14 +-
 tmui/src/icons/font_icon.rs                   |  10 +-
 tmui/src/icons/svg_icon.rs                    |   8 +-
 tmui/src/icons/svg_toggle_icon.rs             |  13 +-
 tmui/src/image.rs                             |   4 +-
 tmui/src/input/dialog.rs                      |  16 +--
 tmui/src/input/number.rs                      |   4 +-
 tmui/src/input/password.rs                    |   4 +-
 tmui/src/input/radio.rs                       |   8 +-
 tmui/src/input/select/dropdown_list.rs        |  11 +-
 tmui/src/input/select/mod.rs                  |  30 +++--
 tmui/src/input/text.rs                        |   4 +-
 tmui/src/label.rs                             |  11 +-
 tmui/src/layout.rs                            |  32 +++--
 tmui/src/overlay.rs                           |  13 +-
 tmui/src/pane.rs                              |  14 +-
 tmui/src/popup.rs                             |   8 +-
 tmui/src/primitive/obj/alloc.rs               |  33 ++++-
 tmui/src/primitive/obj/dyn_popup_tr.rs        | 122 ++++++++++++++++++
 tmui/src/primitive/obj/dyn_tr.rs              |  16 +++
 tmui/src/primitive/obj/mod.rs                 |   2 +
 tmui/src/primitive/obj/tr.rs                  |  23 +++-
 tmui/src/scroll_area.rs                       |  20 +--
 tmui/src/scroll_bar.rs                        |   4 +-
 tmui/src/split_pane.rs                        |  22 ++--
 tmui/src/stack.rs                             |  15 +--
 tmui/src/tooltip.rs                           |   8 +-
 tmui/src/vbox.rs                              |  14 +-
 tmui/src/views/list_view/list_view_image.rs   |   4 +-
 tmui/src/views/list_view/mod.rs               |   4 +-
 tmui/src/views/tree_view/mod.rs               |   4 +-
 tmui/src/views/tree_view/tree_view_image.rs   |   4 +-
 tmui/src/widget/mod.rs                        |  94 ++------------
 tmui/src/widget/widget_ext.rs                 |  48 +------
 tmui/tests/container_test.rs                  |  25 ++--
 tmui/tests/layout_extend_test.rs              |   6 +-
 110 files changed, 865 insertions(+), 706 deletions(-)
 create mode 100644 tmui/src/primitive/obj/dyn_popup_tr.rs

diff --git a/benchmark/benches/size_probe_benchmark.rs b/benchmark/benches/size_probe_benchmark.rs
index 04ffe00..37f8008 100644
--- a/benchmark/benches/size_probe_benchmark.rs
+++ b/benchmark/benches/size_probe_benchmark.rs
@@ -46,7 +46,7 @@ impl ObjectImpl for TestWidget {}
 impl WidgetImpl for TestWidget {}
 
 impl TestWidget {
-    pub fn new() -> Box<Self> {
-        Object::new(&[])
+    pub fn new() -> Tr<Self> {
+        Self::new_alloc()
     }
 }
diff --git a/examples/async_task/async_task_widget.rs b/examples/async_task/async_task_widget.rs
index 90ae928..9addb6c 100644
--- a/examples/async_task/async_task_widget.rs
+++ b/examples/async_task/async_task_widget.rs
@@ -89,7 +89,7 @@ impl WidgetImpl for AsyncTaskWidget {}
 
 impl AsyncTaskWidget {
     #[inline]
-    pub fn new() -> Box<Self> {
-        Object::new(&[])
+    pub fn new() -> Tr<Self> {
+        Self::new_alloc()
     }
 }
diff --git a/examples/border/main.rs b/examples/border/main.rs
index a8f0915..f250885 100644
--- a/examples/border/main.rs
+++ b/examples/border/main.rs
@@ -16,8 +16,8 @@ fn main() {
 
 fn build_ui(window: &mut ApplicationWindow) {
     let mut hbox = HBox::new();
-    let mut widget1: Box<Widget> = Object::new(&[]);
-    let mut widget2: Box<Widget> = Object::new(&[]);
+    let mut widget1 = Widget::new_alloc();
+    let mut widget2 = Widget::new_alloc();
 
     widget1.set_background(Color::CYAN);
     widget1.width_request(400);
diff --git a/examples/box_layout/hbox_layout.rs b/examples/box_layout/hbox_layout.rs
index 60a684e..84528f5 100644
--- a/examples/box_layout/hbox_layout.rs
+++ b/examples/box_layout/hbox_layout.rs
@@ -6,13 +6,13 @@ use tmui::{label::Label, prelude::*};
 #[derive(Childrenable)]
 pub struct HBoxLayout {
     #[children]
-    label_1: Box<Label>,
+    label_1: Tr<Label>,
 
     #[children]
-    label_2: Box<Label>,
+    label_2: Tr<Label>,
 
     #[children]
-    label_3: Box<Label>,
+    label_3: Tr<Label>,
 }
 
 impl ObjectSubclass for HBoxLayout {
diff --git a/examples/box_layout/vbox_layout.rs b/examples/box_layout/vbox_layout.rs
index b22462f..a9c2915 100644
--- a/examples/box_layout/vbox_layout.rs
+++ b/examples/box_layout/vbox_layout.rs
@@ -8,13 +8,13 @@ use crate::hbox_layout::HBoxLayout;
 #[derive(Childrenable)]
 pub struct VBoxLayout {
     #[children]
-    hbox_1: Box<HBoxLayout>,
+    hbox_1: Tr<HBoxLayout>,
 
     #[children]
-    hbox_2: Box<HBoxLayout>,
+    hbox_2: Tr<HBoxLayout>,
 
     #[children]
-    hbox_3: Box<HBoxLayout>,
+    hbox_3: Tr<HBoxLayout>,
 }
 
 impl ObjectSubclass for VBoxLayout {
@@ -39,7 +39,7 @@ impl ObjectImpl for VBoxLayout {
 impl WidgetImpl for VBoxLayout {}
 
 impl VBoxLayout {
-    pub fn new() -> Box<Self> {
-        Object::new(&[])
+    pub fn new() -> Tr<Self> {
+        Self::new_alloc()
     }
 }
diff --git a/examples/box_shadow/main.rs b/examples/box_shadow/main.rs
index be37170..0e9bf0e 100644
--- a/examples/box_shadow/main.rs
+++ b/examples/box_shadow/main.rs
@@ -18,7 +18,7 @@ fn main() {
 }
 
 fn build_ui(window: &mut ApplicationWindow) {
-    let mut widget: Box<Widget> = Object::new(&[]);
+    let mut widget = Widget::new_alloc();
     widget.width_request(400);
     widget.height_request(200);
     widget.set_hexpand(true);
diff --git a/examples/child_attr_widget/child_attr_widget.rs b/examples/child_attr_widget/child_attr_widget.rs
index 51f61cb..6737d7f 100644
--- a/examples/child_attr_widget/child_attr_widget.rs
+++ b/examples/child_attr_widget/child_attr_widget.rs
@@ -9,7 +9,7 @@ use tmui::{
 #[derive(Childable)]
 pub struct ChildAttrWidget {
     #[child]
-    label: Box<Label>,
+    label: Tr<Label>,
 }
 
 impl ObjectSubclass for ChildAttrWidget {
@@ -28,7 +28,7 @@ impl ObjectImpl for ChildAttrWidget {
 impl WidgetImpl for ChildAttrWidget {}
 
 impl ChildAttrWidget {
-    pub fn new() -> Box<Self> {
-        Object::new(&[])
+    pub fn new() -> Tr<Self> {
+        Self::new_alloc()
     }
 }
diff --git a/examples/complex_layout/ctx_menu.rs b/examples/complex_layout/ctx_menu.rs
index 1d845d8..b67c9cc 100644
--- a/examples/complex_layout/ctx_menu.rs
+++ b/examples/complex_layout/ctx_menu.rs
@@ -15,7 +15,7 @@ use tmui::{
 #[derive(Childable)]
 pub struct CtxMenu {
     #[child]
-    list: Box<ListView>,
+    list: Tr<ListView>,
 }
 
 impl ObjectSubclass for CtxMenu {
@@ -75,8 +75,8 @@ impl PopupImpl for CtxMenu {
 
 impl CtxMenu {
     #[inline]
-    pub fn new() -> Box<Self> {
-        Object::new(&[])
+    pub fn new() -> Tr<Self> {
+        Self::new_alloc()
     }
 }
 
diff --git a/examples/complex_layout/layouts/central_panel.rs b/examples/complex_layout/layouts/central_panel.rs
index 2bb7f8b..2c49e7f 100644
--- a/examples/complex_layout/layouts/central_panel.rs
+++ b/examples/complex_layout/layouts/central_panel.rs
@@ -10,10 +10,10 @@ use super::{right_panel::RightPanel, LeftPanel};
 #[derive(Childrenable)]
 pub struct CentralPanel {
     #[children]
-    widget1: Box<LeftPanel>,
+    widget1: Tr<LeftPanel>,
 
     #[children]
-    widget2: Box<RightPanel>,
+    widget2: Tr<RightPanel>,
 }
 
 impl ObjectSubclass for CentralPanel {
@@ -33,4 +33,4 @@ impl ObjectImpl for CentralPanel {
     }
 }
 
-impl WidgetImpl for CentralPanel {}
\ No newline at end of file
+impl WidgetImpl for CentralPanel {}
diff --git a/examples/complex_layout/layouts/left_panel.rs b/examples/complex_layout/layouts/left_panel.rs
index d05f965..12d3375 100644
--- a/examples/complex_layout/layouts/left_panel.rs
+++ b/examples/complex_layout/layouts/left_panel.rs
@@ -10,10 +10,10 @@ use super::{ActivityBar, WorkspacePanel};
 #[derive(Childrenable)]
 pub struct LeftPanel {
     #[children]
-    activity_bar: Box<ActivityBar>,
+    activity_bar: Tr<ActivityBar>,
 
     #[children]
-    workspace_panel: Box<WorkspacePanel>,
+    workspace_panel: Tr<WorkspacePanel>,
 }
 
 impl ObjectSubclass for LeftPanel {
@@ -38,4 +38,4 @@ impl LeftPanel {
             self.show()
         }
     }
-}
\ No newline at end of file
+}
diff --git a/examples/complex_layout/layouts/right_panel/mod.rs b/examples/complex_layout/layouts/right_panel/mod.rs
index 0d8c1fc..efadfa2 100644
--- a/examples/complex_layout/layouts/right_panel/mod.rs
+++ b/examples/complex_layout/layouts/right_panel/mod.rs
@@ -13,7 +13,7 @@ use self::split_pane::MySplitPane;
 #[derive(Childrenable)]
 pub struct RightPanel {
     #[children]
-    split_pane: Box<MySplitPane>,
+    split_pane: Tr<MySplitPane>,
 }
 
 impl ObjectSubclass for RightPanel {
@@ -27,4 +27,4 @@ impl ObjectImpl for RightPanel {
     }
 }
 
-impl WidgetImpl for RightPanel {}
\ No newline at end of file
+impl WidgetImpl for RightPanel {}
diff --git a/examples/complex_layout/layouts/right_panel/split_pane.rs b/examples/complex_layout/layouts/right_panel/split_pane.rs
index 144b666..15638dc 100644
--- a/examples/complex_layout/layouts/right_panel/split_pane.rs
+++ b/examples/complex_layout/layouts/right_panel/split_pane.rs
@@ -28,12 +28,12 @@ impl ObjectImpl for MySplitPane {
         self.set_hexpand(true);
         self.set_vexpand(true);
 
-        let mut widget: Box<MyStack> = Object::new(&[]);
+        let mut widget = MyStack::new_alloc();
         widget.set_background(Color::CYAN);
         widget.set_vexpand(true);
         widget.set_hexpand(true);
 
-        let mut scroll_area: Box<ScrollArea> = Object::new(&[]);
+        let mut scroll_area = ScrollArea::new_alloc();
         scroll_area.set_scroll_bar_position(ScrollBarPosition::End);
         scroll_area.set_orientation(Orientation::Vertical);
         scroll_area.set_hexpand(true);
diff --git a/examples/complex_layout/layouts/right_panel/stack.rs b/examples/complex_layout/layouts/right_panel/stack.rs
index 630bdfd..d9a94d5 100644
--- a/examples/complex_layout/layouts/right_panel/stack.rs
+++ b/examples/complex_layout/layouts/right_panel/stack.rs
@@ -1,15 +1,18 @@
 use tmui::{
-    label::Label, prelude::*, tlib::object::{ObjectImpl, ObjectSubclass}, widget::WidgetImpl
+    label::Label,
+    prelude::*,
+    tlib::object::{ObjectImpl, ObjectSubclass},
+    widget::WidgetImpl,
 };
 
 #[extends(Widget, Layout(Stack))]
 #[derive(Childrenable)]
 pub struct MyStack {
     #[children]
-    label_1: Box<Label>,
+    label_1: Tr<Label>,
 
     #[children]
-    label_2: Box<Label>,
+    label_2: Tr<Label>,
 }
 
 impl ObjectSubclass for MyStack {
@@ -29,4 +32,4 @@ impl ObjectImpl for MyStack {
     }
 }
 
-impl WidgetImpl for MyStack {}
\ No newline at end of file
+impl WidgetImpl for MyStack {}
diff --git a/examples/complex_layout/layouts/title_bar.rs b/examples/complex_layout/layouts/title_bar.rs
index a3bbcf9..44c2fff 100644
--- a/examples/complex_layout/layouts/title_bar.rs
+++ b/examples/complex_layout/layouts/title_bar.rs
@@ -10,13 +10,13 @@ use super::{app_icon::AppIcon, WinCtrlBtns};
 #[derive(Childrenable)]
 pub struct TitleBar {
     #[children]
-    app_icon: Box<AppIcon>,
+    app_icon: Tr<AppIcon>,
 
     #[children]
-    widget2: Box<Widget>,
+    widget2: Tr<Widget>,
 
     #[children]
-    win_ctrl_btns: Box<WinCtrlBtns>
+    win_ctrl_btns: Tr<WinCtrlBtns>,
 }
 
 impl ObjectSubclass for TitleBar {
@@ -43,4 +43,4 @@ impl ObjectImpl for TitleBar {
     }
 }
 
-impl WidgetImpl for TitleBar {}
\ No newline at end of file
+impl WidgetImpl for TitleBar {}
diff --git a/examples/complex_layout/layouts/view.rs b/examples/complex_layout/layouts/view.rs
index 290ad48..3a86d7f 100644
--- a/examples/complex_layout/layouts/view.rs
+++ b/examples/complex_layout/layouts/view.rs
@@ -12,13 +12,13 @@ use super::{CentralPanel, StatusBar, TitleBar};
 #[global_watch(MouseMove, MousePressed, MouseReleased)]
 pub struct View {
     #[children]
-    title_bar: Box<TitleBar>,
+    title_bar: Tr<TitleBar>,
 
     #[children]
-    central_panel: Box<CentralPanel>,
+    central_panel: Tr<CentralPanel>,
 
     #[children]
-    status_bar: Box<StatusBar>,
+    status_bar: Tr<StatusBar>,
 
     resize_zone: bool,
     resize_pressed: bool,
@@ -40,8 +40,8 @@ impl WidgetImpl for View {}
 
 impl View {
     #[inline]
-    pub fn new() -> Box<Self> {
-        Object::new(&[])
+    pub fn new() -> Tr<Self> {
+        Self::new_alloc()
     }
 }
 
diff --git a/examples/complex_layout/layouts/win_ctrl_btns.rs b/examples/complex_layout/layouts/win_ctrl_btns.rs
index f5ac953..0eed58b 100644
--- a/examples/complex_layout/layouts/win_ctrl_btns.rs
+++ b/examples/complex_layout/layouts/win_ctrl_btns.rs
@@ -14,7 +14,7 @@ pub struct WinCtrlBtns {
         SvgIcon::from_bytes(file.data.as_ref())
     }"))]
     #[children]
-    minimize: Box<SvgIcon>,
+    minimize: Tr<SvgIcon>,
 
     #[derivative(Default(value = "{
         let maximize = Asset::get(\"large.svg\").unwrap();
@@ -22,14 +22,14 @@ pub struct WinCtrlBtns {
         SvgToggleIcon::from_bytes(&[maximize.data.as_ref(), restore.data.as_ref()])
     }"))]
     #[children]
-    large_restore: Box<SvgToggleIcon>,
+    large_restore: Tr<SvgToggleIcon>,
 
     #[derivative(Default(value = "{
         let file = Asset::get(\"close.svg\").unwrap();
         SvgIcon::from_bytes(file.data.as_ref())
     }"))]
     #[children]
-    close: Box<SvgIcon>,
+    close: Tr<SvgIcon>,
 }
 
 impl ObjectSubclass for WinCtrlBtns {
diff --git a/examples/complex_layout/layouts/workspace_panel.rs b/examples/complex_layout/layouts/workspace_panel.rs
index c5a13f8..dc5f244 100644
--- a/examples/complex_layout/layouts/workspace_panel.rs
+++ b/examples/complex_layout/layouts/workspace_panel.rs
@@ -20,7 +20,7 @@ impl ObjectImpl for WorkspacePanel {
     fn construct(&mut self) {
         self.parent_construct();
 
-        self.add_popup(CtxMenu::new());
+        self.add_popup(CtxMenu::new().to_dyn_popup_tr());
     }
 
     fn initialize(&mut self) {
diff --git a/examples/custom_diff_handle/my_diff_widget.rs b/examples/custom_diff_handle/my_diff_widget.rs
index 37a811b..fff3dfa 100644
--- a/examples/custom_diff_handle/my_diff_widget.rs
+++ b/examples/custom_diff_handle/my_diff_widget.rs
@@ -24,7 +24,7 @@ impl WidgetImpl for MyDiffWidget {}
 
 impl MyDiffWidget {
     #[inline]
-    pub fn new() -> Box<Self> {
-        Object::new(&[])
+    pub fn new() -> Tr<Self> {
+        Self::new_alloc()
     }
 }
diff --git a/examples/custom_diff_handle/my_split_pane.rs b/examples/custom_diff_handle/my_split_pane.rs
index 0242975..d331ee2 100644
--- a/examples/custom_diff_handle/my_split_pane.rs
+++ b/examples/custom_diff_handle/my_split_pane.rs
@@ -28,7 +28,7 @@ impl WidgetImpl for MySplitPane {}
 
 impl MySplitPane {
     #[inline]
-    pub fn new() -> Box<Self> {
-        Object::new(&[])
+    pub fn new() -> Tr<Self> {
+        Self::new_alloc()
     }
-}
\ No newline at end of file
+}
diff --git a/examples/custom_popup/my_box.rs b/examples/custom_popup/my_box.rs
index 33fe693..28e5136 100644
--- a/examples/custom_popup/my_box.rs
+++ b/examples/custom_popup/my_box.rs
@@ -9,10 +9,10 @@ use tmui::{
 #[derive(Childrenable)]
 pub struct MyBox {
     #[children]
-    content_widget: Box<Widget>,
+    content_widget: Tr<Widget>,
 
     #[children]
-    bottom_bar: Box<MyWidget>,
+    bottom_bar: Tr<MyWidget>,
 }
 
 impl ObjectSubclass for MyBox {
@@ -42,7 +42,7 @@ impl WidgetImpl for MyBox {}
 
 impl MyBox {
     #[inline]
-    pub fn new() -> Box<Self> {
-        Object::new(&[])
+    pub fn new() -> Tr<Self> {
+        Self::new_alloc()
     }
 }
diff --git a/examples/custom_popup/my_widget.rs b/examples/custom_popup/my_widget.rs
index e7463f3..354e751 100644
--- a/examples/custom_popup/my_widget.rs
+++ b/examples/custom_popup/my_widget.rs
@@ -12,10 +12,10 @@ use crate::popups::{rba_popup::RbaPopup, tba_popup::TbaPopup};
 #[derive(Childrenable)]
 pub struct MyWidget {
     #[children]
-    label_1: Box<Label>,
+    label_1: Tr<Label>,
 
     #[children]
-    label_2: Box<Label>,
+    label_2: Tr<Label>,
 }
 
 impl ObjectSubclass for MyWidget {
@@ -33,8 +33,8 @@ impl ObjectImpl for MyWidget {
         self.label_2
             .set_text("Transparency based animated popup. (click me)");
 
-        self.label_1.add_popup(RbaPopup::new());
-        self.label_2.add_popup(TbaPopup::new());
+        self.label_1.add_popup(RbaPopup::new().to_dyn_popup_tr());
+        self.label_2.add_popup(TbaPopup::new().to_dyn_popup_tr());
 
         self.label_1.width_request(300);
         self.label_2.width_request(300);
@@ -70,8 +70,8 @@ impl MyWidget {
         if self.label_1.get_popup_ref().unwrap().visible() {
             self.label_1.hide_popup();
         } else {
-            self.label_1
-                .show_popup(self.label_1.map_to_global(&event.position().into()));
+            let pos = self.label_1.map_to_global(&event.position().into());
+            self.label_1.show_popup(pos);
         }
     }
 
@@ -79,8 +79,8 @@ impl MyWidget {
         if self.label_2.get_popup_ref().unwrap().visible() {
             self.label_2.hide_popup();
         } else {
-            self.label_2
-                .show_popup(self.label_2.map_to_global(&event.position().into()));
+            let pos = self.label_2.map_to_global(&event.position().into());
+            self.label_2.show_popup(pos);
         }
     }
 }
diff --git a/examples/custom_popup/popups/rba_popup.rs b/examples/custom_popup/popups/rba_popup.rs
index 001f10d..01848aa 100644
--- a/examples/custom_popup/popups/rba_popup.rs
+++ b/examples/custom_popup/popups/rba_popup.rs
@@ -22,7 +22,7 @@ use tmui::{
 #[run_after]
 pub struct RbaPopup {
     #[child]
-    label: Box<Label>,
+    label: Tr<Label>,
 }
 
 impl ObjectSubclass for RbaPopup {
@@ -60,7 +60,7 @@ impl PopupImpl for RbaPopup {}
 
 impl RbaPopup {
     #[inline]
-    pub fn new() -> Box<Self> {
-        Object::new(&[])
+    pub fn new() -> Tr<Self> {
+        Self::new_alloc()
     }
 }
diff --git a/examples/custom_popup/popups/tba_popup.rs b/examples/custom_popup/popups/tba_popup.rs
index 0322e90..294a089 100644
--- a/examples/custom_popup/popups/tba_popup.rs
+++ b/examples/custom_popup/popups/tba_popup.rs
@@ -16,7 +16,7 @@ use tmui::{
 #[run_after]
 pub struct TbaPopup {
     #[child]
-    label: Box<Label>,
+    label: Tr<Label>,
 }
 
 impl ObjectSubclass for TbaPopup {
@@ -54,7 +54,7 @@ impl PopupImpl for TbaPopup {}
 
 impl TbaPopup {
     #[inline]
-    pub fn new() -> Box<Self> {
-        Object::new(&[])
+    pub fn new() -> Tr<Self> {
+        Self::new_alloc()
     }
 }
diff --git a/examples/event_bubble/my_widget.rs b/examples/event_bubble/my_widget.rs
index e50a3ac..809baa7 100644
--- a/examples/event_bubble/my_widget.rs
+++ b/examples/event_bubble/my_widget.rs
@@ -10,10 +10,10 @@ use crate::child_widget::ChildWidget;
 #[derive(Childrenable)]
 pub struct MyWidget {
     #[children]
-    w1: Box<ChildWidget>,
+    w1: Tr<ChildWidget>,
 
     #[children]
-    w2: Box<ChildWidget>,
+    w2: Tr<ChildWidget>,
 }
 
 impl ObjectSubclass for MyWidget {
@@ -65,7 +65,7 @@ impl WidgetImpl for MyWidget {
 
 impl MyWidget {
     #[inline]
-    pub fn new() -> Box<Self> {
-        Object::new(&[])
+    pub fn new() -> Tr<Self> {
+        Self::new_alloc()
     }
 }
diff --git a/examples/event_bus/widget.rs b/examples/event_bus/widget.rs
index 3cdbd2b..e6d6d38 100644
--- a/examples/event_bus/widget.rs
+++ b/examples/event_bus/widget.rs
@@ -57,7 +57,7 @@ impl EventHandle for WidgetEvents {
 
 impl WidgetEvents {
     #[inline]
-    pub fn new() -> Box<Self> {
-        Object::new(&[])
+    pub fn new() -> Tr<Self> {
+        Self::new_alloc()
     }
 }
diff --git a/examples/icon_list/ctrl_button.rs b/examples/icon_list/ctrl_button.rs
index 69baf85..1661e69 100644
--- a/examples/icon_list/ctrl_button.rs
+++ b/examples/icon_list/ctrl_button.rs
@@ -10,17 +10,17 @@ use tmui::{
 pub struct CtrlButtons {
     #[children]
     #[derivative(Default(value = "SvgIcon::from_file(\"examples/resources/minimize.svg\")"))]
-    minimize: Box<SvgIcon>,
+    minimize: Tr<SvgIcon>,
 
     #[children]
     #[derivative(Default(
         value = "SvgToggleIcon::from_files(&[\"examples/resources/restore.svg\",\"examples/resources/large.svg\"])"
     ))]
-    maximize_restore: Box<SvgToggleIcon>,
+    maximize_restore: Tr<SvgToggleIcon>,
 
     #[children]
     #[derivative(Default(value = "SvgIcon::from_file(\"examples/resources/close.svg\")"))]
-    close: Box<SvgIcon>,
+    close: Tr<SvgIcon>,
 }
 
 impl ObjectSubclass for CtrlButtons {
diff --git a/examples/icon_list/font_icons.rs b/examples/icon_list/font_icons.rs
index 5493142..5284110 100644
--- a/examples/icon_list/font_icons.rs
+++ b/examples/icon_list/font_icons.rs
@@ -10,31 +10,31 @@ use tmui::{
 pub struct FontIcons {
     #[children]
     #[derivative(Default(value = "FontIcon::new('\u{f007}')"))]
-    icon1: Box<FontIcon>,
+    icon1: Tr<FontIcon>,
 
     #[children]
     #[derivative(Default(value = "FontIcon::new('\u{f118}')"))]
-    icon2: Box<FontIcon>,
+    icon2: Tr<FontIcon>,
 
     #[children]
     #[derivative(Default(value = "FontIcon::new('\u{f2b9}')"))]
-    icon3: Box<FontIcon>,
+    icon3: Tr<FontIcon>,
 
     #[children]
     #[derivative(Default(value = "FontIcon::new('\u{f0f8}')"))]
-    icon4: Box<FontIcon>,
+    icon4: Tr<FontIcon>,
 
     #[children]
     #[derivative(Default(value = "FontIcon::new('\u{f247}')"))]
-    icon5: Box<FontIcon>,
+    icon5: Tr<FontIcon>,
 
     #[children]
     #[derivative(Default(value = "FontIcon::new('\u{f25b}')"))]
-    icon6: Box<FontIcon>,
+    icon6: Tr<FontIcon>,
 
     #[children]
     #[derivative(Default(value = "FontIcon::new('\u{f58b}')"))]
-    icon7: Box<FontIcon>,
+    icon7: Tr<FontIcon>,
 }
 
 impl ObjectSubclass for FontIcons {
diff --git a/examples/icon_list/icons.rs b/examples/icon_list/icons.rs
index 36cf919..699ce5e 100644
--- a/examples/icon_list/icons.rs
+++ b/examples/icon_list/icons.rs
@@ -14,10 +14,10 @@ use crate::{font_icons::FontIcons, svg_icons::SvgIcons};
 #[iter_executor]
 pub struct Icons {
     #[children]
-    font_icons: Box<FontIcons>,
+    font_icons: Tr<FontIcons>,
 
     #[children]
-    svg_icons: Box<SvgIcons>,
+    svg_icons: Tr<SvgIcons>,
 }
 
 impl ObjectSubclass for Icons {
@@ -37,8 +37,8 @@ impl WidgetImpl for Icons {}
 
 impl Icons {
     #[inline]
-    pub fn new() -> Box<Self> {
-        Object::new(&[])
+    pub fn new() -> Tr<Self> {
+        Self::new_alloc()
     }
 }
 
diff --git a/examples/icon_list/svg_icons.rs b/examples/icon_list/svg_icons.rs
index 2a2132b..a2212d0 100644
--- a/examples/icon_list/svg_icons.rs
+++ b/examples/icon_list/svg_icons.rs
@@ -1,5 +1,8 @@
 use tmui::{
-    icons::svg_icon::SvgIcon, prelude::*, tlib::object::{ObjectImpl, ObjectSubclass}, widget::WidgetImpl
+    icons::svg_icon::SvgIcon,
+    prelude::*,
+    tlib::object::{ObjectImpl, ObjectSubclass},
+    widget::WidgetImpl,
 };
 
 use crate::ctrl_button::CtrlButtons;
@@ -9,22 +12,22 @@ use crate::ctrl_button::CtrlButtons;
 pub struct SvgIcons {
     #[children]
     #[derivative(Default(value = "SvgIcon::from_file(\"examples/resources/search.svg\")"))]
-    icon1: Box<SvgIcon>,
+    icon1: Tr<SvgIcon>,
 
     #[children]
     #[derivative(Default(value = "SvgIcon::from_file(\"examples/resources/toggle_on.svg\")"))]
-    icon2: Box<SvgIcon>,
+    icon2: Tr<SvgIcon>,
 
     #[children]
     #[derivative(Default(value = "SvgIcon::from_file(\"examples/resources/globe_asia.svg\")"))]
-    icon3: Box<SvgIcon>,
+    icon3: Tr<SvgIcon>,
 
     #[children]
     #[derivative(Default(value = "SvgIcon::from_file(\"examples/resources/sword_rose.svg\")"))]
-    icon4: Box<SvgIcon>,
+    icon4: Tr<SvgIcon>,
 
     #[children]
-    icon5: Box<CtrlButtons>,
+    icon5: Tr<CtrlButtons>,
 }
 
 impl ObjectSubclass for SvgIcons {
@@ -39,4 +42,4 @@ impl ObjectImpl for SvgIcons {
     }
 }
 
-impl WidgetImpl for SvgIcons {}
\ No newline at end of file
+impl WidgetImpl for SvgIcons {}
diff --git a/examples/input_element/holder.rs b/examples/input_element/holder.rs
index ddb27ea..71f016f 100644
--- a/examples/input_element/holder.rs
+++ b/examples/input_element/holder.rs
@@ -24,28 +24,28 @@ use crate::popup::InputPopup;
 #[popupable]
 pub struct Holder {
     #[children]
-    text1: Box<Text>,
+    text1: Tr<Text>,
 
     #[children]
-    text2: Box<Text>,
+    text2: Tr<Text>,
 
     #[children]
-    text3: Box<Text>,
+    text3: Tr<Text>,
 
     #[children]
-    password: Box<Password>,
+    password: Tr<Password>,
 
     #[children]
-    select1: Box<Select<String>>,
+    select1: Tr<Select<String>>,
 
     #[children]
-    number: Box<Number>,
+    number: Tr<Number>,
 
     #[children]
-    text4: Box<Text>,
+    text4: Tr<Text>,
 
     #[children]
-    select2: Box<Select<String>>,
+    select2: Tr<Select<String>>,
 }
 
 impl ObjectSubclass for Holder {
@@ -54,8 +54,9 @@ impl ObjectSubclass for Holder {
 
 impl ObjectImpl for Holder {
     fn construct(&mut self) {
+        Select::<String>::new_alloc();
         self.parent_construct();
-        self.add_popup(InputPopup::new());
+        self.add_popup(InputPopup::new().to_dyn_popup_tr());
     }
 
     fn initialize(&mut self) {
@@ -190,8 +191,8 @@ impl WidgetImpl for Holder {
 
 impl Holder {
     #[inline]
-    pub fn new() -> Box<Self> {
-        Object::new(&[])
+    pub fn new() -> Tr<Self> {
+        Self::new_alloc()
     }
 
     #[inline]
diff --git a/examples/input_element/popup.rs b/examples/input_element/popup.rs
index b8d2c5d..e004e8b 100644
--- a/examples/input_element/popup.rs
+++ b/examples/input_element/popup.rs
@@ -15,7 +15,7 @@ use tmui::{
 #[derive(Childable)]
 pub struct InputPopup {
     #[child]
-    vbox: Box<VBox>,
+    vbox: Tr<VBox>,
 }
 
 impl ObjectSubclass for InputPopup {
@@ -86,8 +86,8 @@ impl WidgetImpl for InputPopup {}
 
 impl InputPopup {
     #[inline]
-    pub fn new() -> Box<Self> {
-        Object::new(&[])
+    pub fn new() -> Tr<Self> {
+        Self::new_alloc()
     }
 }
 
diff --git a/examples/key_event/key_widget.rs b/examples/key_event/key_widget.rs
index 0941005..6cd319b 100644
--- a/examples/key_event/key_widget.rs
+++ b/examples/key_event/key_widget.rs
@@ -59,8 +59,8 @@ impl WidgetImpl for KeyWidget {
 }
 
 impl KeyWidget {
-    pub fn new() -> Box<Self> {
-        Object::new(&[])
+    pub fn new() -> Tr<Self> {
+        Self::new_alloc()
     }
 
     pub fn timeout(&self) {
diff --git a/examples/layout_widget/layout_widget.rs b/examples/layout_widget/layout_widget.rs
index 1859408..e78924b 100644
--- a/examples/layout_widget/layout_widget.rs
+++ b/examples/layout_widget/layout_widget.rs
@@ -12,7 +12,7 @@ const TEXT: [&str; 4] = ["Hello", "World", "Hello", "You"];
 #[derive(Childrenable)]
 pub struct LayoutWidget {
     #[children]
-    label: Box<Label>,
+    label: Tr<Label>,
 
     timer: Timer,
     idx: usize,
@@ -50,7 +50,12 @@ impl ObjectImpl for LayoutWidget {
         self.width_request(500);
         self.height_request(300);
 
-        connect!(self.label, text_changed(), self, text_changed(String, String));
+        connect!(
+            self.label,
+            text_changed(),
+            self,
+            text_changed(String, String)
+        );
         connect!(self.timer, timeout(), self, change_text());
         self.timer.start(Duration::from_millis(10));
     }
@@ -59,8 +64,8 @@ impl ObjectImpl for LayoutWidget {
 impl WidgetImpl for LayoutWidget {}
 
 impl LayoutWidget {
-    pub fn new() -> Box<Self> {
-        Object::new(&[])
+    pub fn new() -> Tr<Self> {
+        Self::new_alloc()
     }
 
     pub fn text_changed(&self, old: String, new: String) {
diff --git a/examples/list_view/list_view_holder.rs b/examples/list_view/list_view_holder.rs
index cb90516..ad618fd 100644
--- a/examples/list_view/list_view_holder.rs
+++ b/examples/list_view/list_view_holder.rs
@@ -19,13 +19,13 @@ use crate::Node;
 #[async_task(name = "BuildListTaskIII", value = "()")]
 pub struct ListViewHolder {
     #[children]
-    list_view_1: Box<ListView>,
+    list_view_1: Tr<ListView>,
 
     #[children]
-    list_view_2: Box<ListView>,
+    list_view_2: Tr<ListView>,
 
     #[children]
-    list_view_3: Box<ListView>,
+    list_view_3: Tr<ListView>,
 }
 
 impl ObjectSubclass for ListViewHolder {
@@ -75,7 +75,9 @@ impl ObjectImpl for ListViewHolder {
             println!("Node pressed, {}", node.id());
 
             if evt.mouse_button() == MouseButton::RightButton {
-                let idx = mutex.add_node(&Node { name: "New Node".to_string() });
+                let idx = mutex.add_node(&Node {
+                    name: "New Node".to_string(),
+                });
                 node.get_view().scroll_to(idx);
             }
         });
@@ -182,7 +184,7 @@ impl WidgetImpl for ListViewHolder {}
 
 impl ListViewHolder {
     #[inline]
-    pub fn new() -> Box<Self> {
-        Object::new(&[])
+    pub fn new() -> Tr<Self> {
+        Self::new_alloc()
     }
 }
diff --git a/examples/mouse_evt/test_widget.rs b/examples/mouse_evt/test_widget.rs
index fd2e9f4..9ba39f1 100644
--- a/examples/mouse_evt/test_widget.rs
+++ b/examples/mouse_evt/test_widget.rs
@@ -9,7 +9,7 @@ use tmui::{
 #[derive(Childable)]
 pub struct TestWidget {
     #[child]
-    child: Box<Widget>,
+    child: Tr<Widget>,
 }
 
 impl ObjectSubclass for TestWidget {
@@ -56,7 +56,7 @@ impl WidgetImpl for TestWidget {
 
 impl TestWidget {
     #[inline]
-    pub fn new() -> Box<Self> {
-        Object::new(&[])
+    pub fn new() -> Tr<Self> {
+        Self::new_alloc()
     }
 }
diff --git a/examples/multi_window/input_dialog.rs b/examples/multi_window/input_dialog.rs
index 44fa493..a8a3d22 100644
--- a/examples/multi_window/input_dialog.rs
+++ b/examples/multi_window/input_dialog.rs
@@ -12,15 +12,15 @@ use crate::{password_bundle::PasswordBundle, text_bundle::TextBundle};
 pub struct InputDialog {
     #[children]
     #[derivative(Default(value = "TextBundle::new(\"User Name: \")"))]
-    username: Box<TextBundle>,
+    username: Tr<TextBundle>,
 
     #[children]
     #[derivative(Default(value = "PasswordBundle::new(\"Password: \")"))]
-    password: Box<PasswordBundle>,
+    password: Tr<PasswordBundle>,
 
     #[children]
     #[derivative(Default(value = "Button::new(Some(\"Submit\"))"))]
-    submit: Box<Button>,
+    submit: Tr<Button>,
 }
 
 impl ObjectSubclass for InputDialog {
@@ -76,7 +76,7 @@ impl WidgetImpl for InputDialog {}
 
 impl InputDialog {
     #[inline]
-    pub fn new() -> Box<Self> {
-        Object::new(&[])
+    pub fn new() -> Tr<Self> {
+        Self::new_alloc()
     }
 }
diff --git a/examples/multi_window/my_widget.rs b/examples/multi_window/my_widget.rs
index 11f923f..975874c 100644
--- a/examples/multi_window/my_widget.rs
+++ b/examples/multi_window/my_widget.rs
@@ -12,7 +12,7 @@ use crate::input_dialog::InputDialog;
 #[derive(Childable)]
 pub struct MyWidget {
     #[child]
-    text: Box<Text>,
+    text: Tr<Text>,
 }
 
 impl ObjectSubclass for MyWidget {
@@ -58,7 +58,7 @@ impl WidgetImpl for MyWidget {
 
 impl MyWidget {
     #[inline]
-    pub fn new() -> Box<Self> {
-        Object::new(&[])
+    pub fn new() -> Tr<Self> {
+        Self::new_alloc()
     }
 }
diff --git a/examples/multi_window/password_bundle.rs b/examples/multi_window/password_bundle.rs
index 8da045a..b9b5118 100644
--- a/examples/multi_window/password_bundle.rs
+++ b/examples/multi_window/password_bundle.rs
@@ -11,10 +11,10 @@ use tmui::{
 #[derive(Childrenable)]
 pub struct PasswordBundle {
     #[children]
-    label: Box<Label>,
+    label: Tr<Label>,
 
     #[children]
-    password: Box<Password>,
+    password: Tr<Password>,
 }
 
 impl ObjectSubclass for PasswordBundle {
@@ -27,8 +27,8 @@ impl WidgetImpl for PasswordBundle {}
 
 impl PasswordBundle {
     #[inline]
-    pub fn new(label: &str) -> Box<Self> {
-        let mut tb: Box<Self> = Object::new(&[]);
+    pub fn new(label: &str) -> Tr<Self> {
+        let mut tb = Self::new_alloc();
         tb.label.set_margin_top(3);
         tb.label.set_text(label);
         tb
diff --git a/examples/multi_window/text_bundle.rs b/examples/multi_window/text_bundle.rs
index f76cdc7..b3e5248 100644
--- a/examples/multi_window/text_bundle.rs
+++ b/examples/multi_window/text_bundle.rs
@@ -11,10 +11,10 @@ use tmui::{
 #[derive(Childrenable)]
 pub struct TextBundle {
     #[children]
-    label: Box<Label>,
+    label: Tr<Label>,
 
     #[children]
-    text: Box<Text>,
+    text: Tr<Text>,
 }
 
 impl ObjectSubclass for TextBundle {
@@ -27,8 +27,8 @@ impl WidgetImpl for TextBundle {}
 
 impl TextBundle {
     #[inline]
-    pub fn new(label: &str) -> Box<Self> {
-        let mut tb: Box<Self> = Object::new(&[]);
+    pub fn new(label: &str) -> Tr<Self> {
+        let mut tb = Self::new_alloc();
         tb.label.set_margin_top(3);
         tb.label.set_text(label);
         tb
diff --git a/examples/non_strict_clip/non_strict_clip_widget.rs b/examples/non_strict_clip/non_strict_clip_widget.rs
index 708f3c2..f7c05f1 100644
--- a/examples/non_strict_clip/non_strict_clip_widget.rs
+++ b/examples/non_strict_clip/non_strict_clip_widget.rs
@@ -68,7 +68,7 @@ impl CustomRenderChildDiff for NonStrictClipWidget {
 
 impl NonStrictClipWidget {
     #[inline]
-    pub fn new() -> Box<Self> {
-        Object::new(&[])
+    pub fn new() -> Tr<Self> {
+        Self::new_alloc()
     }
 }
diff --git a/examples/pane_layout/central_pane.rs b/examples/pane_layout/central_pane.rs
index 8e34d08..0faf2b9 100644
--- a/examples/pane_layout/central_pane.rs
+++ b/examples/pane_layout/central_pane.rs
@@ -1,7 +1,8 @@
 use tmui::{
-   prelude::*,
-   tlib::object::{ObjectImpl, ObjectSubclass},
-   widget::WidgetImpl, label::Label,
+    label::Label,
+    prelude::*,
+    tlib::object::{ObjectImpl, ObjectSubclass},
+    widget::WidgetImpl,
 };
 
 use crate::pane_layout::PaneLayout;
@@ -10,14 +11,14 @@ use crate::pane_layout::PaneLayout;
 #[derive(Childrenable)]
 pub struct CentralPane {
     #[children]
-    top_label: Box<Label>,
+    top_label: Tr<Label>,
 
     #[children]
-    pane: Box<PaneLayout>,
+    pane: Tr<PaneLayout>,
 }
 
 impl ObjectSubclass for CentralPane {
-   const NAME: &'static str = "CentralPane";
+    const NAME: &'static str = "CentralPane";
 }
 
 impl ObjectImpl for CentralPane {
@@ -39,7 +40,7 @@ impl ObjectImpl for CentralPane {
 impl WidgetImpl for CentralPane {}
 
 impl CentralPane {
-    pub fn new() -> Box<Self> {
-        Object::new(&[])
+    pub fn new() -> Tr<Self> {
+        Self::new_alloc()
     }
-}
\ No newline at end of file
+}
diff --git a/examples/pane_layout/pane_layout.rs b/examples/pane_layout/pane_layout.rs
index 28945c1..e40c9b6 100644
--- a/examples/pane_layout/pane_layout.rs
+++ b/examples/pane_layout/pane_layout.rs
@@ -1,7 +1,10 @@
 use tmui::{
     label::Label,
     prelude::*,
-    tlib::{namespace::Orientation, object::{ObjectImpl, ObjectSubclass}},
+    tlib::{
+        namespace::Orientation,
+        object::{ObjectImpl, ObjectSubclass},
+    },
     widget::WidgetImpl,
 };
 
@@ -9,10 +12,10 @@ use tmui::{
 #[derive(Childrenable)]
 pub struct PaneLayout {
     #[children]
-    left: Box<Label>,
+    left: Tr<Label>,
 
     #[children]
-    right: Box<Label>,
+    right: Tr<Label>,
 }
 
 impl ObjectSubclass for PaneLayout {
@@ -46,7 +49,7 @@ impl WidgetImpl for PaneLayout {}
 impl PaneLayout {
     #[inline]
     #[allow(dead_code)]
-    pub fn new() -> Box<Self> {
-        Object::new(&[])
+    pub fn new() -> Tr<Self> {
+        Self::new_alloc()
     }
 }
diff --git a/examples/remove_demo/child_widget.rs b/examples/remove_demo/child_widget.rs
index a51a5de..d083510 100644
--- a/examples/remove_demo/child_widget.rs
+++ b/examples/remove_demo/child_widget.rs
@@ -19,14 +19,14 @@ impl ObjectImpl for ChildWidget {
         self.height_request(200);
         self.set_background(Color::GREY_LIGHT);
 
-        let mut child: Box<Widget> = Object::new(&[]);
+        let mut child = Widget::new_alloc();
         child.set_halign(Align::Center);
         child.set_valign(Align::Center);
         child.set_background(Color::YELLOW);
         child.width_request(100);
         child.height_request(100);
 
-        let mut child_c: Box<Widget> = Object::new(&[]);
+        let mut child_c = Widget::new_alloc();
         child_c.set_halign(Align::Center);
         child_c.set_valign(Align::Center);
         child_c.set_background(Color::GREEN);
@@ -42,7 +42,7 @@ impl WidgetImpl for ChildWidget {}
 
 impl ChildWidget {
     #[inline]
-    pub fn new() -> Box<Self> {
-        Object::new(&[])
+    pub fn new() -> Tr<Self> {
+        Self::new_alloc()
     }
 }
diff --git a/examples/remove_demo/remove_widget.rs b/examples/remove_demo/remove_widget.rs
index 53a7d54..84e98d1 100644
--- a/examples/remove_demo/remove_widget.rs
+++ b/examples/remove_demo/remove_widget.rs
@@ -14,13 +14,13 @@ use crate::{
 #[derive(Childrenable)]
 pub struct RemoveWidget {
     #[children]
-    top: Box<HBox>,
+    top: Tr<HBox>,
     #[children]
-    bottom: Box<HBox>,
+    bottom: Tr<HBox>,
     #[children]
-    stack: Box<StackWidget>,
+    stack: Tr<StackWidget>,
     #[children]
-    split_pane: Box<SplitPaneLayout>,
+    split_pane: Tr<SplitPaneLayout>,
 
     to_remove: ObjectId,
     widget_id: ObjectId,
@@ -119,8 +119,8 @@ impl WidgetImpl for RemoveWidget {}
 
 impl RemoveWidget {
     #[inline]
-    pub fn new() -> Box<Self> {
-        Object::new(&[])
+    pub fn new() -> Tr<Self> {
+        Self::new_alloc()
     }
 
     pub fn remove_left_pressed(&mut self, _: MouseEvent) {
diff --git a/examples/remove_demo/stack_widget.rs b/examples/remove_demo/stack_widget.rs
index 1410ed9..c277e96 100644
--- a/examples/remove_demo/stack_widget.rs
+++ b/examples/remove_demo/stack_widget.rs
@@ -18,8 +18,8 @@ impl ObjectImpl for StackWidget {
         self.width_request(100);
         self.height_request(100);
 
-        let mut w1: Box<Widget> = Object::new(&[]);
-        let mut w2: Box<Widget> = Object::new(&[]);
+        let mut w1 = Widget::new_alloc();
+        let mut w2 = Widget::new_alloc();
 
         w1.set_vexpand(true);
         w1.set_hexpand(true);
diff --git a/examples/run_after/run_after_layout_widget.rs b/examples/run_after/run_after_layout_widget.rs
index 51a9850..f248b92 100644
--- a/examples/run_after/run_after_layout_widget.rs
+++ b/examples/run_after/run_after_layout_widget.rs
@@ -11,7 +11,7 @@ use tmui::{
 #[run_after]
 pub struct RunAfterLayoutWidget {
     #[children]
-    label: Box<Label>,
+    label: Tr<Label>,
 }
 
 impl ObjectSubclass for RunAfterLayoutWidget {
@@ -37,7 +37,7 @@ impl WidgetImpl for RunAfterLayoutWidget {
 
 impl RunAfterLayoutWidget {
     #[inline]
-    pub fn new() -> Box<Self> {
-        Object::new(&[])
+    pub fn new() -> Tr<Self> {
+        Self::new_alloc()
     }
 }
diff --git a/examples/run_after/run_after_widget.rs b/examples/run_after/run_after_widget.rs
index 8f25612..e94b188 100644
--- a/examples/run_after/run_after_widget.rs
+++ b/examples/run_after/run_after_widget.rs
@@ -31,7 +31,7 @@ impl WidgetImpl for RunAfterWidget {
 }
 
 impl RunAfterWidget {
-    pub fn new() -> Box<Self> {
-        Object::new(&[])
+    pub fn new() -> Tr<Self> {
+        Self::new_alloc()
     }
 }
diff --git a/examples/scroll_area_layout/scroll_area_layout.rs b/examples/scroll_area_layout/scroll_area_layout.rs
index 371a26b..b217969 100644
--- a/examples/scroll_area_layout/scroll_area_layout.rs
+++ b/examples/scroll_area_layout/scroll_area_layout.rs
@@ -29,7 +29,7 @@ impl WidgetImpl for ScrollAreaLayout {}
 
 impl ScrollAreaLayout {
     #[inline]
-    pub fn new() -> Box<Self> {
-        Object::new(&[])
+    pub fn new() -> Tr<Self> {
+        Self::new_alloc()
     }
 }
diff --git a/examples/scrolled/main.rs b/examples/scrolled/main.rs
index 942cffc..125324e 100644
--- a/examples/scrolled/main.rs
+++ b/examples/scrolled/main.rs
@@ -1,7 +1,6 @@
 mod scroll_window;
 
 use scroll_window::ScrollWindow;
-use tlib::Object;
 use tmui::{
     application::Application, application_window::ApplicationWindow, prelude::*, widget::ChildOp,
 };
@@ -21,7 +20,7 @@ fn main() {
 }
 
 fn build_ui(window: &mut ApplicationWindow) {
-    let mut scroll_window: Box<ScrollWindow> = Object::new(&[]);
+    let mut scroll_window = ScrollWindow::new_alloc();
     // scroll_window.width_request(400);
     // scroll_window.height_request(300);
     scroll_window.set_hexpand(true);
diff --git a/examples/scrolled/scroll_window.rs b/examples/scrolled/scroll_window.rs
index 8f16617..9fc21b1 100644
--- a/examples/scrolled/scroll_window.rs
+++ b/examples/scrolled/scroll_window.rs
@@ -39,7 +39,7 @@ impl ObjectImpl for ScrollWindow {
             when_laebl_receive_wheel(MouseEvent)
         );
 
-        let mut scroll_area: Box<ScrollArea> = Object::new(&[]);
+        let mut scroll_area = ScrollArea::new_alloc();
         scroll_area.set_area(label);
         // scroll_area.width_request(400);
         // scroll_area.height_request(300);
diff --git a/examples/self_adaption_layout/self_adaption_widget.rs b/examples/self_adaption_layout/self_adaption_widget.rs
index 00e944d..092ec20 100644
--- a/examples/self_adaption_layout/self_adaption_widget.rs
+++ b/examples/self_adaption_layout/self_adaption_widget.rs
@@ -46,7 +46,7 @@ impl WidgetImpl for SelfAdaptionWidget {}
 
 impl SelfAdaptionWidget {
     #[inline]
-    pub fn new() -> Box<Self> {
-        Object::new(&[])
+    pub fn new() -> Tr<Self> {
+        Self::new_alloc()
     }
 }
diff --git a/examples/shared_window_master/shared_widget.rs b/examples/shared_window_master/shared_widget.rs
index 826eb4a..75583d1 100644
--- a/examples/shared_window_master/shared_widget.rs
+++ b/examples/shared_window_master/shared_widget.rs
@@ -25,7 +25,7 @@ impl WidgetImpl for MasterSharedWidget {}
 impl SharedWidgetImpl for MasterSharedWidget {}
 
 impl MasterSharedWidget {
-    pub fn new() -> Box<Self> {
-        Object::new(&[])
+    pub fn new() -> Tr<Self> {
+        Self::new_alloc()
     }
 }
diff --git a/examples/shared_window_slave/test_widget.rs b/examples/shared_window_slave/test_widget.rs
index c813d83..e5b6703 100644
--- a/examples/shared_window_slave/test_widget.rs
+++ b/examples/shared_window_slave/test_widget.rs
@@ -44,8 +44,8 @@ impl WidgetImpl for TestWidget {
 }
 
 impl TestWidget {
-    pub fn new() -> Box<Self> {
-        Object::new(&[])
+    pub fn new() -> Tr<Self> {
+        Self::new_alloc()
     }
 
     pub fn timeout(&mut self) {
diff --git a/examples/skia_paint/main.rs b/examples/skia_paint/main.rs
index 1ea25e8..ed5f91e 100644
--- a/examples/skia_paint/main.rs
+++ b/examples/skia_paint/main.rs
@@ -1,7 +1,8 @@
 mod skia_paint;
 use skia_paint::SkiaPaint;
 use tmui::{
-    application::Application, application_window::ApplicationWindow, tlib::Object, widget::ChildOp,
+    application::Application, application_window::ApplicationWindow, prelude::TrAlloc,
+    widget::ChildOp,
 };
 
 fn main() {
@@ -19,6 +20,6 @@ fn main() {
 }
 
 fn build_ui(window: &mut ApplicationWindow) {
-    let w: Box<SkiaPaint> = Object::new(&[]);
+    let w = SkiaPaint::new_alloc();
     window.child(w)
 }
diff --git a/examples/split_pane_layout/main.rs b/examples/split_pane_layout/main.rs
index 8b49989..6ade1ac 100644
--- a/examples/split_pane_layout/main.rs
+++ b/examples/split_pane_layout/main.rs
@@ -2,7 +2,8 @@ mod split_pane_layout;
 
 use split_pane_layout::SplitPaneLayout;
 use tmui::{
-    application::Application, application_window::ApplicationWindow, tlib::Object, widget::ChildOp,
+    application::Application, application_window::ApplicationWindow, prelude::TrAlloc,
+    widget::ChildOp,
 };
 
 fn main() {
@@ -20,7 +21,7 @@ fn main() {
 }
 
 fn build_ui(window: &mut ApplicationWindow) {
-    let split_pane: Box<SplitPaneLayout> = Object::new(&[]);
+    let split_pane = SplitPaneLayout::new_alloc();
 
     window.child(split_pane);
 }
diff --git a/examples/tree_view/ctx_menu.rs b/examples/tree_view/ctx_menu.rs
index a66a81d..f6e6bcf 100644
--- a/examples/tree_view/ctx_menu.rs
+++ b/examples/tree_view/ctx_menu.rs
@@ -19,7 +19,7 @@ use crate::tree_view_holder::SimpContent;
 #[run_after]
 pub struct CtxMenu {
     #[child]
-    selection_list: Box<TreeView>,
+    selection_list: Tr<TreeView>,
 }
 
 impl ObjectSubclass for CtxMenu {
@@ -105,8 +105,8 @@ impl PopupImpl for CtxMenu {
 
 impl CtxMenu {
     #[inline]
-    pub fn new() -> Box<Self> {
-        Object::new(&[])
+    pub fn new() -> Tr<Self> {
+        Self::new_alloc()
     }
 }
 
diff --git a/examples/tree_view/tree_view_holder.rs b/examples/tree_view/tree_view_holder.rs
index 6ef61ae..d53ae8f 100644
--- a/examples/tree_view/tree_view_holder.rs
+++ b/examples/tree_view/tree_view_holder.rs
@@ -29,13 +29,13 @@ const DATA_SIZE: u32 = 30;
 #[async_task(name = "BuildSortTreeTask", value = "Box<TreeNode>")]
 pub struct TreeViewHolder {
     #[children]
-    tree_view: Box<TreeView>,
+    tree_view: Tr<TreeView>,
 
     #[children]
-    tree_view_2: Box<TreeView>,
+    tree_view_2: Tr<TreeView>,
 
     #[children]
-    tree_view_3: Box<TreeView>,
+    tree_view_3: Tr<TreeView>,
 
     tooltip_timer: Rc<Timer>,
 }
@@ -51,7 +51,7 @@ impl ObjectImpl for TreeViewHolder {
 
         self.tree_view
             .set_layout_mode(tmui::scroll_area::LayoutMode::Overlay);
-        self.tree_view.add_popup(CtxMenu::new());
+        self.tree_view.add_popup(CtxMenu::new().to_dyn_popup_tr());
         self.tree_view.start_loading();
         self.tree_view.set_hexpand(true);
         self.tree_view.set_vexpand(true);
@@ -348,8 +348,8 @@ impl WidgetImpl for TreeViewHolder {}
 
 impl TreeViewHolder {
     #[inline]
-    pub fn new() -> Box<Self> {
-        Object::new(&[])
+    pub fn new() -> Tr<Self> {
+        Self::new_alloc()
     }
 
     #[inline]
diff --git a/examples/win_widget/main.rs b/examples/win_widget/main.rs
index 5803df2..6450acf 100644
--- a/examples/win_widget/main.rs
+++ b/examples/win_widget/main.rs
@@ -2,7 +2,8 @@ mod win_widget;
 
 use tlib::{figure::OptionSize, namespace::MouseButton};
 use tmui::{
-    application::Application, application_window::ApplicationWindow, prelude::*, tooltip::Tooltip, widget::callbacks::CallbacksRegister
+    application::Application, application_window::ApplicationWindow, prelude::*, tooltip::Tooltip,
+    widget::callbacks::CallbacksRegister,
 };
 use win_widget::{CorrMyWinWidget, CrsWinMsg};
 
@@ -25,7 +26,7 @@ fn build_ui(window: &mut ApplicationWindow) {
     hbox.set_hexpand(true);
     hbox.set_vexpand(true);
 
-    let mut widget: Box<Widget> = Object::new(&[]);
+    let mut widget = Widget::new_alloc();
     let mut win_widget = CorrMyWinWidget::new();
 
     widget.set_hexpand(true);
@@ -38,7 +39,7 @@ fn build_ui(window: &mut ApplicationWindow) {
             pos.offset(1, 0);
             Tooltip::show("Windowed tooltip content.", pos, OptionSize::none(), None);
         } else if e.mouse_button() == MouseButton::MiddleButton {
-        }   
+        }
     });
     Tooltip::hide_on_window_resize(true);
 
diff --git a/examples/window/test_widget.rs b/examples/window/test_widget.rs
index 598c9d6..48c8405 100644
--- a/examples/window/test_widget.rs
+++ b/examples/window/test_widget.rs
@@ -55,8 +55,8 @@ impl WidgetImpl for TestWidget {
 }
 
 impl TestWidget {
-    pub fn new() -> Box<Self> {
-        Object::new(&[])
+    pub fn new() -> Tr<Self> {
+        Self::new_alloc()
     }
 
     pub fn timeout(&mut self) {
diff --git a/macros/src/childable.rs b/macros/src/childable.rs
index f1e8d88..a8afdac 100644
--- a/macros/src/childable.rs
+++ b/macros/src/childable.rs
@@ -1,7 +1,8 @@
 use proc_macro2::Ident;
-use quote::quote;
+use quote::{quote, ToTokens};
 use syn::{
-    punctuated::Punctuated, spanned::Spanned, token::Pound, Attribute, FieldsNamed, Path, Token,
+    punctuated::Punctuated, spanned::Spanned, token::Pound, Attribute, FieldsNamed,
+    GenericArgument, Path, PathArguments, Token, Type, TypePath,
 };
 
 pub(crate) struct Childable {
@@ -18,9 +19,9 @@ impl Childable {
         let mut child_field = None;
 
         // If field with attribute `#[child]`,
-        // add attribute `#[derivative(Default(value = "Object::new(&[])"))]` to it,
+        // add attribute `#[derivative(Default(value = "Self::new_alloc()"))]` to it,
         for field in fields.named.iter_mut() {
-            let mut childable = false;
+            let mut ty = None;
             for attr in field.attrs.iter() {
                 if let Some(attr_ident) = attr.path.get_ident() {
                     if *attr_ident == "child" {
@@ -30,33 +31,45 @@ impl Childable {
                                 "Widget can only has one child.",
                             ));
                         }
-                        childable = true;
+                        ty = Some(field.ty.clone());
                         break;
                     }
                 }
             }
 
-            if childable {
-                child_field = Some(field.ident.clone().unwrap());
+            if let Some(ty) = ty {
+                if &get_outer_type_ident_string(&ty) != "Tr" {
+                    return Err(syn::Error::new_spanned(
+                        field,
+                        "Child widget must wrapped with `Tr`.",
+                    ));
+                }
+                if let Some(ty) = extract_inner_type(&ty) {
+                    if let Some(ty) = type_to_string_with_turbofish(ty) {
+                        child_field = Some(field.ident.clone().unwrap());
+                        let value_str = format!("{}::new_alloc()", ty);
+                        let value_lit = syn::LitStr::new(&value_str, field.span());
 
-                let mut segments = Punctuated::<syn::PathSegment, Token![::]>::new();
-                segments.push(syn::PathSegment {
-                    ident: syn::Ident::new("derivative", field.span()),
-                    arguments: syn::PathArguments::None,
-                });
-                let attr = Attribute {
-                    pound_token: Pound {
-                        spans: [field.span()],
-                    },
-                    style: syn::AttrStyle::Outer,
-                    bracket_token: syn::token::Bracket { span: field.span() },
-                    path: Path {
-                        leading_colon: None,
-                        segments,
-                    },
-                    tokens: quote! {(Default(value = "Object::new(&[])"))},
-                };
-                field.attrs.push(attr);
+                        let mut segments = Punctuated::<syn::PathSegment, Token![::]>::new();
+                        segments.push(syn::PathSegment {
+                            ident: syn::Ident::new("derivative", field.span()),
+                            arguments: syn::PathArguments::None,
+                        });
+                        let attr = Attribute {
+                            pound_token: Pound {
+                                spans: [field.span()],
+                            },
+                            style: syn::AttrStyle::Outer,
+                            bracket_token: syn::token::Bracket { span: field.span() },
+                            path: Path {
+                                leading_colon: None,
+                                segments,
+                            },
+                            tokens: quote! {(Default(value = #value_lit))},
+                        };
+                        field.attrs.push(attr);
+                    }
+                }
             }
         }
 
@@ -69,11 +82,63 @@ impl Childable {
         match self.child_field.as_ref() {
             Some(field) => {
                 quote! {
-                    let child = self.#field.as_mut() as *mut dyn WidgetImpl;
-                    unsafe { self._child_ref(child) };
+                    let child = self.#field.clone();
+                    unsafe { self.child(child) };
                 }
             }
             None => proc_macro2::TokenStream::new(),
         }
     }
 }
+
+pub fn get_outer_type_ident_string(ty: &syn::Type) -> String {
+    if let syn::Type::Path(type_path) = ty {
+        if let Some(last) = type_path.path.segments.last() {
+            last.ident.to_string()
+        } else {
+            String::new()
+        }
+    } else {
+        String::new()
+    }
+}
+
+pub fn extract_inner_type(ty: &Type) -> Option<&Type> {
+    if let Type::Path(TypePath { path, .. }) = ty {
+        let segment = path.segments.last()?; // e.g., Tr
+        if let PathArguments::AngleBracketed(ref args) = segment.arguments {
+            for arg in &args.args {
+                if let GenericArgument::Type(inner_ty) = arg {
+                    return Some(inner_ty);
+                }
+            }
+        }
+    }
+    None
+}
+pub fn type_to_string_with_turbofish(ty: &Type) -> Option<String> {
+    if let Type::Path(TypePath { path, .. }) = ty {
+        let segment = path.segments.last()?;
+        if let PathArguments::AngleBracketed(ref args) = segment.arguments {
+            let generic_strs: Vec<String> = args
+                .args
+                .iter()
+                .filter_map(|arg| {
+                    if let GenericArgument::Type(ty) = arg {
+                        Some(ty.to_token_stream().to_string().replace(" ", ""))
+                    } else {
+                        None
+                    }
+                })
+                .collect();
+
+            let base_type = segment.ident.to_string();
+            let generics = generic_strs.join(",");
+            return Some(format!("{}::<{}>", base_type, generics));
+        }
+
+        Some(segment.ident.to_string())
+    } else {
+        None
+    }
+}
diff --git a/macros/src/extend_container.rs b/macros/src/extend_container.rs
index 7cb350d..419e6a6 100644
--- a/macros/src/extend_container.rs
+++ b/macros/src/extend_container.rs
@@ -1,4 +1,5 @@
 use crate::{
+    childable::{extract_inner_type, get_outer_type_ident_string, type_to_string_with_turbofish},
     extend_element, extend_object, extend_popup, extend_widget,
     general_attr::GeneralAttr,
     layout::LayoutType,
@@ -168,10 +169,12 @@ pub(crate) fn expand(
                     for field in fields.named.iter_mut() {
                         let mut childrenable = false;
                         let mut has_default = false;
+                        let mut ty = None;
                         for attr in field.attrs.iter() {
                             if let Some(attr_ident) = attr.path.get_ident() {
                                 if *attr_ident == "children" {
                                     childrenable = true;
+                                    ty = Some(field.ty.clone())
                                 }
                                 if *attr_ident == "derivative" {
                                     has_default = true;
@@ -180,24 +183,40 @@ pub(crate) fn expand(
                         }
 
                         if childrenable && !has_default {
-                            let mut segments = Punctuated::<syn::PathSegment, Token![::]>::new();
-                            segments.push(syn::PathSegment {
-                                ident: syn::Ident::new("derivative", field.span()),
-                                arguments: syn::PathArguments::None,
-                            });
-                            let attr = Attribute {
-                                pound_token: Pound {
-                                    spans: [field.span()],
-                                },
-                                style: syn::AttrStyle::Outer,
-                                bracket_token: syn::token::Bracket { span: field.span() },
-                                path: Path {
-                                    leading_colon: None,
-                                    segments,
-                                },
-                                tokens: quote! {(Default(value = "Object::new(&[])"))},
-                            };
-                            field.attrs.push(attr);
+                            let ty = ty.as_ref().unwrap();
+                            if &get_outer_type_ident_string(ty) != "Tr" {
+                                return Err(syn::Error::new_spanned(
+                                    field,
+                                    "Children widget must wrapped with `Tr`.",
+                                ));
+                            }
+
+                            if let Some(ty) = extract_inner_type(ty) {
+                                if let Some(ty) = type_to_string_with_turbofish(ty) {
+                                    let value_str = format!("{}::new_alloc()", ty);
+                                    let value_lit = syn::LitStr::new(&value_str, field.span());
+
+                                    let mut segments =
+                                        Punctuated::<syn::PathSegment, Token![::]>::new();
+                                    segments.push(syn::PathSegment {
+                                        ident: syn::Ident::new("derivative", field.span()),
+                                        arguments: syn::PathArguments::None,
+                                    });
+                                    let attr = Attribute {
+                                        pound_token: Pound {
+                                            spans: [field.span()],
+                                        },
+                                        style: syn::AttrStyle::Outer,
+                                        bracket_token: syn::token::Bracket { span: field.span() },
+                                        path: Path {
+                                            leading_colon: None,
+                                            segments,
+                                        },
+                                        tokens: quote! {(Default(value = #value_lit))},
+                                    };
+                                    field.attrs.push(attr);
+                                }
+                            }
                         }
                     }
                 }
@@ -320,7 +339,7 @@ pub(crate) fn expand(
                 let children_fields = children_fields.unwrap();
                 quote!(
                     #(
-                        self.container.children_ref.push(std::ptr::NonNull::new(self.#children_fields.as_mut()));
+                        self.container.children.push(self.#children_fields.to_dyn_tr());
                     )*
                 )
             } else {
diff --git a/macros/src/extend_widget.rs b/macros/src/extend_widget.rs
index 484e98b..604fcfc 100644
--- a/macros/src/extend_widget.rs
+++ b/macros/src/extend_widget.rs
@@ -288,7 +288,7 @@ pub(crate) fn gen_widget_trait_impl_clause(
 
         impl #impl_generics ChildOp for #name #ty_generics #where_clause {
             #[inline]
-            fn child<_T: WidgetImpl>(&mut self, mut child: Box<_T>) {
+            fn child<_T: WidgetImpl>(&mut self, mut child: Tr<_T>) {
                 if self.super_type().is_a(Container::static_type()) {
                     panic!("function `child()` was invalid in `Container`, use `add_child()` instead")
                 }
@@ -296,16 +296,6 @@ pub(crate) fn gen_widget_trait_impl_clause(
                 self.#(#widget_path).*._child_internal(child)
             }
 
-            #[inline]
-            unsafe fn _child_ref(&mut self, child: *mut dyn WidgetImpl) {
-                if self.super_type().is_a(Container::static_type()) {
-                    panic!("function `_child_ref()` was invalid in `Container`")
-                }
-                let child_mut = tlib::ptr_mut!(child);
-                child_mut.set_parent(self);
-                self.#(#widget_path).*._child_ref_internal(child_mut)
-            }
-
             #[inline]
             fn remove_child(&mut self) {
                 if self.super_type().is_a(Container::static_type()) {
diff --git a/macros/src/layout.rs b/macros/src/layout.rs
index 6fa24af..998196a 100644
--- a/macros/src/layout.rs
+++ b/macros/src/layout.rs
@@ -248,8 +248,8 @@ fn gen_layout_clause(
         (false, false, false, false) => (
             quote! {
                 child.set_parent(self);
-                ApplicationWindow::initialize_dynamic_component(child.as_mut(), self.is_in_tree());
-                self.container.children.push(child);
+                self.container.children.push(child.clone().into());
+                ApplicationWindow::initialize_dynamic_component(child.as_dyn_mut(), self.is_in_tree());
                 self.update();
             },
             quote! {
@@ -282,19 +282,15 @@ fn gen_layout_clause(
     } else {
         quote!(
             fn children(&self) -> Vec<&dyn WidgetImpl> {
-                let mut children: Vec<&dyn WidgetImpl> = self.container.children.iter().map(|c| c.as_ref()).collect();
-                #(
-                    children.push(self.#children_fields.as_ref());
-                )*
-                children
+                self.container.children.iter().map(|c| c.bind()).collect()
             }
 
             fn children_mut(&mut self) -> Vec<&mut dyn WidgetImpl> {
-                let mut children: Vec<&mut dyn WidgetImpl> = self.container.children.iter_mut().map(|c| c.as_mut()).collect();
-                #(
-                    children.push(self.#children_fields.as_mut());
-                )*
-                children
+                self.container
+                    .children
+                    .iter_mut()
+                    .map(|c| c.bind_mut())
+                    .collect()
             }
         )
     };
@@ -335,7 +331,7 @@ fn gen_layout_clause(
 
         impl ContainerImplExt for #name {
             #[inline]
-            fn add_child<T>(&mut self, mut child: Box<T>)
+            fn add_child<T>(&mut self, mut child: Tr<T>)
             where
                 T: WidgetImpl,
             {
diff --git a/macros/src/pane.rs b/macros/src/pane.rs
index 1cdb5d5..4e8dd24 100644
--- a/macros/src/pane.rs
+++ b/macros/src/pane.rs
@@ -9,8 +9,8 @@ pub(crate) fn generate_pane_add_child() -> syn::Result<proc_macro2::TokenStream>
         }
 
         child.set_parent(self);
-        ApplicationWindow::initialize_dynamic_component(child.as_mut(), self.is_in_tree());
-        self.container.children.push(child);
+        self.container.children.push(child.clone().into());
+        ApplicationWindow::initialize_dynamic_component(child.as_dyn_mut(), self.is_in_tree());
         self.update();
     ))
 }
diff --git a/macros/src/popupable.rs b/macros/src/popupable.rs
index 588e8ba..35806e0 100644
--- a/macros/src/popupable.rs
+++ b/macros/src/popupable.rs
@@ -10,10 +10,7 @@ pub(crate) struct Popupable<'a> {
 }
 
 impl<'a> Popupable<'a> {
-    pub(crate) fn parse(
-        ast: &DeriveInput,
-        generics: SplitGenericsRef<'a>,
-    ) -> syn::Result<Self> {
+    pub(crate) fn parse(ast: &DeriveInput, generics: SplitGenericsRef<'a>) -> syn::Result<Self> {
         Ok(Self {
             name: ast.ident.clone(),
             generics,
@@ -21,7 +18,7 @@ impl<'a> Popupable<'a> {
     }
 
     pub(crate) fn popupable_field(&self) -> TokenStream {
-        quote!(popup_field: Option<Box<dyn PopupImpl>>)
+        quote!(popup_field: Option<DynPopupTr>)
     }
 
     pub(crate) fn popupable_reflect(&self) -> TokenStream {
@@ -39,19 +36,19 @@ impl<'a> Popupable<'a> {
         quote!(
             impl #impl_generics Popupable for #name #ty_generics #where_clause {
                 #[inline]
-                fn set_popup(&mut self, mut popup: Box<dyn PopupImpl>) {
+                fn set_popup(&mut self, mut popup: DynPopupTr) {
                     popup.set_supervisor(self);
                     self.popup_field = Some(popup)
                 }
 
                 #[inline]
                 fn get_popup_ref(&self) -> Option<&dyn PopupImpl> {
-                    self.popup_field.as_ref().and_then(|p| {Some(p.as_ref())})
+                    self.popup_field.as_ref().and_then(|p| {Some(p.bind())})
                 }
 
                 #[inline]
                 fn get_popup_mut(&mut self) -> Option<&mut dyn PopupImpl> {
-                    self.popup_field.as_mut().and_then(|p| {Some(p.as_mut())})
+                    self.popup_field.as_mut().and_then(|p| {Some(p.bind_mut())})
                 }
 
                 #[inline]
diff --git a/macros/src/scroll_area.rs b/macros/src/scroll_area.rs
index 286fd6e..b6dec60 100644
--- a/macros/src/scroll_area.rs
+++ b/macros/src/scroll_area.rs
@@ -20,7 +20,7 @@ pub(crate) fn generate_scroll_area_get_children() -> syn::Result<proc_macro2::To
     Ok(quote!(
         #[inline]
         fn children(&self) -> Vec<&dyn WidgetImpl> {
-            self.container.children.iter().map(|w| w.as_ref()).collect()
+            self.container.children.iter().map(|w| w.bind()).collect()
         }
 
         #[inline]
@@ -28,7 +28,7 @@ pub(crate) fn generate_scroll_area_get_children() -> syn::Result<proc_macro2::To
             self.container
                 .children
                 .iter_mut()
-                .map(|w| w.as_mut())
+                .map(|w| w.bind_mut())
                 .collect()
         }
     ))
@@ -39,7 +39,7 @@ pub(crate) fn generate_scroll_area_pre_construct() -> syn::Result<proc_macro2::T
         self.set_render_difference(true);
         self.container
             .children
-            .push(ScrollBar::new(Orientation::Vertical));
+            .push(ScrollBar::new(Orientation::Vertical).into());
 
         let use_occupy = self.layout_mode == LayoutMode::Normal;
         self.scroll_bar_mut()
@@ -60,7 +60,7 @@ pub(crate) fn generate_scroll_area_impl(name: &Ident) -> syn::Result<proc_macro2
                 if self.container.children.len() == 1 {
                     return None;
                 }
-                self.container.children.first().map(|w| w.as_ref())
+                self.container.children.first().map(|w| w.bind())
             }
 
             #[inline]
@@ -68,7 +68,7 @@ pub(crate) fn generate_scroll_area_impl(name: &Ident) -> syn::Result<proc_macro2
                 if self.container.children.len() == 1 {
                     return None;
                 }
-                self.container.children.first_mut().map(|w| w.as_mut())
+                self.container.children.first_mut().map(|w| w.bind_mut())
             }
 
             #[inline]
@@ -139,7 +139,7 @@ pub(crate) fn generate_scroll_area_impl(name: &Ident) -> syn::Result<proc_macro2
 
         impl ScrollAreaGenericExt for #name {
             #[inline]
-            fn set_area<T: WidgetImpl>(&mut self, mut area: Box<T>) {
+            fn set_area<T: WidgetImpl>(&mut self, mut area: Tr<T>) {
                 area.set_parent(self);
                 area.set_vexpand(true);
                 area.set_hexpand(true);
@@ -149,8 +149,8 @@ pub(crate) fn generate_scroll_area_impl(name: &Ident) -> syn::Result<proc_macro2
                     connect!(self.scroll_bar_mut(), need_update(), self.area_mut().unwrap(), update());
                 }
 
-                ApplicationWindow::initialize_dynamic_component(area.as_mut(), self.is_in_tree());
-                self.container.children.insert(0, area)
+                self.container.children.insert(0, area.clone().into());
+                ApplicationWindow::initialize_dynamic_component(area.as_dyn_mut(), self.is_in_tree());
             }
 
             #[inline]
diff --git a/macros/src/split_pane.rs b/macros/src/split_pane.rs
index aef26c8..521ebc5 100644
--- a/macros/src/split_pane.rs
+++ b/macros/src/split_pane.rs
@@ -7,8 +7,7 @@ pub(crate) fn generate_split_pane_add_child() -> syn::Result<proc_macro2::TokenS
             panic!("Only first widget can use function `add_child()` to add, please use `split_left()`,`split_top()`,`split_right()` or `split_down()`")
         }
         child.set_parent(self);
-        ApplicationWindow::initialize_dynamic_component(child.as_mut(), self.is_in_tree());
-        let widget_ptr: std::option::Option<std::ptr::NonNull<dyn WidgetImpl>> = std::ptr::NonNull::new(child.as_mut());
+        let widget_ptr: std::option::Option<std::ptr::NonNull<dyn WidgetImpl>> = std::ptr::NonNull::new(child.bind_mut());
         let mut split_info = Box::new(SplitInfo::new(
             child.id(),
             widget_ptr.clone(),
@@ -18,7 +17,8 @@ pub(crate) fn generate_split_pane_add_child() -> syn::Result<proc_macro2::TokenS
         self.split_infos_vec
             .push(std::ptr::NonNull::new(split_info.as_mut()));
         self.split_infos.insert(child.id(), split_info);
-        self.container.children.push(child);
+        self.container.children.push(child.clone().into());
+        ApplicationWindow::initialize_dynamic_component(child.as_dyn_mut(), self.is_in_tree());
         self.update();
     })
 }
@@ -65,22 +65,22 @@ pub(crate) fn generate_split_pane_impl(name: &Ident) -> syn::Result<proc_macro2:
 
     impl SplitPaneExt for #name {
         #[inline]
-        fn split_left<T: WidgetImpl>(&mut self, id: ObjectId, widget: Box<T>) {
+        fn split_left<T: WidgetImpl>(&mut self, id: ObjectId, widget: Tr<T>) {
             self.split(id, widget, SplitType::SplitLeft)
         }
 
         #[inline]
-        fn split_up<T: WidgetImpl>(&mut self, id: ObjectId, widget: Box<T>) {
+        fn split_up<T: WidgetImpl>(&mut self, id: ObjectId, widget: Tr<T>) {
             self.split(id, widget, SplitType::SplitUp)
         }
 
         #[inline]
-        fn split_right<T: WidgetImpl>(&mut self, id: ObjectId, widget: Box<T>) {
+        fn split_right<T: WidgetImpl>(&mut self, id: ObjectId, widget: Tr<T>) {
             self.split(id, widget, SplitType::SplitRight)
         }
 
         #[inline]
-        fn split_down<T: WidgetImpl>(&mut self, id: ObjectId, widget: Box<T>) {
+        fn split_down<T: WidgetImpl>(&mut self, id: ObjectId, widget: Tr<T>) {
             self.split(id, widget, SplitType::SplitDown)
         }
 
@@ -111,7 +111,7 @@ pub(crate) fn generate_split_pane_impl(name: &Ident) -> syn::Result<proc_macro2:
             self.split_infos_vec.retain(|s| nonnull_ref!(s).id != id);
         }
 
-        fn split<T: WidgetImpl>(&mut self, id: ObjectId, mut widget: Box<T>, ty: SplitType) {
+        fn split<T: WidgetImpl>(&mut self, id: ObjectId, mut widget: Tr<T>, ty: SplitType) {
             use std::ptr::NonNull;
 
             let mut split_from = if let Some(split_info) = self.split_infos.get_mut(&id) {
@@ -121,10 +121,9 @@ pub(crate) fn generate_split_pane_impl(name: &Ident) -> syn::Result<proc_macro2:
             };
 
             widget.set_parent(self);
-            ApplicationWindow::initialize_dynamic_component(widget.as_mut(), self.is_in_tree());
             let mut split_info = Box::new(SplitInfo::new(
                 widget.id(),
-                NonNull::new(widget.as_mut()),
+                NonNull::new(widget.as_dyn_mut()),
                 split_from,
                 ty,
             ));
@@ -133,13 +132,13 @@ pub(crate) fn generate_split_pane_impl(name: &Ident) -> syn::Result<proc_macro2:
             self.split_infos_vec
                 .push(NonNull::new(split_info.as_mut()));
             self.split_infos.insert(widget.id(), split_info);
-            self.container.children.push(widget);
+            self.container.children.push(widget.clone().into());
 
             // Tell the `ApplicationWindow` that widget's layout has changed:
             if self.window_id() == 0 {
                 panic!("`split()` in SplitPane should invoke after window initialize.")
             }
-            ApplicationWindow::window_of(self.window_id()).layout_change(self);
+            ApplicationWindow::initialize_dynamic_component(widget.as_dyn_mut(), self.is_in_tree());
             self.update()
         }
     }
diff --git a/macros/src/stack.rs b/macros/src/stack.rs
index 0c4792b..6856815 100644
--- a/macros/src/stack.rs
+++ b/macros/src/stack.rs
@@ -9,8 +9,8 @@ pub(crate) fn generate_stack_add_child() -> syn::Result<proc_macro2::TokenStream
         } else {
             child.hide()
         }
-        ApplicationWindow::initialize_dynamic_component(child.as_mut(), self.is_in_tree());
-        self.container.children.push(child);
+        self.container.children.push(child.clone().into());
+        ApplicationWindow::initialize_dynamic_component(child.as_dyn_mut(), self.is_in_tree());
         self.update();
     })
 }
diff --git a/macros/src/win_widget.rs b/macros/src/win_widget.rs
index a58ad28..4f7ff7e 100644
--- a/macros/src/win_widget.rs
+++ b/macros/src/win_widget.rs
@@ -593,7 +593,7 @@ impl<'a> WinWidget<'a> {
 
             token.extend(quote!(
                 Box::new(move |win| {
-                    let mut w_widget = Object::new::<#name>(&[]);
+                    let mut w_widget = #name::new_alloc();
                     w_widget.set_background(Color::WHITE);
                     #set_receiver_clause
                     #set_sender_clause
@@ -604,7 +604,7 @@ impl<'a> WinWidget<'a> {
         } else {
             quote!(
                 Box::new(|win| {
-                    win.child(Object::new::<#name>(&[]))
+                    win.child(#name::new_alloc())
                 })
             )
         };
@@ -655,8 +655,8 @@ impl<'a> WinWidget<'a> {
 
             impl #corr_name {
                 #[inline]
-                pub fn new() -> Box<Self> {
-                    let mut w: Box<#corr_name> = Object::new(&[]);
+                pub fn new() -> Tr<Self> {
+                    let mut w: Tr<#corr_name> = Self::new_alloc();
                     #channel_set_clause
                     w
                 }
diff --git a/tmui/src/application_window.rs b/tmui/src/application_window.rs
index c787906..faca444 100644
--- a/tmui/src/application_window.rs
+++ b/tmui/src/application_window.rs
@@ -4,7 +4,7 @@ use crate::{
     container::ContainerLayoutEnum,
     graphics::{
         board::Board,
-        element::{HierachyZ, TOP_Z_INDEX},
+        element::{HierachyZ, RenderOrder, TOP_Z_INDEX},
     },
     input::{dialog::TyInputDialog, focus_mgr::FocusMgr, ReflectInputEle},
     layout::LayoutMgr,
@@ -19,7 +19,7 @@ use crate::{
         index_children,
         widget_inner::WidgetInnerExt,
         win_widget::{handle_win_widget_create, CrsWinMsgHnd, WinWidgetHnd},
-        IterExecutorHnd, WidgetImpl, ZIndexStep,
+        IterExecutorHnd, WidgetImpl,
     },
     window::win_builder::WindowBuilder,
 };
@@ -94,16 +94,16 @@ pub struct ApplicationWindow {
     overlaids: IntMap<ObjectId, WidgetHnd>,
     root_ancestors: Vec<ObjectId>,
     win_widgets: Vec<WinWidgetHnd>,
-    removed: Vec<Box<dyn WidgetImpl>>,
+    removed: Vec<DynTr>,
 
     #[cfg(not(win_dialog))]
-    input_dialog: Option<Box<crate::input::dialog::InputDialog>>,
+    input_dialog: Option<Tr<crate::input::dialog::InputDialog>>,
     #[cfg(win_dialog)]
-    input_dialog: Option<Box<crate::input::dialog::CorrInputDialog>>,
+    input_dialog: Option<Tr<crate::input::dialog::CorrInputDialog>>,
     #[cfg(not(win_tooltip))]
-    tooltip: Option<Box<crate::tooltip::Tooltip>>,
+    tooltip: Option<Tr<crate::tooltip::Tooltip>>,
     #[cfg(win_tooltip)]
-    tooltip: Option<Box<crate::tooltip::CorrTooltip>>,
+    tooltip: Option<Tr<crate::tooltip::CorrTooltip>>,
 }
 
 impl ObjectSubclass for ApplicationWindow {
@@ -132,11 +132,12 @@ impl ObjectImpl for ApplicationWindow {
         self.set_in_tree();
         child_initialize(self.get_child_mut(), window_id, true);
         if let Some(input_dialog) = self.input_dialog.as_mut() {
-            child_initialize(Some(input_dialog.as_mut()), window_id, true);
+            child_initialize(Some(input_dialog.as_dyn_mut()), window_id, true);
         }
         if let Some(tooltip) = self.tooltip.as_mut() {
-            child_initialize(Some(tooltip.as_mut()), window_id, true);
+            child_initialize(Some(tooltip.as_dyn_mut()), window_id, true);
         }
+        self.rebuild_render_order();
 
         self.when_size_change(self.size());
 
@@ -501,13 +502,9 @@ impl ApplicationWindow {
 
         child_initialize(Some(widget), window_id, ancestor_is_in_tree);
 
+        window.rebuild_render_order();
         window.board().shuffle();
-
-        if let Some(parent) = widget.get_parent_mut() {
-            window.layout_change(parent);
-        } else {
-            window.layout_change(widget);
-        }
+        window.layout_change(widget);
 
         if let Some(win_widget) = cast_mut!(widget as WinWidget) {
             let inner = cast!(win_widget as PopupImpl).is_none();
@@ -723,7 +720,7 @@ impl ApplicationWindow {
     }
 
     #[inline]
-    pub fn _add_removed_widget(&mut self, widget: Box<dyn WidgetImpl>) {
+    pub fn _add_removed_widget(&mut self, widget: DynTr) {
         self.removed.push(widget);
     }
 
@@ -994,7 +991,7 @@ impl ApplicationWindow {
             #[cfg(win_dialog)]
             let mut input_dialog = crate::input::dialog::CorrInputDialog::new();
 
-            Self::initialize_dynamic_component(input_dialog.as_mut(), true);
+            Self::initialize_dynamic_component(input_dialog.as_dyn_mut(), true);
             self.input_dialog = Some(input_dialog);
         }
 
@@ -1019,7 +1016,7 @@ impl ApplicationWindow {
             #[cfg(win_tooltip)]
             let mut tooltip = crate::tooltip::CorrTooltip::new();
 
-            Self::initialize_dynamic_component(tooltip.as_mut(), true);
+            Self::initialize_dynamic_component(tooltip.as_dyn_mut(), true);
             self.tooltip = Some(tooltip);
         }
 
@@ -1124,6 +1121,11 @@ impl ApplicationWindow {
         let rect = self.rect_f();
         painter.clip_round_rect_global(rect, self.border_ref().border_radius, ClipOp::Intersect);
     }
+
+    pub(crate) fn rebuild_render_order(&mut self) {
+        let mut order_counter = 0;
+        assign_render_order(self, &mut order_counter);
+    }
 }
 
 /// Get window id in current ui thread.
@@ -1138,7 +1140,6 @@ fn child_initialize(
     ancestor_is_in_tree: bool,
 ) {
     let window = ApplicationWindow::window_of(window_id);
-    let type_registry = TypeRegistry::instance();
 
     let mut children: VecDeque<Option<*mut dyn WidgetImpl>> = VecDeque::new();
 
@@ -1155,15 +1156,15 @@ fn child_initialize(
             .insert(child_ref.id(), NonNull::new(child_ref));
         index_children(child_ref);
 
-        child_ref.inner_type_register(type_registry);
-        child_ref.type_register(type_registry);
-
         if let Some(pop) = cast!(child_ref as PopupImpl) {
             let supervisor = pop.supervisor();
             window.root_ancestors.push(pop.id());
             child_ref.set_z_index(supervisor.z_index() + TOP_Z_INDEX);
+
+            let mut render_order = 0;
+            assign_render_order(child_ref, &mut render_order);
         } else if let Some(parent) = child_ref.get_parent_mut() {
-            let zindex = parent.z_index() + parent.z_index_step();
+            let zindex = parent.z_index();
             child_ref.set_z_index(zindex);
         }
 
@@ -1277,3 +1278,16 @@ fn child_initialize(
         });
     }
 }
+
+fn assign_render_order(node: &mut dyn WidgetImpl, order_counter: &mut usize) {
+    node.set_render_order(*order_counter);
+    *order_counter += 1;
+
+    if let Some(container) = cast_mut!(node as ContainerImpl) {
+        for child in container.children_mut() {
+            assign_render_order(child, order_counter);
+        }
+    } else if let Some(child) = node.get_child_mut() {
+        assign_render_order(child, order_counter);
+    }
+}
diff --git a/tmui/src/button.rs b/tmui/src/button.rs
index be831c8..a5e1d1a 100644
--- a/tmui/src/button.rs
+++ b/tmui/src/button.rs
@@ -15,7 +15,7 @@ const DEFAULT_BACKGROUND_HOVER: Color = Color::grey_with(225);
 #[derive(Childable)]
 pub struct Button {
     #[child]
-    label: Box<Label>,
+    label: Tr<Label>,
 }
 
 impl ObjectSubclass for Button {
@@ -52,11 +52,11 @@ impl WidgetImpl for Button {
 
 impl Button {
     #[inline]
-    pub fn new(text: Option<&str>) -> Box<Self> {
-        let mut button: Box<Self> = Object::new(&[]);
+    pub fn new(text: Option<&str>) -> Tr<Self> {
+        let mut button = Self::new_alloc();
         if let Some(text) = text {
             button.label.set_text(text);
         }
         button
     }
-}
\ No newline at end of file
+}
diff --git a/tmui/src/container.rs b/tmui/src/container.rs
index 056bced..299bc21 100644
--- a/tmui/src/container.rs
+++ b/tmui/src/container.rs
@@ -5,7 +5,7 @@ use crate::{
 };
 use tlib::{
     namespace::Orientation,
-    nonnull_mut, nonnull_ref,
+    nonnull_ref,
     object::{ObjectImpl, ObjectSubclass},
     skia_safe::region::RegionOp,
 };
@@ -23,8 +23,7 @@ pub enum ContainerLayoutEnum {
 
 #[extends(Widget)]
 pub struct Container {
-    pub children: Vec<Box<dyn WidgetImpl>>,
-    pub children_ref: Vec<WidgetHnd>,
+    pub children: Vec<DynTr>,
 
     /// The container will restrictly respect childrens' `size_hint` or not.
     ///
@@ -58,10 +57,6 @@ impl ObjectImpl for Container {
                     for child in self.children.iter_mut() {
                         child.update()
                     }
-                } else if !self.children_ref.is_empty() {
-                    for c in self.children_ref.iter_mut() {
-                        nonnull_mut!(c).update()
-                    }
                 }
             }
             "visible" => {
@@ -88,68 +83,32 @@ impl ObjectImpl for Container {
                             child.set_property("visible", false.to_value());
                         }
                     }
-                } else if !self.children_ref.is_empty() {
-                    for c in self.children_ref.iter_mut() {
-                        let child = nonnull_mut!(c);
-                        if visible {
-                            if !child.visibility_check() {
-                                continue;
-                            }
-                            if let Some(iv) = cast!(child as IsolatedVisibility) {
-                                if iv.auto_hide() {
-                                    continue;
-                                }
-                            }
-
-                            child.set_property("visible", true.to_value());
-                            child.set_render_styles(true);
-                        } else {
-                            child.set_property("visible", false.to_value());
-                        }
-                    }
                 }
             }
             "z_index" => {
                 if !ApplicationWindow::window_of(self.window_id()).initialized() {
                     return;
                 }
-                let offset = value.get::<u32>() - self.z_index();
+                let new_zindex = value.get::<u64>() - self.z_index();
                 if !self.children.is_empty() {
                     for child in self.children.iter_mut() {
-                        child.set_z_index(child.z_index() + offset);
-                    }
-                } else if !self.children_ref.is_empty() {
-                    for c in self.children_ref.iter_mut() {
-                        let child = nonnull_mut!(c);
-                        child.set_z_index(child.z_index() + offset);
+                        child.set_z_index(new_zindex);
                     }
                 }
             }
             "rerender_styles" => {
                 let rerender = value.get::<bool>();
-                if rerender {
-                    if !self.children.is_empty() {
-                        for child in self.children.iter_mut() {
-                            child.set_render_styles(true)
-                        }
-                    } else if !self.children_ref.is_empty() {
-                        for c in self.children_ref.iter_mut() {
-                            nonnull_mut!(c).set_render_styles(true)
-                        }
+                if rerender && !self.children.is_empty() {
+                    for child in self.children.iter_mut() {
+                        child.set_render_styles(true)
                     }
                 }
             }
             "minimized" => {
                 let minimized = value.get::<bool>();
-                if minimized {
-                    if !self.children.is_empty() {
-                        for child in self.children.iter_mut() {
-                            child.set_minimized(true)
-                        }
-                    } else if !self.children_ref.is_empty() {
-                        for c in self.children_ref.iter_mut() {
-                            nonnull_mut!(c).set_minimized(true)
-                        }
+                if minimized && !self.children.is_empty() {
+                    for child in self.children.iter_mut() {
+                        child.set_minimized(true)
                     }
                 }
             }
@@ -159,10 +118,6 @@ impl ObjectImpl for Container {
                     for child in self.children.iter_mut() {
                         child.propagate_update_rect(rect)
                     }
-                } else if !self.children_ref.is_empty() {
-                    for c in self.children_ref.iter_mut() {
-                        nonnull_mut!(c).propagate_update_rect(rect)
-                    }
                 }
             }
             "animation_progressing" => {
@@ -171,10 +126,6 @@ impl ObjectImpl for Container {
                     for child in self.children.iter_mut() {
                         child.propagate_animation_progressing(is)
                     }
-                } else if !self.children_ref.is_empty() {
-                    for c in self.children_ref.iter_mut() {
-                        nonnull_mut!(c).propagate_animation_progressing(is)
-                    }
                 }
             }
             "propagate_transparency" => {
@@ -183,10 +134,6 @@ impl ObjectImpl for Container {
                     for child in self.children.iter_mut() {
                         child.propagate_set_transparency(transparency)
                     }
-                } else if !self.children_ref.is_empty() {
-                    for c in self.children_ref.iter_mut() {
-                        nonnull_mut!(c).propagate_set_transparency(transparency)
-                    }
                 }
             }
             _ => {}
@@ -270,13 +217,12 @@ pub trait ContainerImpl:
 
 pub trait ContainerImplExt: ContainerImpl {
     /// Go to[`Function defination`](ContainerImplExt::add_child) (Defined in [`ContainerImplExt`])
-    fn add_child<T>(&mut self, child: Box<T>)
+    fn add_child<T>(&mut self, child: Tr<T>)
     where
         T: WidgetImpl;
 
     /// Go to[`Function defination`](ContainerImplExt::remove_children) (Defined in [`ContainerImplExt`])
     /// Remove the children with id
-    /// Children with `#[children]` annotated can't be removed.
     fn remove_children(&mut self, id: ObjectId);
 }
 
diff --git a/tmui/src/graphics/board.rs b/tmui/src/graphics/board.rs
index 9669593..fc5edee 100644
--- a/tmui/src/graphics/board.rs
+++ b/tmui/src/graphics/board.rs
@@ -1,6 +1,6 @@
 use super::{
     drawing_context::DrawingContext,
-    element::{ElementImpl, HierachyZ},
+    element::{ElementImpl, HierachyZ, RenderOrder},
 };
 use crate::{
     backend::Backend,
@@ -100,7 +100,7 @@ impl Board {
             let b_z_index = b.z_index();
 
             if a_z_index == b_z_index {
-                a.id().cmp(&b.id())
+                a.get_render_order().cmp(&b.get_render_order())
             } else {
                 a_z_index.cmp(&b_z_index)
             }
diff --git a/tmui/src/graphics/element.rs b/tmui/src/graphics/element.rs
index 09c7eeb..2b75ac6 100644
--- a/tmui/src/graphics/element.rs
+++ b/tmui/src/graphics/element.rs
@@ -253,16 +253,16 @@ pub trait ElementAcquire: ElementImpl + Default {}
 
 /// The hierarchy of widget on the z-axis, the higher the numerical value,
 /// the higher the widget position
-pub(crate) const TOP_Z_INDEX: u32 = 100000000;
-pub(crate) trait HierachyZ {
-    fn z_index(&self) -> u32;
+pub(crate) const TOP_Z_INDEX: u64 = 1000000000000;
+pub trait HierachyZ {
+    fn z_index(&self) -> u64;
 
-    fn set_z_index(&mut self, z_index: u32);
+    fn set_z_index(&mut self, z_index: u64);
 }
 macro_rules! hierarchy_z_impl {
     () => {
         #[inline]
-        fn z_index(&self) -> u32 {
+        fn z_index(&self) -> u64 {
             match self.get_property("z_index") {
                 Some(val) => val.get(),
                 None => 0,
@@ -270,7 +270,7 @@ macro_rules! hierarchy_z_impl {
         }
 
         #[inline]
-        fn set_z_index(&mut self, z_index: u32) {
+        fn set_z_index(&mut self, z_index: u64) {
             self.set_property("z_index", z_index.to_value())
         }
     };
@@ -285,6 +285,37 @@ impl HierachyZ for dyn WidgetImpl {
     hierarchy_z_impl!();
 }
 
+pub(crate) trait RenderOrder {
+    fn get_render_order(&self) -> usize;
+
+    fn set_render_order(&mut self, render_order: usize);
+}
+macro_rules! render_order_impl {
+    () => {
+        #[inline]
+        fn get_render_order(&self) -> usize {
+            match self.get_property("render_order") {
+                Some(val) => val.get(),
+                None => 0,
+            }
+        }
+
+        #[inline]
+        fn set_render_order(&mut self, order: usize) {
+            self.set_property("render_order", order.to_value())
+        }
+    };
+}
+impl<T: ElementImpl> RenderOrder for T {
+    render_order_impl!();
+}
+impl RenderOrder for dyn ElementImpl {
+    render_order_impl!();
+}
+impl RenderOrder for dyn WidgetImpl {
+    render_order_impl!();
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
diff --git a/tmui/src/hbox.rs b/tmui/src/hbox.rs
index be9610a..cbd32fb 100644
--- a/tmui/src/hbox.rs
+++ b/tmui/src/hbox.rs
@@ -32,14 +32,14 @@ impl WidgetImpl for HBox {}
 
 impl ContainerImpl for HBox {
     fn children(&self) -> Vec<&dyn WidgetImpl> {
-        self.container.children.iter().map(|c| c.as_ref()).collect()
+        self.container.children.iter().map(|c| c.bind()).collect()
     }
 
     fn children_mut(&mut self) -> Vec<&mut dyn WidgetImpl> {
         self.container
             .children
             .iter_mut()
-            .map(|c| c.as_mut())
+            .map(|c| c.bind_mut())
             .collect()
     }
 
@@ -49,13 +49,13 @@ impl ContainerImpl for HBox {
 }
 
 impl ContainerImplExt for HBox {
-    fn add_child<T>(&mut self, mut child: Box<T>)
+    fn add_child<T>(&mut self, mut child: Tr<T>)
     where
         T: WidgetImpl,
     {
         child.set_parent(self);
-        ApplicationWindow::initialize_dynamic_component(child.as_mut(), self.is_in_tree());
-        self.container.children.push(child);
+        self.container.children.push(child.clone().into());
+        ApplicationWindow::initialize_dynamic_component(child.as_dyn_mut(), self.is_in_tree());
         self.update();
     }
 
@@ -143,8 +143,8 @@ impl ContentAlignment for HBox {
 }
 
 impl HBox {
-    pub fn new() -> Box<Self> {
-        Object::new(&[])
+    pub fn new() -> Tr<Self> {
+        Self::new_alloc()
     }
 }
 
diff --git a/tmui/src/icons/font_icon.rs b/tmui/src/icons/font_icon.rs
index 7192b69..2120e70 100644
--- a/tmui/src/icons/font_icon.rs
+++ b/tmui/src/icons/font_icon.rs
@@ -89,8 +89,8 @@ impl WidgetImpl for FontIcon {
 impl FontIcon {
     #[cfg(font_awesome)]
     #[inline]
-    pub fn new(code: char) -> Box<Self> {
-        let mut icon: Box<Self> = Object::new(&[]);
+    pub fn new(code: char) -> Tr<Self> {
+        let mut icon = Self::new_alloc();
         icon.code = code;
 
         let mut font = Font::with_families(&DEFAULT_ICON_FAMILIES);
@@ -102,13 +102,13 @@ impl FontIcon {
 
     #[cfg(not(font_awesome))]
     #[inline]
-    pub fn new<T: ToString>(code: char, families: &[T]) -> Box<Self> {
+    pub fn new<T: ToString>(code: char, families: &[T]) -> Tr<Self> {
         Self::with_families(code, families)
     }
 
     #[inline]
-    pub fn with_families<T: ToString>(code: char, families: &[T]) -> Box<Self> {
-        let mut icon: Box<Self> = Object::new(&[]);
+    pub fn with_families<T: ToString>(code: char, families: &[T]) -> Tr<Self> {
+        let mut icon = Self::new_alloc();
         icon.code = code;
 
         let mut font = Font::with_families(families);
diff --git a/tmui/src/icons/svg_icon.rs b/tmui/src/icons/svg_icon.rs
index f5612f4..18df55f 100644
--- a/tmui/src/icons/svg_icon.rs
+++ b/tmui/src/icons/svg_icon.rs
@@ -41,8 +41,8 @@ impl WidgetImpl for SvgIcon {
 
 impl SvgIcon {
     #[inline]
-    pub fn from_file(path: &str) -> Box<Self> {
-        let mut icon: Box<Self> = Object::new(&[]);
+    pub fn from_file(path: &str) -> Tr<Self> {
+        let mut icon = Self::new_alloc();
 
         let mut file = std::fs::File::open(path).expect("Open file failed");
         let mut data = vec![];
@@ -54,8 +54,8 @@ impl SvgIcon {
     }
 
     #[inline]
-    pub fn from_bytes(data: &[u8]) -> Box<Self> {
-        let mut icon: Box<Self> = Object::new(&[]);
+    pub fn from_bytes(data: &[u8]) -> Tr<Self> {
+        let mut icon = Self::new_alloc();
 
         icon.build_from_data(data);
 
diff --git a/tmui/src/icons/svg_toggle_icon.rs b/tmui/src/icons/svg_toggle_icon.rs
index 62c1315..9360706 100644
--- a/tmui/src/icons/svg_toggle_icon.rs
+++ b/tmui/src/icons/svg_toggle_icon.rs
@@ -45,8 +45,8 @@ impl WidgetImpl for SvgToggleIcon {
 
 impl SvgToggleIcon {
     #[inline]
-    pub fn from_files(paths: &[&str]) -> Box<Self> {
-        let mut icon: Box<Self> = Object::new(&[]);
+    pub fn from_files(paths: &[&str]) -> Tr<Self> {
+        let mut icon = Self::new_alloc();
 
         let mut datas = vec![];
         for path in paths {
@@ -68,8 +68,8 @@ impl SvgToggleIcon {
     }
 
     #[inline]
-    pub fn from_bytes(data: &[&[u8]]) -> Box<Self> {
-        let mut icon: Box<Self> = Object::new(&[]);
+    pub fn from_bytes(data: &[&[u8]]) -> Tr<Self> {
+        let mut icon = Self::new_alloc();
 
         icon.build_from_datas(data);
 
@@ -126,7 +126,10 @@ impl SvgToggleIcon {
     #[inline]
     fn handle_geometry_changed(&mut self, rect: FRect) {
         let (x1, y1, w1, h1) = (rect.x(), rect.y(), rect.width(), rect.height());
-        let (w2, h2) = (self.view_size.width() as f32, self.view_size.height() as f32);
+        let (w2, h2) = (
+            self.view_size.width() as f32,
+            self.view_size.height() as f32,
+        );
         self.origin = FPoint::new(x1 + (w1 - w2) / 2., y1 + (h1 - h2) / 2.);
     }
 }
diff --git a/tmui/src/image.rs b/tmui/src/image.rs
index 639c557..6347d5e 100644
--- a/tmui/src/image.rs
+++ b/tmui/src/image.rs
@@ -114,7 +114,7 @@ impl WidgetImpl for Image {
 
 impl Image {
     #[inline]
-    pub fn new<T: AsRef<Path>>(path: T) -> Box<Self> {
+    pub fn new<T: AsRef<Path>>(path: T) -> Tr<Self> {
         let image_buf = ImageBuf::from_file(&path).unwrap_or_else(|| {
             panic!(
                 "load image file `{:?}` failed, maybe it's not exist",
@@ -122,7 +122,7 @@ impl Image {
             )
         });
 
-        let mut image: Box<Self> = Object::new(&[]);
+        let mut image = Self::new_alloc();
         image.image_buf = Some(image_buf);
         image
     }
diff --git a/tmui/src/input/dialog.rs b/tmui/src/input/dialog.rs
index 91035a0..f7392de 100644
--- a/tmui/src/input/dialog.rs
+++ b/tmui/src/input/dialog.rs
@@ -32,13 +32,13 @@ pub type TyInputDialog = crate::input::dialog::CorrInputDialog;
 )]
 pub struct InputDialog {
     #[children]
-    text: Box<Text>,
+    text: Tr<Text>,
 
     #[children]
-    password: Box<Password>,
+    password: Tr<Password>,
 
     #[children]
-    number: Box<Number>,
+    number: Tr<Number>,
 
     #[derivative(Default(value = "InputType::Text"))]
     current: InputType,
@@ -49,13 +49,13 @@ pub struct InputDialog {
 #[derive(Childrenable)]
 pub struct InputDialog {
     #[children]
-    text: Box<Text>,
+    text: Tr<Text>,
 
     #[children]
-    password: Box<Password>,
+    password: Tr<Password>,
 
     #[children]
-    number: Box<Number>,
+    number: Tr<Number>,
 
     value: Option<Value>,
     #[derivative(Default(value = "InputType::Text"))]
@@ -173,8 +173,8 @@ impl InputDialog {
 impl InputDialog {
     #[inline]
     #[cfg(not(win_dialog))]
-    pub(crate) fn new() -> Box<Self> {
-        Object::new(&[])
+    pub(crate) fn new() -> Tr<Self> {
+        Self::new_alloc()
     }
 
     #[cfg(not(win_dialog))]
diff --git a/tmui/src/input/number.rs b/tmui/src/input/number.rs
index dbbb574..a0a2030 100644
--- a/tmui/src/input/number.rs
+++ b/tmui/src/input/number.rs
@@ -280,8 +280,8 @@ impl TextPropsAcquire for Number {
 /// Public implement.
 impl Number {
     #[inline]
-    pub fn new() -> Box<Self> {
-        Object::new(&[])
+    pub fn new() -> Tr<Self> {
+        Self::new_alloc()
     }
 
     #[inline]
diff --git a/tmui/src/input/password.rs b/tmui/src/input/password.rs
index 864636f..4701090 100644
--- a/tmui/src/input/password.rs
+++ b/tmui/src/input/password.rs
@@ -230,8 +230,8 @@ impl Input for Password {
 
 impl Password {
     #[inline]
-    pub fn new() -> Box<Self> {
-        Object::new(&[])
+    pub fn new() -> Tr<Self> {
+        Self::new_alloc()
     }
 
     /// Set the input element `Password`'s text is visible or not.
diff --git a/tmui/src/input/radio.rs b/tmui/src/input/radio.rs
index b43d831..402dcbd 100644
--- a/tmui/src/input/radio.rs
+++ b/tmui/src/input/radio.rs
@@ -1,4 +1,6 @@
-use super::{ctrl::RadioControl, Input, InputBounds, InputEle, InputSignals, InputWrapper, ReflectInputEle};
+use super::{
+    ctrl::RadioControl, Input, InputBounds, InputEle, InputSignals, InputWrapper, ReflectInputEle,
+};
 use crate::{
     input_ele_impl,
     prelude::*,
@@ -55,8 +57,8 @@ impl<T: InputBounds> Input for Radio<T> {
 
 impl<T: InputBounds> Radio<T> {
     #[inline]
-    pub fn new() -> Box<Self> {
-        Object::new(&[])
+    pub fn new() -> Tr<Self> {
+        Self::new_alloc()
     }
 
     #[inline]
diff --git a/tmui/src/input/select/dropdown_list.rs b/tmui/src/input/select/dropdown_list.rs
index cb1c920..6eb807c 100644
--- a/tmui/src/input/select/dropdown_list.rs
+++ b/tmui/src/input/select/dropdown_list.rs
@@ -42,7 +42,7 @@ impl DropdownListSignals for DropdownList {}
 )]
 pub struct DropdownList {
     #[child]
-    list: Box<ListView>,
+    list: Tr<ListView>,
 }
 
 #[cfg(not(win_select))]
@@ -50,7 +50,7 @@ pub struct DropdownList {
 #[derive(Childable)]
 pub struct DropdownList {
     #[child]
-    list: Box<ListView>,
+    list: Tr<ListView>,
 }
 
 impl ObjectSubclass for DropdownList {
@@ -98,7 +98,8 @@ impl ObjectImpl for DropdownList {
 impl WidgetImpl for DropdownList {
     #[inline]
     fn font_changed(&mut self) {
-        self.list.set_font(self.font().clone())
+        let font = self.font().clone();
+        self.list.set_font(font)
     }
 }
 
@@ -129,8 +130,8 @@ fn popup_position_calculate(widget: &dyn WidgetImpl, base_rect: Rect, _: Point)
 impl DropdownList {
     #[cfg(not(win_select))]
     #[inline]
-    pub(crate) fn new() -> Box<Self> {
-        Object::new(&[])
+    pub(crate) fn new() -> Tr<Self> {
+        Self::new_alloc()
     }
 
     #[inline]
diff --git a/tmui/src/input/select/mod.rs b/tmui/src/input/select/mod.rs
index a5204ee..ea11cf7 100644
--- a/tmui/src/input/select/mod.rs
+++ b/tmui/src/input/select/mod.rs
@@ -1,16 +1,26 @@
 pub mod dropdown_list;
 pub mod select_option;
 
-use super::{Input, InputBounds, InputEle, InputSignals, InputWrapper, ReflectInputEle, INPUT_FOCUSED_BORDER_COLOR};
-use crate::{
-    asset::Asset, font::FontCalculation, input::INPUT_DEFAULT_BORDER_COLOR, input_ele_impl, prelude::*, svg::{svg_attr::SvgAttr, svg_str::SvgStr}, tlib::object::{ObjectImpl, ObjectSubclass}, widget::{widget_inner::WidgetInnerExt, WidgetImpl}
+use super::{
+    Input, InputBounds, InputEle, InputSignals, InputWrapper, ReflectInputEle,
+    INPUT_FOCUSED_BORDER_COLOR,
 };
 #[cfg(not(win_select))]
 use crate::widget::widget_ext::FocusStrat;
-#[cfg(not(win_select))]
-use dropdown_list::{DropdownList, DropdownListSignals};
+use crate::{
+    asset::Asset,
+    font::FontCalculation,
+    input::INPUT_DEFAULT_BORDER_COLOR,
+    input_ele_impl,
+    prelude::*,
+    svg::{svg_attr::SvgAttr, svg_str::SvgStr},
+    tlib::object::{ObjectImpl, ObjectSubclass},
+    widget::{widget_inner::WidgetInnerExt, WidgetImpl},
+};
 #[cfg(win_select)]
 use dropdown_list::{CorrDropdownList, CorrDropdownListSignals};
+#[cfg(not(win_select))]
+use dropdown_list::{DropdownList, DropdownListSignals};
 use select_option::SelectOption;
 use tlib::{
     connect, events::MouseEvent, global::PrecisionOps, namespace::MouseButton, run_after,
@@ -62,7 +72,7 @@ impl<T: SelectBounds> ObjectImpl for Select<T> {
                 self,
                 dropdown_list_value_changed(String)
             );
-            self.add_popup(dropdown_list);
+            self.add_popup(dropdown_list.into());
         }
 
         #[cfg(win_select)]
@@ -75,7 +85,7 @@ impl<T: SelectBounds> ObjectImpl for Select<T> {
                 self,
                 dropdown_list_value_changed(String)
             );
-            self.add_popup(dropdown_list);
+            self.add_popup(dropdown_list.into());
         }
 
         let size = ARROW_SIZE as u32;
@@ -167,8 +177,8 @@ impl<T: SelectBounds> Input for Select<T> {
 
 impl<T: SelectBounds> Select<T> {
     #[inline]
-    pub fn new() -> Box<Self> {
-        Object::new(&[])
+    pub fn new() -> Tr<Self> {
+        Self::new_alloc()
     }
 
     #[inline]
@@ -324,4 +334,4 @@ impl<T: SelectBounds> Select<T> {
     }
 }
 
-input_ele_impl!(Select<T: SelectBounds>);
\ No newline at end of file
+input_ele_impl!(Select<T: SelectBounds>);
diff --git a/tmui/src/input/text.rs b/tmui/src/input/text.rs
index aa03c16..cb21392 100644
--- a/tmui/src/input/text.rs
+++ b/tmui/src/input/text.rs
@@ -1507,8 +1507,8 @@ impl TextMemory {
 
 impl Text {
     #[inline]
-    pub fn new() -> Box<Self> {
-        Object::new(&[])
+    pub fn new() -> Tr<Self> {
+        Self::new_alloc()
     }
 }
 
diff --git a/tmui/src/label.rs b/tmui/src/label.rs
index 3e3499f..12dc727 100644
--- a/tmui/src/label.rs
+++ b/tmui/src/label.rs
@@ -6,9 +6,12 @@ use crate::{
 };
 use log::debug;
 use tlib::{
-    emit, object::{ObjectImpl, ObjectSubclass}, run_after, signals, skia_safe::textlayout::{
+    emit,
+    object::{ObjectImpl, ObjectSubclass},
+    run_after, signals,
+    skia_safe::textlayout::{
         FontCollection, ParagraphBuilder, ParagraphStyle, TextStyle, TypefaceFontProvider,
-    }
+    },
 };
 
 #[extends(Widget)]
@@ -189,8 +192,8 @@ impl WidgetImpl for Label {
 
 impl Label {
     #[inline]
-    pub fn new(text: Option<&str>) -> Box<Self> {
-        let mut label: Box<Self> = Object::new(&[]);
+    pub fn new(text: Option<&str>) -> Tr<Self> {
+        let mut label = Self::new_alloc();
         if let Some(text) = text {
             label.label = text.to_string();
         }
diff --git a/tmui/src/layout.rs b/tmui/src/layout.rs
index b087615..0518bf6 100644
--- a/tmui/src/layout.rs
+++ b/tmui/src/layout.rs
@@ -239,10 +239,14 @@ impl SizeCalculation for dyn WidgetImpl {
                 }
                 if parent_vscale.is_adaption() {
                     let ration = self.vscale().min(1.) / 1.;
-                    self.set_fixed_height((parent_size.height() as f32 * ration) as i32 - outer_ver);
+                    self.set_fixed_height(
+                        (parent_size.height() as f32 * ration) as i32 - outer_ver,
+                    );
                 } else if !parent_vscale.is_dismiss() {
                     let ration = self.vscale() / parent_vscale;
-                    self.set_fixed_height((parent_size.height() as f32 * ration) as i32 - outer_ver);
+                    self.set_fixed_height(
+                        (parent_size.height() as f32 * ration) as i32 - outer_ver,
+                    );
                 }
             } else {
                 if self.detecting_height() != 0 {
@@ -290,13 +294,13 @@ impl SizeCalculation for dyn WidgetImpl {
         let visible = self.visible();
         let mut resized = false;
 
-        if (size.width() == 0 && child_size.width() != 0 && visible)
-            || (!self.hexpand() && !self.fixed_width())
+        if (size.width() == 0 && visible)
+            || (!self.hexpand() && !self.fixed_width()) && child_size.width() != 0
         {
             self.set_fixed_width(child_size.width());
         }
-        if (size.height() == 0 && child_size.height() != 0 && visible)
-            || (!self.vexpand() && !self.fixed_height())
+        if (size.height() == 0 && visible)
+            || (!self.vexpand() && !self.fixed_height()) && child_size.height() != 0
         {
             self.set_fixed_height(child_size.height());
         }
@@ -346,7 +350,7 @@ impl SizeCalculation for dyn WidgetImpl {
                 }
 
                 if self.fixed_width_ration() <= 0. {
-                    if parent_size.width() == 0 || self.size().width() == 0{
+                    if parent_size.width() == 0 || self.size().width() == 0 {
                         self.set_fixed_width_ration(1.);
                     } else {
                         let ration = self.get_width_request() as f32 / parent_size.width() as f32;
@@ -430,10 +434,14 @@ impl SizeCalculation for dyn WidgetImpl {
                 }
                 if parent_vscale.is_adaption() {
                     let ration = self.vscale().min(1.) / 1.;
-                    self.set_fixed_height((parent_size.height() as f32 * ration) as i32 - outer_ver);
+                    self.set_fixed_height(
+                        (parent_size.height() as f32 * ration) as i32 - outer_ver,
+                    );
                 } else if !parent_vscale.is_dismiss() {
                     let ration = self.vscale() / parent_vscale;
-                    self.set_fixed_height((parent_size.height() as f32 * ration) as i32 - outer_ver);
+                    self.set_fixed_height(
+                        (parent_size.height() as f32 * ration) as i32 - outer_ver,
+                    );
                 }
             } else {
                 if self.detecting_height() != 0 {
@@ -670,7 +678,8 @@ impl LayoutMgr {
             let visual_image_size = widget.visual_image_rect().size();
             let size: Size = visual_image_size.floor().into();
             let window = ApplicationWindow::window();
-            if window.initialized() && widget.visible()
+            if window.initialized()
+                && widget.visible()
                 && cast!(widget as CrossWinWidget).is_some()
                 && size != window_size
             {
@@ -814,8 +823,7 @@ impl LayoutMgr {
         match valign {
             Align::Start => widget.set_fixed_y(parent_rect.y() + widget.outer_top()),
             Align::Center => {
-                let offset =
-                    (parent_rect.height() - widget_rect.height()) / 2 + widget.outer_top();
+                let offset = (parent_rect.height() - widget_rect.height()) / 2 + widget.outer_top();
                 widget.set_fixed_y(parent_rect.y() + offset)
             }
             Align::End => {
diff --git a/tmui/src/overlay.rs b/tmui/src/overlay.rs
index 5489eb0..45f9213 100644
--- a/tmui/src/overlay.rs
+++ b/tmui/src/overlay.rs
@@ -12,7 +12,7 @@ use crate::{
 pub struct Overlay {}
 
 impl Overlay {
-    pub fn add_overlay<T, P>(&mut self, mut child: Box<T>, point: P)
+    pub fn add_overlay<T, P>(&mut self, mut child: Tr<T>, point: P)
     where
         T: WidgetImpl,
         P: Into<Point>,
@@ -22,9 +22,8 @@ impl Overlay {
         child.set_fixed_x(point.x());
         child.set_fixed_y(point.y());
 
-        ApplicationWindow::initialize_dynamic_component(child.as_mut(), self.is_in_tree());
-
-        self.container.children.push(child);
+        self.container.children.push(child.clone().into());
+        ApplicationWindow::initialize_dynamic_component(child.as_dyn_mut(), self.is_in_tree());
         self.update();
     }
 }
@@ -39,14 +38,14 @@ impl WidgetImpl for Overlay {}
 
 impl ContainerImpl for Overlay {
     fn children(&self) -> Vec<&dyn WidgetImpl> {
-        self.container.children.iter().map(|c| c.as_ref()).collect()
+        self.container.children.iter().map(|c| c.bind()).collect()
     }
 
     fn children_mut(&mut self) -> Vec<&mut dyn WidgetImpl> {
         self.container
             .children
             .iter_mut()
-            .map(|c| c.as_mut())
+            .map(|c| c.bind_mut())
             .collect()
     }
 
@@ -56,7 +55,7 @@ impl ContainerImpl for Overlay {
 }
 
 impl ContainerImplExt for Overlay {
-    fn add_child<T>(&mut self, _child: Box<T>)
+    fn add_child<T>(&mut self, _child: Tr<T>)
     where
         T: WidgetImpl,
     {
diff --git a/tmui/src/pane.rs b/tmui/src/pane.rs
index 966d53d..c1f40f2 100644
--- a/tmui/src/pane.rs
+++ b/tmui/src/pane.rs
@@ -19,8 +19,8 @@ pub struct Pane {
 
 impl Pane {
     #[inline]
-    pub fn new() -> Box<Self> {
-        Object::new(&[])
+    pub fn new() -> Tr<Self> {
+        Self::new_alloc()
     }
 }
 
@@ -196,14 +196,14 @@ impl<T: PaneExt> InnerCustomizeEventProcess for T {
 
 impl ContainerImpl for Pane {
     fn children(&self) -> Vec<&dyn WidgetImpl> {
-        self.container.children.iter().map(|c| c.as_ref()).collect()
+        self.container.children.iter().map(|c| c.bind()).collect()
     }
 
     fn children_mut(&mut self) -> Vec<&mut dyn WidgetImpl> {
         self.container
             .children
             .iter_mut()
-            .map(|c| c.as_mut())
+            .map(|c| c.bind_mut())
             .collect()
     }
 
@@ -213,7 +213,7 @@ impl ContainerImpl for Pane {
 }
 
 impl ContainerImplExt for Pane {
-    fn add_child<T>(&mut self, mut child: Box<T>)
+    fn add_child<T>(&mut self, mut child: Tr<T>)
     where
         T: WidgetImpl,
     {
@@ -223,8 +223,8 @@ impl ContainerImplExt for Pane {
         }
 
         child.set_parent(self);
-        ApplicationWindow::initialize_dynamic_component(child.as_mut(), self.is_in_tree());
-        self.container.children.push(child);
+        self.container.children.push(child.clone().into());
+        ApplicationWindow::initialize_dynamic_component(child.as_dyn_mut(), self.is_in_tree());
         self.update();
     }
 
diff --git a/tmui/src/popup.rs b/tmui/src/popup.rs
index fbb3a2a..50385e4 100644
--- a/tmui/src/popup.rs
+++ b/tmui/src/popup.rs
@@ -190,13 +190,13 @@ pub trait Popupable: WidgetImpl {
     ///
     /// Only one popup can exist at the same time.
     #[inline]
-    fn add_popup(&mut self, mut popup: Box<dyn PopupImpl>) {
+    fn add_popup(&mut self, mut popup: DynPopupTr) {
+        self.set_popup(popup.clone());
+
         ApplicationWindow::initialize_dynamic_component(
             popup.as_widget_impl_mut(),
             self.is_in_tree(),
         );
-
-        self.set_popup(popup);
     }
 
     /// Change the popup's visibility to true, show the popup.
@@ -232,7 +232,7 @@ pub trait Popupable: WidgetImpl {
     /// Set the popup to widget.
     ///
     /// use [`add_popup()`](Popupable::add_popup) instead, do not use this function directly.
-    fn set_popup(&mut self, popup: Box<dyn PopupImpl>);
+    fn set_popup(&mut self, popup: DynPopupTr);
 
     /// Get the refrence of popup.
     fn get_popup_ref(&self) -> Option<&dyn PopupImpl>;
diff --git a/tmui/src/primitive/obj/alloc.rs b/tmui/src/primitive/obj/alloc.rs
index fe68973..d3ed33a 100644
--- a/tmui/src/primitive/obj/alloc.rs
+++ b/tmui/src/primitive/obj/alloc.rs
@@ -33,9 +33,15 @@ impl TrAllocater {
 pub trait TrAlloc<T: WidgetImpl + ObjectSubclass + Default>: ObjectOperation {
     #[inline]
     fn new_alloc() -> Tr<T> {
+        let type_registry = TypeRegistry::instance();
+
         let mut obj: Box<T> = Object::new(&[]);
-        let tr = Tr::from_raw(obj.as_mut());
-        let ref_count = tr.clone_ref_count();
+        obj.inner_type_register(type_registry);
+        obj.type_register(type_registry);
+
+        let ref_count = Rc::new(Cell::new(1));
+        let tr = Tr::from_raw(obj.as_mut(), ref_count.clone());
+
         TrAllocater::insert(obj, ref_count);
         tr
     }
@@ -47,7 +53,7 @@ pub trait TrAlloc<T: WidgetImpl + ObjectSubclass + Default>: ObjectOperation {
             if let Some((widget, ref_count)) = map.get_mut(&id) {
                 Tr::new_directly(widget.downcast_mut::<T>().unwrap(), ref_count.clone())
             } else {
-                panic!("The widget is not managed internally by `tmui`.")
+                panic!("The widget is not created by `Self::new_alloc()`.")
             }
         })
     }
@@ -59,7 +65,7 @@ pub trait TrAlloc<T: WidgetImpl + ObjectSubclass + Default>: ObjectOperation {
             if let Some((widget, ref_count)) = map.get_mut(&id) {
                 DynTr::new_directly(widget.as_mut(), ref_count.clone())
             } else {
-                panic!("The widget is not managed internally by `tmui`.")
+                panic!("The widget is not created by `Self::new_alloc()`.")
             }
         })
     }
@@ -74,13 +80,30 @@ pub trait DynTrAlloc: WidgetImpl {
             if let Some((widget, ref_count)) = map.get_mut(&id) {
                 DynTr::new_directly(widget.as_mut(), ref_count.clone())
             } else {
-                panic!("The widget is not managed internally by `tmui`.")
+                panic!("The widget is not created by `Self::new_alloc()`.")
             }
         })
     }
 }
 impl DynTrAlloc for dyn WidgetImpl {}
 
+pub trait DynPopupTrAlloc<T: PopupImpl + ObjectSubclass + Default>: PopupImpl {
+    #[inline]
+    fn to_dyn_popup_tr(&self) -> DynPopupTr {
+        let id = self.id();
+        OWNER_STORAGE.with_borrow_mut(|map| {
+            if let Some((widget, ref_count)) = map.get_mut(&id) {
+                let widget = widget.as_mut();
+                let raw = cast_mut!(widget as PopupImpl).unwrap();
+                DynPopupTr::new_directly(raw, ref_count.clone())
+            } else {
+                panic!("The widget is not created by `Self::new_alloc()`.")
+            }
+        })
+    }
+}
+impl<T: PopupImpl + ObjectSubclass + Default> DynPopupTrAlloc<T> for T {}
+
 #[cfg(test)]
 mod tests {
     use crate::{
diff --git a/tmui/src/primitive/obj/dyn_popup_tr.rs b/tmui/src/primitive/obj/dyn_popup_tr.rs
new file mode 100644
index 0000000..5ebb851
--- /dev/null
+++ b/tmui/src/primitive/obj/dyn_popup_tr.rs
@@ -0,0 +1,122 @@
+use super::{Tr, TrAllocater};
+use crate::popup::PopupImpl;
+use crate::prelude::*;
+use std::{
+    cell::Cell,
+    ops::{Deref, DerefMut},
+    rc::Rc,
+};
+
+#[derive(Debug, PartialEq, Eq)]
+pub struct DynPopupTr {
+    raw: *mut dyn PopupImpl,
+    ref_count: Rc<Cell<i32>>,
+}
+
+impl DynPopupTr {
+    #[inline]
+    pub(crate) fn new_directly(raw: *mut dyn PopupImpl, ref_count: Rc<Cell<i32>>) -> Self {
+        ref_count.set(ref_count.get() + 1);
+
+        Self { raw, ref_count }
+    }
+
+    /// # SAFETY
+    ///
+    /// Destruction of the underlying object is managed by reference counting, and exceptions should never occur.
+    #[inline]
+    pub fn bind(&self) -> &dyn PopupImpl {
+        unsafe {
+            self.raw
+                .as_ref()
+                .expect("Fatal error, try to access the removed reference.")
+        }
+    }
+
+    /// # SAFETY
+    ///
+    /// Destruction of the underlying object is managed by reference counting, and exceptions should never occur.
+    #[inline]
+    pub fn bind_mut(&mut self) -> &mut dyn PopupImpl {
+        unsafe {
+            self.raw
+                .as_mut()
+                .expect("Fatal error, try to access the removed reference.")
+        }
+    }
+
+    #[inline]
+    pub fn get_ref_count(&self) -> usize {
+        self.ref_count.get() as usize
+    }
+}
+
+impl<R: PopupImpl> From<Tr<R>> for DynPopupTr {
+    #[inline]
+    fn from(mut value: Tr<R>) -> Self {
+        let ref_count = value.clone_ref_count();
+        ref_count.set(ref_count.get() + 1);
+
+        let widget = value.as_mut();
+        let raw = cast_mut!(widget as PopupImpl).unwrap();
+
+        Self { raw, ref_count }
+    }
+}
+
+impl Clone for DynPopupTr {
+    #[inline]
+    fn clone(&self) -> Self {
+        let ref_count = self.ref_count.clone();
+        ref_count.set(ref_count.get() + 1);
+
+        Self {
+            raw: self.raw,
+            ref_count,
+        }
+    }
+}
+
+impl Drop for DynPopupTr {
+    #[inline]
+    fn drop(&mut self) {
+        self.ref_count.set(self.ref_count.get() - 1);
+
+        let ref_cnt = self.ref_count.get();
+        debug_assert!(ref_cnt >= 0);
+
+        if ref_cnt == 0 {
+            TrAllocater::remove(self.id());
+        }
+    }
+}
+
+impl Deref for DynPopupTr {
+    type Target = dyn PopupImpl;
+
+    #[inline]
+    fn deref(&self) -> &Self::Target {
+        self.bind()
+    }
+}
+
+impl DerefMut for DynPopupTr {
+    #[inline]
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        self.bind_mut()
+    }
+}
+
+impl AsRef<dyn PopupImpl> for DynPopupTr {
+    #[inline]
+    fn as_ref(&self) -> &dyn PopupImpl {
+        self.bind()
+    }
+}
+
+impl AsMut<dyn PopupImpl> for DynPopupTr {
+    #[inline]
+    fn as_mut(&mut self) -> &mut dyn PopupImpl {
+        self.bind_mut()
+    }
+}
diff --git a/tmui/src/primitive/obj/dyn_tr.rs b/tmui/src/primitive/obj/dyn_tr.rs
index 3495152..3a6bd84 100644
--- a/tmui/src/primitive/obj/dyn_tr.rs
+++ b/tmui/src/primitive/obj/dyn_tr.rs
@@ -15,6 +15,8 @@ pub struct DynTr {
 impl DynTr {
     #[inline]
     pub(crate) fn new_directly(raw: *mut dyn WidgetImpl, ref_count: Rc<Cell<i32>>) -> Self {
+        ref_count.set(ref_count.get() + 1);
+
         Self { raw, ref_count }
     }
 
@@ -103,3 +105,17 @@ impl DerefMut for DynTr {
         self.bind_mut()
     }
 }
+
+impl AsRef<dyn WidgetImpl> for DynTr {
+    #[inline]
+    fn as_ref(&self) -> &dyn WidgetImpl {
+        self.bind()
+    }
+}
+
+impl AsMut<dyn WidgetImpl> for DynTr {
+    #[inline]
+    fn as_mut(&mut self) -> &mut dyn WidgetImpl {
+        self.bind_mut()
+    }
+}
diff --git a/tmui/src/primitive/obj/mod.rs b/tmui/src/primitive/obj/mod.rs
index 752fead..fbee29e 100644
--- a/tmui/src/primitive/obj/mod.rs
+++ b/tmui/src/primitive/obj/mod.rs
@@ -1,7 +1,9 @@
 pub mod alloc;
+pub mod dyn_popup_tr;
 pub mod dyn_tr;
 pub mod tr;
 
 pub use alloc::*;
+pub use dyn_popup_tr::*;
 pub use dyn_tr::*;
 pub use tr::*;
diff --git a/tmui/src/primitive/obj/tr.rs b/tmui/src/primitive/obj/tr.rs
index 0667981..4c43cb6 100644
--- a/tmui/src/primitive/obj/tr.rs
+++ b/tmui/src/primitive/obj/tr.rs
@@ -14,15 +14,14 @@ pub struct Tr<R: WidgetImpl> {
 
 impl<R: WidgetImpl> Tr<R> {
     #[inline]
-    pub(crate) fn from_raw(raw: *mut R) -> Tr<R> {
-        Self {
-            raw,
-            ref_count: Rc::new(Cell::new(1)),
-        }
+    pub(crate) fn from_raw(raw: *mut R, ref_count: Rc<Cell<i32>>) -> Tr<R> {
+        Self { raw, ref_count }
     }
 
     #[inline]
     pub(crate) fn new_directly(raw: *mut R, ref_count: Rc<Cell<i32>>) -> Tr<R> {
+        ref_count.set(ref_count.get() + 1);
+
         Self { raw, ref_count }
     }
 
@@ -113,3 +112,17 @@ impl<R: WidgetImpl> DerefMut for Tr<R> {
         self.bind_mut()
     }
 }
+
+impl<R: WidgetImpl> AsRef<R> for Tr<R> {
+    #[inline]
+    fn as_ref(&self) -> &R {
+        self.bind()
+    }
+}
+
+impl<R: WidgetImpl> AsMut<R> for Tr<R> {
+    #[inline]
+    fn as_mut(&mut self) -> &mut R {
+        self.bind_mut()
+    }
+}
diff --git a/tmui/src/scroll_area.rs b/tmui/src/scroll_area.rs
index 9aa2783..8d332d5 100644
--- a/tmui/src/scroll_area.rs
+++ b/tmui/src/scroll_area.rs
@@ -62,7 +62,7 @@ pub trait ScrollAreaExt: WidgetImpl {
 }
 
 pub trait ScrollAreaGenericExt {
-    fn set_area<T: WidgetImpl>(&mut self, area: Box<T>);
+    fn set_area<T: WidgetImpl>(&mut self, area: Tr<T>);
 
     fn get_area_cast<T: WidgetImpl + ObjectSubclass>(&self) -> Option<&T>;
 
@@ -112,7 +112,7 @@ impl ScrollAreaExt for ScrollArea {
         if self.container.children.len() == 1 {
             return None;
         }
-        self.container.children.first().map(|w| w.as_ref())
+        self.container.children.first().map(|w| w.bind())
     }
 
     #[inline]
@@ -120,7 +120,7 @@ impl ScrollAreaExt for ScrollArea {
         if self.container.children.len() == 1 {
             return None;
         }
-        self.container.children.first_mut().map(|w| w.as_mut())
+        self.container.children.first_mut().map(|w| w.bind_mut())
     }
 
     #[inline]
@@ -221,7 +221,7 @@ impl ScrollAreaExt for ScrollArea {
 
 impl ScrollAreaGenericExt for ScrollArea {
     #[inline]
-    fn set_area<T: WidgetImpl>(&mut self, mut area: Box<T>) {
+    fn set_area<T: WidgetImpl>(&mut self, mut area: Tr<T>) {
         area.set_parent(self);
         area.set_vexpand(true);
         area.set_hexpand(true);
@@ -235,8 +235,8 @@ impl ScrollAreaGenericExt for ScrollArea {
             );
         }
 
-        ApplicationWindow::initialize_dynamic_component(area.as_mut(), self.is_in_tree());
-        self.container.children.insert(0, area)
+        self.container.children.insert(0, area.clone().into());
+        ApplicationWindow::initialize_dynamic_component(area.as_dyn_mut(), self.is_in_tree());
     }
 
     #[inline]
@@ -261,7 +261,7 @@ impl ObjectImpl for ScrollArea {
         self.set_render_difference(true);
         self.container
             .children
-            .push(ScrollBar::new(Orientation::Vertical));
+            .push(ScrollBar::new(Orientation::Vertical).into());
 
         let occupy_space = self.layout_mode == LayoutMode::Normal;
         self.scroll_bar_mut().set_occupy_space(occupy_space);
@@ -286,7 +286,7 @@ impl WidgetImpl for ScrollArea {
 impl ContainerImpl for ScrollArea {
     #[inline]
     fn children(&self) -> Vec<&dyn WidgetImpl> {
-        self.container.children.iter().map(|w| w.as_ref()).collect()
+        self.container.children.iter().map(|w| w.bind()).collect()
     }
 
     #[inline]
@@ -294,7 +294,7 @@ impl ContainerImpl for ScrollArea {
         self.container
             .children
             .iter_mut()
-            .map(|w| w.as_mut())
+            .map(|w| w.bind_mut())
             .collect()
     }
 
@@ -305,7 +305,7 @@ impl ContainerImpl for ScrollArea {
 }
 
 impl ContainerImplExt for ScrollArea {
-    fn add_child<T>(&mut self, _: Box<T>)
+    fn add_child<T>(&mut self, _: Tr<T>)
     where
         T: WidgetImpl,
     {
diff --git a/tmui/src/scroll_bar.rs b/tmui/src/scroll_bar.rs
index 6a618e4..ce21f21 100644
--- a/tmui/src/scroll_bar.rs
+++ b/tmui/src/scroll_bar.rs
@@ -373,8 +373,8 @@ impl ScrollBarSignal for ScrollBar {}
 
 impl ScrollBar {
     #[inline]
-    pub fn new(orientation: Orientation) -> Box<Self> {
-        let mut scroll_bar: Box<Self> = Object::new(&[]);
+    pub fn new(orientation: Orientation) -> Tr<Self> {
+        let mut scroll_bar: Tr<Self> = Self::new_alloc();
         scroll_bar.orientation = orientation;
         scroll_bar
     }
diff --git a/tmui/src/split_pane.rs b/tmui/src/split_pane.rs
index e1bbec5..e2d0787 100644
--- a/tmui/src/split_pane.rs
+++ b/tmui/src/split_pane.rs
@@ -41,7 +41,7 @@ impl WidgetImpl for SplitPane {}
 impl ContainerImpl for SplitPane {
     #[inline]
     fn children(&self) -> Vec<&dyn WidgetImpl> {
-        self.container.children.iter().map(|c| c.as_ref()).collect()
+        self.container.children.iter().map(|c| c.bind()).collect()
     }
 
     #[inline]
@@ -49,7 +49,7 @@ impl ContainerImpl for SplitPane {
         self.container
             .children
             .iter_mut()
-            .map(|c| c.as_mut())
+            .map(|c| c.bind_mut())
             .collect()
     }
 
@@ -60,7 +60,7 @@ impl ContainerImpl for SplitPane {
 }
 
 impl ContainerImplExt for SplitPane {
-    fn add_child<T>(&mut self, mut child: Box<T>)
+    fn add_child<T>(&mut self, mut child: Tr<T>)
     where
         T: WidgetImpl,
     {
@@ -68,8 +68,7 @@ impl ContainerImplExt for SplitPane {
             panic!("Only first widget can use function `add_child()` to add, please use `split_left()`,`split_top()`,`split_right()` or `split_down()`")
         }
         child.set_parent(self);
-        ApplicationWindow::initialize_dynamic_component(child.as_mut(), self.is_in_tree());
-        let widget_ptr: WidgetHnd = NonNull::new(child.as_mut());
+        let widget_ptr: WidgetHnd = NonNull::new(child.bind_mut());
         let mut split_info = Box::new(SplitInfo::new(
             child.id(),
             widget_ptr,
@@ -78,7 +77,8 @@ impl ContainerImplExt for SplitPane {
         ));
         self.split_infos_vec.push(NonNull::new(split_info.as_mut()));
         self.split_infos.insert(child.id(), split_info);
-        self.container.children.push(child);
+        self.container.children.push(child.clone().into());
+        ApplicationWindow::initialize_dynamic_component(child.as_dyn_mut(), self.is_in_tree());
         self.update();
     }
 
@@ -160,7 +160,7 @@ pub trait SplitPaneExt {
     /// @param widget the new widget that split off. <br>
     ///
     /// @reutrn success or not.
-    fn split_left<T: WidgetImpl>(&mut self, id: ObjectId, widget: Box<T>);
+    fn split_left<T: WidgetImpl>(&mut self, id: ObjectId, widget: Tr<T>);
 
     /// Split new widget up.
     ///
@@ -168,7 +168,7 @@ pub trait SplitPaneExt {
     /// @param widget the new widget that split off. <br>
     ///
     /// @reutrn success or not.
-    fn split_up<T: WidgetImpl>(&mut self, id: ObjectId, widget: Box<T>);
+    fn split_up<T: WidgetImpl>(&mut self, id: ObjectId, widget: Tr<T>);
 
     /// Split new widget right.
     ///
@@ -176,7 +176,7 @@ pub trait SplitPaneExt {
     /// @param widget the new widget that split off. <br>
     ///
     /// @reutrn success or not.
-    fn split_right<T: WidgetImpl>(&mut self, id: ObjectId, widget: Box<T>);
+    fn split_right<T: WidgetImpl>(&mut self, id: ObjectId, widget: Tr<T>);
 
     /// Split new widget down.
     ///
@@ -184,7 +184,7 @@ pub trait SplitPaneExt {
     /// @param widget the new widget that split off. <br>
     ///
     /// @reutrn success or not.
-    fn split_down<T: WidgetImpl>(&mut self, id: ObjectId, widget: Box<T>);
+    fn split_down<T: WidgetImpl>(&mut self, id: ObjectId, widget: Tr<T>);
 
     /// **Do not call this function directly, use `remove_children()` instead.**
     ///
@@ -194,7 +194,7 @@ pub trait SplitPaneExt {
     fn close_pane(&mut self, id: ObjectId);
 
     /// Common function of split().
-    fn split<T: WidgetImpl>(&mut self, id: ObjectId, widget: Box<T>, ty: SplitType);
+    fn split<T: WidgetImpl>(&mut self, id: ObjectId, widget: Tr<T>, ty: SplitType);
 }
 
 split_pane_impl!(SplitPane);
diff --git a/tmui/src/stack.rs b/tmui/src/stack.rs
index 3c77d24..61d595a 100644
--- a/tmui/src/stack.rs
+++ b/tmui/src/stack.rs
@@ -64,14 +64,14 @@ impl WidgetImpl for Stack {}
 
 impl ContainerImpl for Stack {
     fn children(&self) -> Vec<&dyn WidgetImpl> {
-        self.container.children.iter().map(|c| c.as_ref()).collect()
+        self.container.children.iter().map(|c| c.bind()).collect()
     }
 
     fn children_mut(&mut self) -> Vec<&mut dyn WidgetImpl> {
         self.container
             .children
             .iter_mut()
-            .map(|c| c.as_mut())
+            .map(|c| c.bind_mut())
             .collect()
     }
 
@@ -81,7 +81,7 @@ impl ContainerImpl for Stack {
 }
 
 impl ContainerImplExt for Stack {
-    fn add_child<T>(&mut self, mut child: Box<T>)
+    fn add_child<T>(&mut self, mut child: Tr<T>)
     where
         T: WidgetImpl,
     {
@@ -92,9 +92,8 @@ impl ContainerImplExt for Stack {
             child.hide()
         }
 
-        ApplicationWindow::initialize_dynamic_component(child.as_mut(), self.is_in_tree());
-
-        self.container.children.push(child);
+        self.container.children.push(child.clone().into());
+        ApplicationWindow::initialize_dynamic_component(child.as_dyn_mut(), self.is_in_tree());
         self.update();
     }
 
@@ -186,7 +185,7 @@ impl StaticContainerScaleCalculate for Stack {
 
 impl Stack {
     #[inline]
-    pub fn new() -> Box<Self> {
-        Object::new(&[])
+    pub fn new() -> Tr<Self> {
+        Self::new_alloc()
     }
 }
diff --git a/tmui/src/tooltip.rs b/tmui/src/tooltip.rs
index a6a87c2..79092d8 100644
--- a/tmui/src/tooltip.rs
+++ b/tmui/src/tooltip.rs
@@ -12,7 +12,7 @@ use tlib::figure::OptionSize;
 #[derive(Childable)]
 pub struct Tooltip {
     #[child]
-    label: Box<Label>,
+    label: Tr<Label>,
 }
 
 #[cfg(win_tooltip)]
@@ -27,7 +27,7 @@ pub enum TooltipCrsMsg {
 #[tlib::win_widget(TooltipCrsMsg)]
 pub struct Tooltip {
     #[child]
-    label: Box<Label>,
+    label: Tr<Label>,
 }
 
 #[cfg(win_tooltip)]
@@ -119,8 +119,8 @@ impl Tooltip {
 #[cfg(not(win_tooltip))]
 impl Tooltip {
     #[inline]
-    pub(crate) fn new() -> Box<Self> {
-        Object::new(&[])
+    pub(crate) fn new() -> Tr<Self> {
+        Self::new_alloc()
     }
 }
 
diff --git a/tmui/src/vbox.rs b/tmui/src/vbox.rs
index b348946..f4d56cb 100644
--- a/tmui/src/vbox.rs
+++ b/tmui/src/vbox.rs
@@ -34,14 +34,14 @@ impl WidgetImpl for VBox {}
 
 impl ContainerImpl for VBox {
     fn children(&self) -> Vec<&dyn WidgetImpl> {
-        self.container.children.iter().map(|c| c.as_ref()).collect()
+        self.container.children.iter().map(|c| c.bind()).collect()
     }
 
     fn children_mut(&mut self) -> Vec<&mut dyn WidgetImpl> {
         self.container
             .children
             .iter_mut()
-            .map(|c| c.as_mut())
+            .map(|c| c.bind_mut())
             .collect()
     }
 
@@ -51,13 +51,13 @@ impl ContainerImpl for VBox {
 }
 
 impl ContainerImplExt for VBox {
-    fn add_child<T>(&mut self, mut child: Box<T>)
+    fn add_child<T>(&mut self, mut child: Tr<T>)
     where
         T: WidgetImpl,
     {
         child.set_parent(self);
-        ApplicationWindow::initialize_dynamic_component(child.as_mut(), self.is_in_tree());
-        self.container.children.push(child);
+        self.container.children.push(child.clone().into());
+        ApplicationWindow::initialize_dynamic_component(child.as_dyn_mut(), self.is_in_tree());
         self.update();
     }
 
@@ -144,8 +144,8 @@ impl ContentAlignment for VBox {
 }
 
 impl VBox {
-    pub fn new() -> Box<Self> {
-        Object::new(&[])
+    pub fn new() -> Tr<Self> {
+        Self::new_alloc()
     }
 }
 
diff --git a/tmui/src/views/list_view/list_view_image.rs b/tmui/src/views/list_view/list_view_image.rs
index 036d7bc..2e61e7d 100644
--- a/tmui/src/views/list_view/list_view_image.rs
+++ b/tmui/src/views/list_view/list_view_image.rs
@@ -115,8 +115,8 @@ impl WidgetImpl for ListViewImage {
 
 impl ListViewImage {
     #[inline]
-    pub(crate) fn new(scroll_bar: &mut ScrollBar) -> Box<Self> {
-        let mut img: Box<ListViewImage> = Object::new(&[]);
+    pub(crate) fn new(scroll_bar: &mut ScrollBar) -> Tr<Self> {
+        let mut img = Self::new_alloc();
         img.scroll_bar = NonNull::new(scroll_bar);
         img
     }
diff --git a/tmui/src/views/list_view/mod.rs b/tmui/src/views/list_view/mod.rs
index 49e3ea0..a3fea12 100644
--- a/tmui/src/views/list_view/mod.rs
+++ b/tmui/src/views/list_view/mod.rs
@@ -109,8 +109,8 @@ impl WidgetImpl for ListView {
 
 impl ListView {
     #[inline]
-    pub fn new() -> Box<Self> {
-        Object::new(&[])
+    pub fn new() -> Tr<Self> {
+        Self::new_alloc()
     }
 
     /// @return the index of added node.
diff --git a/tmui/src/views/tree_view/mod.rs b/tmui/src/views/tree_view/mod.rs
index ef110cb..c95140a 100644
--- a/tmui/src/views/tree_view/mod.rs
+++ b/tmui/src/views/tree_view/mod.rs
@@ -104,8 +104,8 @@ impl WidgetImpl for TreeView {}
 
 impl TreeView {
     #[inline]
-    pub fn new() -> Box<Self> {
-        Object::new(&[])
+    pub fn new() -> Tr<Self> {
+        Self::new_alloc()
     }
 
     #[inline]
diff --git a/tmui/src/views/tree_view/tree_view_image.rs b/tmui/src/views/tree_view/tree_view_image.rs
index bafe3e7..dedfceb 100644
--- a/tmui/src/views/tree_view/tree_view_image.rs
+++ b/tmui/src/views/tree_view/tree_view_image.rs
@@ -204,8 +204,8 @@ impl WidgetImpl for TreeViewImage {
 
 impl TreeViewImage {
     #[inline]
-    pub fn new(scroll_bar: &mut ScrollBar) -> Box<Self> {
-        let mut image: Box<TreeViewImage> = Object::new(&[]);
+    pub fn new(scroll_bar: &mut ScrollBar) -> Tr<Self> {
+        let mut image = Self::new_alloc();
         image.scroll_bar = NonNull::new(scroll_bar);
         image
     }
diff --git a/tmui/src/widget/mod.rs b/tmui/src/widget/mod.rs
index 1b76d87..b61e912 100644
--- a/tmui/src/widget/mod.rs
+++ b/tmui/src/widget/mod.rs
@@ -46,8 +46,7 @@ pub type WidgetHnd = Option<NonNull<dyn WidgetImpl>>;
 pub struct Widget {
     parent: WidgetHnd,
 
-    child: Option<Box<dyn WidgetImpl>>,
-    child_ref: WidgetHnd,
+    child: Option<DynTr>,
     children_index: IntSet<ObjectId>,
 
     old_rect: FRect,
@@ -287,7 +286,7 @@ impl WidgetSignals for dyn WidgetImpl {}
 ////////////////////////////////////// Widget Implements //////////////////////////////////////
 impl Widget {
     #[inline]
-    pub fn _child_internal<T>(&mut self, mut child: Box<T>)
+    pub fn _child_internal<T>(&mut self, mut child: Tr<T>)
     where
         T: WidgetImpl,
     {
@@ -295,22 +294,9 @@ impl Widget {
             panic!("Do not call `child_internal()` directly, use `child()` instead.")
         }
 
-        ApplicationWindow::initialize_dynamic_component(child.as_mut(), self.is_in_tree());
+        self.child = Some(child.clone().into());
 
-        self.child = Some(child);
-        self.child_ref = None;
-    }
-
-    #[inline]
-    pub fn _child_ref_internal(&mut self, child: &mut dyn WidgetImpl) {
-        if child.get_parent_ref().is_none() {
-            panic!("Do not call `child_internal()` directly, use `child()` instead.")
-        }
-
-        ApplicationWindow::initialize_dynamic_component(child, self.is_in_tree());
-
-        self.child = None;
-        self.child_ref = NonNull::new(child);
+        ApplicationWindow::initialize_dynamic_component(child.as_dyn_mut(), self.is_in_tree());
     }
 
     #[inline]
@@ -354,9 +340,9 @@ impl Widget {
 
     /// Notify the child to change the zindex.
     #[inline]
-    fn notify_zindex(&mut self, offset: u32) {
+    fn notify_zindex(&mut self, new_zindex: u64) {
         if let Some(child) = self.get_child_mut() {
-            child.set_z_index(child.z_index() + offset);
+            child.set_z_index(new_zindex);
         }
     }
 
@@ -453,8 +439,8 @@ impl ObjectImpl for Widget {
                 if !ApplicationWindow::window_of(self.window_id()).initialized() {
                     return;
                 }
-                let new_z_index = value.get::<u32>();
-                self.notify_zindex(new_z_index - self.z_index());
+                let new_z_index = value.get::<u64>();
+                self.notify_zindex(new_z_index);
             }
             "rerender_styles" => {
                 let rerender = value.get::<bool>();
@@ -1488,22 +1474,6 @@ impl dyn WidgetImpl {
             None
         }
     }
-
-    #[inline]
-    pub fn downcast<T: StaticType + 'static>(self: Box<Self>) -> Option<Box<T>> {
-        let require = self.object_type().name();
-        match self.as_any_boxed().downcast::<T>() {
-            Ok(v) => Some(v),
-            _ => {
-                error!(
-                    "Downcast widget type mismatched, require {}, get {}",
-                    require,
-                    T::static_type().name()
-                );
-                None
-            }
-        }
-    }
 }
 
 impl AsMutPtr for dyn WidgetImpl {}
@@ -1511,24 +1481,16 @@ impl AsMutPtr for dyn WidgetImpl {}
 pub trait ChildOp: WidgetImpl {
     /// @see [`Widget::_child_internal`](Widget::_child_internal) <br>
     /// Go to[`Function defination`](ChildOp::child) (Defined in [`ChildOp`])
-    fn child<T: WidgetImpl>(&mut self, child: Box<T>);
-
-    /// # Safety
-    /// Do not call this function directly, this crate will handle the lifetime of child widget automatically.
-    ///
-    /// @see [`Widget::_child_ref_internal`](Widget::_child_ref_internal) <br>
-    /// Go to[`Function defination`](ChildOp::_child_ref) (Defined in [`ChildOp`])
-    unsafe fn _child_ref(&mut self, child: *mut dyn WidgetImpl);
+    fn child<T: WidgetImpl>(&mut self, child: Tr<T>);
 
     /// @see [`Widget::_remove_child_internal`](Widget::_remove_child_internal) <br>
     /// Go to[`Function defination`](ChildOp::child) (Defined in [`ChildOp`])
     /// Remove current child.
-    /// Child with `#[child]` annotated can't be removed.
     fn remove_child(&mut self);
 }
 impl ChildOp for Widget {
     #[inline]
-    fn child<_T: WidgetImpl>(&mut self, mut child: Box<_T>) {
+    fn child<_T: WidgetImpl>(&mut self, mut child: Tr<_T>) {
         if self.super_type().is_a(Container::static_type()) {
             panic!("function `child()` was invalid in `Container`, use `add_child()` instead")
         }
@@ -1536,16 +1498,6 @@ impl ChildOp for Widget {
         self._child_internal(child)
     }
 
-    #[inline]
-    unsafe fn _child_ref(&mut self, child: *mut dyn WidgetImpl) {
-        if self.super_type().is_a(Container::static_type()) {
-            panic!("function `_child_ref()` was invalid in `Container`")
-        }
-        let child_mut = tlib::ptr_mut!(child);
-        child_mut.set_parent(self);
-        self._child_ref_internal(child_mut)
-    }
-
     #[inline]
     fn remove_child(&mut self) {
         if self.super_type().is_a(Container::static_type()) {
@@ -1580,32 +1532,6 @@ impl Layout for Widget {
     }
 }
 
-////////////////////////////////////// ZInddexStep //////////////////////////////////////
-pub(crate) trait ZIndexStep {
-    /// Get current widget's z-index step, starts from 1, `auto-increacement`.
-    fn z_index_step(&mut self) -> u32;
-}
-macro_rules! z_index_step_impl {
-    () => {
-        #[inline]
-        fn z_index_step(&mut self) -> u32 {
-            let step = match self.get_property("z_index_step") {
-                Some(val) => val.get(),
-                None => 1,
-            };
-            self.set_property("z_index_step", (step + 1).to_value());
-            step
-        }
-    };
-}
-impl<T: WidgetImpl> ZIndexStep for T {
-    z_index_step_impl!();
-}
-
-impl ZIndexStep for dyn WidgetImpl {
-    z_index_step_impl!();
-}
-
 ////////////////////////////////////// ScaleCalculate //////////////////////////////////////
 pub(crate) trait ScaleCalculate {
     #[inline]
diff --git a/tmui/src/widget/widget_ext.rs b/tmui/src/widget/widget_ext.rs
index 0b5faff..63c0e60 100644
--- a/tmui/src/widget/widget_ext.rs
+++ b/tmui/src/widget/widget_ext.rs
@@ -621,56 +621,29 @@ impl<T: WidgetImpl> WidgetExt for T {
 
     #[inline]
     fn get_raw_child(&self) -> Option<*const dyn WidgetImpl> {
-        let mut child = self
+        let child = self
             .widget_props()
             .child
             .as_ref()
-            .map(|c| c.as_ref().as_ptr());
-
-        if child.is_none() {
-            unsafe {
-                child = match self.widget_props().child_ref {
-                    Some(ref c) => Some(c.as_ref().as_ptr()),
-                    None => None,
-                }
-            }
-        }
+            .map(|c| c.bind().as_ptr());
 
         child
     }
 
     #[inline]
     fn get_raw_child_mut(&mut self) -> Option<*mut dyn WidgetImpl> {
-        let mut child = self
+        let child = self
             .widget_props_mut()
             .child
             .as_mut()
-            .map(|c| c.as_mut().as_ptr_mut());
-
-        if child.is_none() {
-            unsafe {
-                child = match self.widget_props_mut().child_ref {
-                    Some(ref mut c) => Some(c.as_mut().as_ptr_mut()),
-                    None => None,
-                }
-            }
-        }
+            .map(|c| c.bind_mut().as_ptr_mut());
 
         child
     }
 
     #[inline]
     fn get_child_ref(&self) -> Option<&dyn WidgetImpl> {
-        let mut child = self.widget_props().child.as_ref().map(|c| c.as_ref());
-
-        if child.is_none() {
-            unsafe {
-                child = match self.widget_props().child_ref {
-                    Some(ref c) => Some(c.as_ref()),
-                    None => None,
-                }
-            }
-        }
+        let child = self.widget_props().child.as_ref().map(|c| c.bind());
 
         child
     }
@@ -678,16 +651,7 @@ impl<T: WidgetImpl> WidgetExt for T {
     #[inline]
     fn get_child_mut(&mut self) -> Option<&mut dyn WidgetImpl> {
         let props = self.widget_props_mut();
-        let mut child = props.child.as_mut().map(|c| c.as_mut());
-
-        if child.is_none() {
-            unsafe {
-                child = match props.child_ref {
-                    Some(ref mut c) => Some(c.as_mut()),
-                    None => None,
-                }
-            }
-        }
+        let child = props.child.as_mut().map(|c| c.bind_mut());
 
         child
     }
diff --git a/tmui/tests/container_test.rs b/tmui/tests/container_test.rs
index dc296b3..ad7d5fe 100644
--- a/tmui/tests/container_test.rs
+++ b/tmui/tests/container_test.rs
@@ -15,7 +15,7 @@ pub struct TestContainer {
     #[derivative(Default(value = "99"))]
     _num: i32,
     #[children]
-    _label: Box<Label>,
+    _label: Tr<Label>,
 }
 
 impl ObjectSubclass for TestContainer {
@@ -28,14 +28,14 @@ impl WidgetImpl for TestContainer {}
 
 impl ContainerImpl for TestContainer {
     fn children(&self) -> Vec<&dyn WidgetImpl> {
-        self.container.children.iter().map(|c| c.as_ref()).collect()
+        self.container.children.iter().map(|c| c.bind()).collect()
     }
 
     fn children_mut(&mut self) -> Vec<&mut dyn WidgetImpl> {
         self.container
             .children
             .iter_mut()
-            .map(|c| c.as_mut())
+            .map(|c| c.bind_mut())
             .collect()
     }
 
@@ -45,11 +45,11 @@ impl ContainerImpl for TestContainer {
 }
 
 impl ContainerImplExt for TestContainer {
-    fn add_child<T>(&mut self, child: Box<T>)
+    fn add_child<T>(&mut self, child: Tr<T>)
     where
         T: WidgetImpl,
     {
-        self.container.children.push(child)
+        self.container.children.push(child.into())
     }
 
     fn remove_children(&mut self, _: ObjectId) {}
@@ -77,11 +77,10 @@ impl ContainerScaleCalculate for TestContainer {
 fn main() {
     ActionHub::initialize();
     let r = TypeRegistry::instance();
-    let mut c = Object::new::<TestContainer>(&[]);
+    let mut c = TestContainer::new_alloc();
     c.inner_type_register(r);
-    cast_test(c.as_ref());
-    cast_mut_test(c.as_mut());
-    cast_boxed_test(c);
+    cast_test(c.bind());
+    cast_mut_test(c.bind_mut());
 }
 
 fn cast_test(widget: &dyn WidgetImpl) {
@@ -99,11 +98,3 @@ fn cast_mut_test(widget: &mut dyn WidgetImpl) {
     }
     assert!(c);
 }
-
-fn cast_boxed_test(widget: Box<dyn WidgetImpl>) {
-    let mut c = false;
-    if let Some(_) = cast_boxed!(widget as ContainerImpl) {
-        c = true;
-    }
-    assert!(c);
-}
diff --git a/tmui/tests/layout_extend_test.rs b/tmui/tests/layout_extend_test.rs
index d8fe374..a3f00df 100644
--- a/tmui/tests/layout_extend_test.rs
+++ b/tmui/tests/layout_extend_test.rs
@@ -5,7 +5,7 @@ use tmui::{label::Label, platform::PlatformType, prelude::*};
 #[derive(Childrenable)]
 struct TestWidget {
     #[children]
-    label: Box<Label>,
+    label: Tr<Label>,
 }
 
 impl ObjectSubclass for TestWidget {
@@ -26,11 +26,11 @@ fn main() {
     ActionHub::initialize();
     let _window = ApplicationWindow::new(PlatformType::default(), 0, 0);
 
-    let widget: Box<TestWidget> = Object::new(&[]);
+    let widget = TestWidget::new_alloc();
     let children = widget.children();
     assert_eq!(1, children.len());
     let label_dyn = *children.first().unwrap();
     assert_eq!(widget.label.id(), label_dyn.id());
     let label = label_dyn.downcast_ref::<Label>().unwrap();
     assert_eq!("Hello World", label.text())
-}
\ No newline at end of file
+}

From dce1239b47b928b64a2c04528cb63f7392c308f0 Mon Sep 17 00:00:00 2001
From: JoeZane <joezane.cn@gmail.com>
Date: Mon, 21 Apr 2025 03:01:39 +0800
Subject: [PATCH 6/7] upd: remove generic param bound of `DynPopupTrAlloc`

---
 tmui/src/primitive/obj/alloc.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/tmui/src/primitive/obj/alloc.rs b/tmui/src/primitive/obj/alloc.rs
index d3ed33a..ed89e7d 100644
--- a/tmui/src/primitive/obj/alloc.rs
+++ b/tmui/src/primitive/obj/alloc.rs
@@ -87,7 +87,7 @@ pub trait DynTrAlloc: WidgetImpl {
 }
 impl DynTrAlloc for dyn WidgetImpl {}
 
-pub trait DynPopupTrAlloc<T: PopupImpl + ObjectSubclass + Default>: PopupImpl {
+pub trait DynPopupTrAlloc: PopupImpl {
     #[inline]
     fn to_dyn_popup_tr(&self) -> DynPopupTr {
         let id = self.id();
@@ -102,7 +102,7 @@ pub trait DynPopupTrAlloc<T: PopupImpl + ObjectSubclass + Default>: PopupImpl {
         })
     }
 }
-impl<T: PopupImpl + ObjectSubclass + Default> DynPopupTrAlloc<T> for T {}
+impl<T: PopupImpl> DynPopupTrAlloc for T {}
 
 #[cfg(test)]
 mod tests {

From ff50b4493810586381f23112d19bce9baa63456d Mon Sep 17 00:00:00 2001
From: JoeZane <joezane.cn@gmail.com>
Date: Mon, 21 Apr 2025 22:55:20 +0800
Subject: [PATCH 7/7] upd: handle popup's render order assignment.

---
 tmui/src/application_window.rs | 13 ++++++++++++-
 1 file changed, 12 insertions(+), 1 deletion(-)

diff --git a/tmui/src/application_window.rs b/tmui/src/application_window.rs
index faca444..9223f7c 100644
--- a/tmui/src/application_window.rs
+++ b/tmui/src/application_window.rs
@@ -502,7 +502,18 @@ impl ApplicationWindow {
 
         child_initialize(Some(widget), window_id, ancestor_is_in_tree);
 
-        window.rebuild_render_order();
+        let root_ancestor = widget.root_ancestor();
+        if root_ancestor == window.id() {
+            window.rebuild_render_order();
+        } else if root_ancestor != widget.id() {
+            if let Some(ancestor) = window.find_id_mut(root_ancestor) {
+                let mut order_counter = 0;
+                assign_render_order(ancestor, &mut order_counter);
+            } else {
+                error!("Fatal error, the ancestor of `{}` is None.", widget.name())
+            }
+        }
+
         window.board().shuffle();
         window.layout_change(widget);