use super::*;
impl<E> Widget<E> for &(dyn Widget<E>+'_) where E: Env {
#[inline]
fn id(&self) -> E::WidgetID {
(**self).id()
}
#[inline]
fn _render(&self, l: Link<E>, r: &mut RenderLink<E>) {
(**self)._render(l,r)
}
#[inline]
fn _event_direct(&self, l: Link<E>, e: &EventCompound<E>) -> EventResp {
(**self)._event_direct(l,e)
}
#[inline]
fn _size(&self, l: Link<E>, e: &EStyle<E>) -> ESize<E> {
(**self)._size(l,e)
}
#[inline]
fn childs(&self) -> usize {
(**self).childs()
}
#[allow(deprecated)]
#[inline]
fn childs_ref(&self) -> Vec<Resolvable<E>> {
(**self).childs_ref()
}
#[allow(deprecated)]
#[inline]
fn into_childs<'w>(self: Box<Self>) -> Vec<Resolvable<'w,E>> where Self: 'w {
(**self).childs_ref()
}
#[inline]
fn child_bounds(&self, l: Link<E>, b: &Bounds, e: &EStyle<E>, force: bool) -> Result<Vec<Bounds>,()> {
(**self).child_bounds(l, b,e, force)
}
#[inline]
fn focusable(&self) -> bool {
(**self).focusable()
}
#[allow(deprecated)]
#[inline]
fn child_paths(&self, own_path: E::WidgetPath) -> Vec<E::WidgetPath> {
(**self).child_paths(own_path)
}
#[inline]
fn resolve(&self, i: E::WidgetPath) -> Result<Resolvable<E>,GuionError<E>> {
(**self).resolve(i)
}
#[inline]
fn into_resolve<'w>(self: Box<Self>, i: E::WidgetPath) -> Result<Resolvable<'w,E>,GuionError<E>> where Self: 'w {
(**self).resolve(i)
}
#[inline]
fn resolve_child(&self, p: &E::WidgetPath) -> Result<(usize,E::WidgetPath),GuionError<E>> {
(**self).resolve_child(p)
}
#[inline]
fn trace_bounds(&self, l: Link<E>, i: E::WidgetPath, b: &Bounds, e: &EStyle<E>, force: bool) -> Result<Bounds,GuionError<E>> {
(**self).trace_bounds(l, i, b,e, force)
}
#[allow(deprecated)]
#[inline]
fn in_parent_path(&self, parent: E::WidgetPath) -> E::WidgetPath {
(**self).in_parent_path(parent)
}
#[allow(deprecated)]
#[inline]
fn resolved_by_path(&self, sub_path: &E::WidgetPath) -> Option<ResolvesThruResult<E>> {
(**self).resolved_by_path(sub_path)
}
#[inline]
fn _focus_on_mouse_down(&self) -> bool {
(**self)._focus_on_mouse_down()
}
#[inline]
fn _tabulate_by_tab(&self) -> bool {
(**self)._tabulate_by_tab()
}
fn debug_type_name(&self, dest: &mut Vec<&'static str>) {
dest.push(self.type_name());
(**self).debug_type_name(dest);
}
#[inline]
fn inner(&self) -> Option<&dyn Widget<E>> {
Some(&(**self))
}
#[inline]
fn child(&self, i: usize) -> Result<Resolvable<E>,()> {
(**self).child(i)
}
#[inline]
fn into_child<'w>(self: Box<Self>, i: usize) -> Result<Resolvable<'w,E>,()> where Self: 'w {
(**self).child(i)
}
#[inline]
fn box_ref(&self) -> WidgetRef<E> {
(**self).box_ref()
}
#[inline]
fn box_box<'w>(self: Box<Self>) -> WidgetRef<'w,E> where Self: 'w {
(**self).box_ref()
}
#[inline]
fn boxed<'w>(self) -> WidgetRef<'w,E> where Self: Sized+'w {
(*self).box_ref()
}
}
impl<E> Widget<E> for &mut (dyn Widget<E>+'_) where E: Env {
#[inline]
fn id(&self) -> E::WidgetID {
(**self).id()
}
#[inline]
fn _render(&self, l: Link<E>, r: &mut RenderLink<E>) {
(**self)._render(l,r)
}
#[inline]
fn _event_direct(&self, l: Link<E>, e: &EventCompound<E>) -> EventResp {
(**self)._event_direct(l,e)
}
#[inline]
fn _size(&self, l: Link<E>, e: &EStyle<E>) -> ESize<E> {
(**self)._size(l,e)
}
#[inline]
fn childs(&self) -> usize {
(**self).childs()
}
#[allow(deprecated)]
#[inline]
fn childs_ref(&self) -> Vec<Resolvable<E>> {
(**self).childs_ref()
}
#[allow(deprecated)]
#[inline]
fn into_childs<'w>(self: Box<Self>) -> Vec<Resolvable<'w,E>> where Self: 'w {
(**self).childs_ref()
}
#[inline]
fn child_bounds(&self, l: Link<E>, b: &Bounds, e: &EStyle<E>, force: bool) -> Result<Vec<Bounds>,()> {
(**self).child_bounds(l, b,e, force)
}
#[inline]
fn focusable(&self) -> bool {
(**self).focusable()
}
#[allow(deprecated)]
#[inline]
fn child_paths(&self, own_path: E::WidgetPath) -> Vec<E::WidgetPath> {
(**self).child_paths(own_path)
}
#[inline]
fn resolve(&self, i: E::WidgetPath) -> Result<Resolvable<E>,GuionError<E>> {
(**self).resolve(i)
}
#[inline]
fn into_resolve<'w>(self: Box<Self>, i: E::WidgetPath) -> Result<Resolvable<'w,E>,GuionError<E>> where Self: 'w {
(**self).resolve(i)
}
#[inline]
fn resolve_child(&self, p: &E::WidgetPath) -> Result<(usize,E::WidgetPath),GuionError<E>> {
(**self).resolve_child(p)
}
#[inline]
fn trace_bounds(&self, l: Link<E>, i: E::WidgetPath, b: &Bounds, e: &EStyle<E>, force: bool) -> Result<Bounds,GuionError<E>> {
(**self).trace_bounds(l, i, b,e, force)
}
#[allow(deprecated)]
#[inline]
fn in_parent_path(&self, parent: E::WidgetPath) -> E::WidgetPath {
(**self).in_parent_path(parent)
}
#[allow(deprecated)]
#[inline]
fn resolved_by_path(&self, sub_path: &E::WidgetPath) -> Option<ResolvesThruResult<E>> {
(**self).resolved_by_path(sub_path)
}
#[inline]
fn _focus_on_mouse_down(&self) -> bool {
(**self)._focus_on_mouse_down()
}
#[inline]
fn _tabulate_by_tab(&self) -> bool {
(**self)._tabulate_by_tab()
}
fn debug_type_name(&self, dest: &mut Vec<&'static str>) {
dest.push(self.type_name());
(**self).debug_type_name(dest);
}
#[inline]
fn inner(&self) -> Option<&dyn Widget<E>> {
Some(&(**self))
}
#[inline]
fn child(&self, i: usize) -> Result<Resolvable<E>,()> {
(**self).child(i)
}
#[inline]
fn into_child<'w>(self: Box<Self>, i: usize) -> Result<Resolvable<'w,E>,()> where Self: 'w {
(**self).child(i)
}
#[inline]
fn box_ref(&self) -> WidgetRef<E> {
(**self).box_ref()
}
#[inline]
fn box_box<'w>(self: Box<Self>) -> WidgetRef<'w,E> where Self: 'w {
(**self).box_ref()
}
#[inline]
fn boxed<'w>(self) -> WidgetRef<'w,E> where Self: Sized+'w {
(*self).box_ref()
}
}
impl<E> Widget<E> for &(dyn WidgetMut<E>+'_) where E: Env {
#[inline]
fn id(&self) -> E::WidgetID {
(**self).id()
}
#[inline]
fn _render(&self, l: Link<E>, r: &mut RenderLink<E>) {
(**self)._render(l,r)
}
#[inline]
fn _event_direct(&self, l: Link<E>, e: &EventCompound<E>) -> EventResp {
(**self)._event_direct(l,e)
}
#[inline]
fn _size(&self, l: Link<E>, e: &EStyle<E>) -> ESize<E> {
(**self)._size(l,e)
}
#[inline]
fn childs(&self) -> usize {
(**self).childs()
}
#[allow(deprecated)]
#[inline]
fn childs_ref(&self) -> Vec<Resolvable<E>> {
(**self).childs_ref()
}
#[allow(deprecated)]
#[inline]
fn into_childs<'w>(self: Box<Self>) -> Vec<Resolvable<'w,E>> where Self: 'w {
(**self).childs_ref()
}
#[inline]
fn child_bounds(&self, l: Link<E>, b: &Bounds, e: &EStyle<E>, force: bool) -> Result<Vec<Bounds>,()> {
(**self).child_bounds(l, b,e, force)
}
#[inline]
fn focusable(&self) -> bool {
(**self).focusable()
}
#[allow(deprecated)]
#[inline]
fn child_paths(&self, own_path: E::WidgetPath) -> Vec<E::WidgetPath> {
(**self).child_paths(own_path)
}
#[inline]
fn resolve(&self, i: E::WidgetPath) -> Result<Resolvable<E>,GuionError<E>> {
(**self).resolve(i)
}
#[inline]
fn into_resolve<'w>(self: Box<Self>, i: E::WidgetPath) -> Result<Resolvable<'w,E>,GuionError<E>> where Self: 'w {
(**self).resolve(i)
}
#[inline]
fn resolve_child(&self, p: &E::WidgetPath) -> Result<(usize,E::WidgetPath),GuionError<E>> {
(**self).resolve_child(p)
}
#[inline]
fn trace_bounds(&self, l: Link<E>, i: E::WidgetPath, b: &Bounds, e: &EStyle<E>, force: bool) -> Result<Bounds,GuionError<E>> {
(**self).trace_bounds(l, i, b,e, force)
}
#[allow(deprecated)]
#[inline]
fn in_parent_path(&self, parent: E::WidgetPath) -> E::WidgetPath {
(**self).in_parent_path(parent)
}
#[allow(deprecated)]
#[inline]
fn resolved_by_path(&self, sub_path: &E::WidgetPath) -> Option<ResolvesThruResult<E>> {
(**self).resolved_by_path(sub_path)
}
#[inline]
fn _focus_on_mouse_down(&self) -> bool {
(**self)._focus_on_mouse_down()
}
#[inline]
fn _tabulate_by_tab(&self) -> bool {
(**self)._tabulate_by_tab()
}
fn debug_type_name(&self, dest: &mut Vec<&'static str>) {
dest.push(self.type_name());
(**self).debug_type_name(dest);
}
#[inline]
fn inner(&self) -> Option<&dyn Widget<E>> {
Some((**self).base())
}
#[inline]
fn child(&self, i: usize) -> Result<Resolvable<E>,()> {
(**self).child(i)
}
#[inline]
fn into_child<'w>(self: Box<Self>, i: usize) -> Result<Resolvable<'w,E>,()> where Self: 'w {
let r: &dyn Widget<E> = (**self).base();
r.child(i)
}
#[inline]
fn box_ref(&self) -> WidgetRef<E> {
(**self).box_ref()
}
#[inline]
fn box_box<'w>(self: Box<Self>) -> WidgetRef<'w,E> where Self: 'w {
(**self).box_ref()
}
#[inline]
fn boxed<'w>(self) -> WidgetRef<'w,E> where Self: Sized+'w {
(*self).box_ref()
}
}
impl<E> Widget<E> for &mut (dyn WidgetMut<E>+'_) where E: Env {
#[inline]
fn id(&self) -> E::WidgetID {
(**self).id()
}
#[inline]
fn _render(&self, l: Link<E>, r: &mut RenderLink<E>) {
(**self)._render(l,r)
}
#[inline]
fn _event_direct(&self, l: Link<E>, e: &EventCompound<E>) -> EventResp {
(**self)._event_direct(l,e)
}
#[inline]
fn _size(&self, l: Link<E>, e: &EStyle<E>) -> ESize<E> {
(**self)._size(l,e)
}
#[inline]
fn childs(&self) -> usize {
(**self).childs()
}
#[allow(deprecated)]
#[inline]
fn childs_ref(&self) -> Vec<Resolvable<E>> {
(**self).childs_ref()
}
#[allow(deprecated)]
#[inline]
fn into_childs<'w>(self: Box<Self>) -> Vec<Resolvable<'w,E>> where Self: 'w {
(**self).childs_ref()
}
#[inline]
fn child_bounds(&self, l: Link<E>, b: &Bounds, e: &EStyle<E>, force: bool) -> Result<Vec<Bounds>,()> {
(**self).child_bounds(l, b,e, force)
}
#[inline]
fn focusable(&self) -> bool {
(**self).focusable()
}
#[allow(deprecated)]
#[inline]
fn child_paths(&self, own_path: E::WidgetPath) -> Vec<E::WidgetPath> {
(**self).child_paths(own_path)
}
#[inline]
fn resolve(&self, i: E::WidgetPath) -> Result<Resolvable<E>,GuionError<E>> {
(**self).resolve(i)
}
#[inline]
fn into_resolve<'w>(self: Box<Self>, i: E::WidgetPath) -> Result<Resolvable<'w,E>,GuionError<E>> where Self: 'w {
(**self).resolve(i)
}
#[inline]
fn resolve_child(&self, p: &E::WidgetPath) -> Result<(usize,E::WidgetPath),GuionError<E>> {
(**self).resolve_child(p)
}
#[inline]
fn trace_bounds(&self, l: Link<E>, i: E::WidgetPath, b: &Bounds, e: &EStyle<E>, force: bool) -> Result<Bounds,GuionError<E>> {
(**self).trace_bounds(l, i, b,e, force)
}
#[allow(deprecated)]
#[inline]
fn in_parent_path(&self, parent: E::WidgetPath) -> E::WidgetPath {
(**self).in_parent_path(parent)
}
#[allow(deprecated)]
#[inline]
fn resolved_by_path(&self, sub_path: &E::WidgetPath) -> Option<ResolvesThruResult<E>> {
(**self).resolved_by_path(sub_path)
}
#[inline]
fn _focus_on_mouse_down(&self) -> bool {
(**self)._focus_on_mouse_down()
}
#[inline]
fn _tabulate_by_tab(&self) -> bool {
(**self)._tabulate_by_tab()
}
fn debug_type_name(&self, dest: &mut Vec<&'static str>) {
dest.push(self.type_name());
(**self).debug_type_name(dest);
}
#[inline]
fn inner(&self) -> Option<&dyn Widget<E>> {
Some((**self).base())
}
#[inline]
fn child(&self, i: usize) -> Result<Resolvable<E>,()> {
(**self).child(i)
}
#[inline]
fn into_child<'w>(self: Box<Self>, i: usize) -> Result<Resolvable<'w,E>,()> where Self: 'w {
let r: &dyn Widget<E> = (**self).base();
r.child(i)
}
#[inline]
fn box_ref(&self) -> WidgetRef<E> {
(**self).box_ref()
}
#[inline]
fn box_box<'w>(self: Box<Self>) -> WidgetRef<'w,E> where Self: 'w {
(**self).box_ref()
}
#[inline]
fn boxed<'w>(self) -> WidgetRef<'w,E> where Self: Sized+'w {
(*self).box_ref()
}
}
impl<E> WidgetMut<E> for &mut (dyn WidgetMut<E>+'_) where E: Env {
#[allow(deprecated)]
#[inline]
fn childs_mut(&mut self) -> Vec<ResolvableMut<E>> {
(**self).childs_mut()
}
#[allow(deprecated)]
#[inline]
fn into_childs_mut<'w>(self: Box<Self>) -> Vec<ResolvableMut<'w,E>> where Self: 'w {
(**self).childs_mut()
}
#[inline]
fn _set_invalid(&mut self, v: bool) {
(**self)._set_invalid(v)
}
#[inline]
fn resolve_mut(&mut self, i: E::WidgetPath) -> Result<ResolvableMut<E>,GuionError<E>> {
(**self).resolve_mut(i)
}
#[inline]
fn into_resolve_mut<'w>(self: Box<Self>, i: E::WidgetPath) -> Result<ResolvableMut<'w,E>,GuionError<E>> where Self: 'w {
(**self).resolve_mut(i)
}
#[inline]
fn resolve_child_mut(&mut self, p: &E::WidgetPath) -> Result<(usize,E::WidgetPath),GuionError<E>> {
(**self).resolve_child_mut(p)
}
#[inline]
fn inner_mut(&mut self) -> Option<&mut dyn WidgetMut<E>> {
Some(&mut(**self))
}
#[inline]
fn child_mut(&mut self, i: usize) -> Result<ResolvableMut<E>,()> {
(**self).child_mut(i)
}
#[inline]
fn into_child_mut<'w>(self: Box<Self>, i: usize) -> Result<ResolvableMut<'w,E>,()> where Self: 'w {
(**self).child_mut(i)
}
#[inline]
fn message(&mut self, m: E::Message) {
(**self).message(m)
}
fn debug_type_name_mut(&mut self, dest: &mut Vec<&'static str>) {
dest.push(self.type_name());
(**self).debug_type_name_mut(dest);
}
#[inline]
fn box_mut(&mut self) -> WidgetRefMut<E> {
(**self).box_mut()
}
#[inline]
fn box_box_mut<'w>(self: Box<Self>) -> WidgetRefMut<'w,E> where Self: 'w {
(**self).box_mut()
}
#[inline]
fn boxed_mut<'w>(self) -> WidgetRefMut<'w,E> where Self: Sized+'w {
(*self).box_mut()
}
}
impl<E> Widget<E> for Box<(dyn Widget<E>+'_)> where E: Env {
#[inline]
fn id(&self) -> E::WidgetID {
(**self).id()
}
#[inline]
fn _render(&self, l: Link<E>, r: &mut RenderLink<E>) {
(**self)._render(l,r)
}
#[inline]
fn _event_direct(&self, l: Link<E>, e: &EventCompound<E>) -> EventResp {
(**self)._event_direct(l,e)
}
#[inline]
fn _size(&self, l: Link<E>, e: &EStyle<E>) -> ESize<E> {
(**self)._size(l,e)
}
#[inline]
fn childs(&self) -> usize {
(**self).childs()
}
#[allow(deprecated)]
#[inline]
fn childs_ref(&self) -> Vec<Resolvable<E>> {
(**self).childs_ref()
}
#[inline]
fn into_childs<'w>(self: Box<Self>) -> Vec<Resolvable<'w,E>> where Self: 'w {
(*self).into_childs()
}
#[inline]
fn child_bounds(&self, l: Link<E>, b: &Bounds, e: &EStyle<E>, force: bool) -> Result<Vec<Bounds>,()> {
(**self).child_bounds(l, b,e, force)
}
#[inline]
fn focusable(&self) -> bool {
(**self).focusable()
}
#[allow(deprecated)]
#[inline]
fn child_paths(&self, own_path: E::WidgetPath) -> Vec<E::WidgetPath> {
(**self).child_paths(own_path)
}
#[inline]
fn resolve(&self, i: E::WidgetPath) -> Result<Resolvable<E>,GuionError<E>> {
(**self).resolve(i)
}
#[inline]
fn into_resolve<'w>(self: Box<Self>, i: E::WidgetPath) -> Result<Resolvable<'w,E>,GuionError<E>> where Self: 'w {
(*self).into_resolve(i)
}
#[inline]
fn resolve_child(&self, p: &E::WidgetPath) -> Result<(usize,E::WidgetPath),GuionError<E>> {
(**self).resolve_child(p)
}
#[inline]
fn trace_bounds(&self, l: Link<E>, i: E::WidgetPath, b: &Bounds, e: &EStyle<E>, force: bool) -> Result<Bounds,GuionError<E>> {
(**self).trace_bounds(l, i, b,e, force)
}
#[allow(deprecated)]
#[inline]
fn in_parent_path(&self, parent: E::WidgetPath) -> E::WidgetPath {
(**self).in_parent_path(parent)
}
#[allow(deprecated)]
#[inline]
fn resolved_by_path(&self, sub_path: &E::WidgetPath) -> Option<ResolvesThruResult<E>> {
(**self).resolved_by_path(sub_path)
}
#[inline]
fn _focus_on_mouse_down(&self) -> bool {
(**self)._focus_on_mouse_down()
}
#[inline]
fn _tabulate_by_tab(&self) -> bool {
(**self)._tabulate_by_tab()
}
fn debug_type_name(&self, dest: &mut Vec<&'static str>) {
dest.push(self.type_name());
(**self).debug_type_name(dest);
}
#[inline]
fn inner(&self) -> Option<&dyn Widget<E>> {
Some(&**self)
}
#[inline]
fn child(&self, i: usize) -> Result<Resolvable<E>,()> {
(**self).child(i)
}
#[inline]
fn into_child<'w>(self: Box<Self>, i: usize) -> Result<Resolvable<'w,E>,()> where Self: 'w {
(*self).into_child(i)
}
#[inline]
fn box_ref(&self) -> WidgetRef<E> {
(**self).box_ref()
}
#[inline]
fn box_box<'w>(self: Box<Self>) -> WidgetRef<'w,E> where Self: 'w {
(*self).box_box()
}
#[inline]
fn boxed<'w>(self) -> WidgetRef<'w,E> where Self: Sized+'w {
self.box_box()
}
}
impl<E> Widget<E> for Box<(dyn WidgetMut<E>+'_)> where E: Env {
#[inline]
fn id(&self) -> E::WidgetID {
(**self).id()
}
#[inline]
fn _render(&self, l: Link<E>, r: &mut RenderLink<E>) {
(**self)._render(l,r)
}
#[inline]
fn _event_direct(&self, l: Link<E>, e: &EventCompound<E>) -> EventResp {
(**self)._event_direct(l,e)
}
#[inline]
fn _size(&self, l: Link<E>, e: &EStyle<E>) -> ESize<E> {
(**self)._size(l,e)
}
#[inline]
fn childs(&self) -> usize {
(**self).childs()
}
#[allow(deprecated)]
#[inline]
fn childs_ref(&self) -> Vec<Resolvable<E>> {
(**self).childs_ref()
}
#[inline]
fn into_childs<'w>(self: Box<Self>) -> Vec<Resolvable<'w,E>> where Self: 'w {
(*self).into_childs()
}
#[inline]
fn child_bounds(&self, l: Link<E>, b: &Bounds, e: &EStyle<E>, force: bool) -> Result<Vec<Bounds>,()> {
(**self).child_bounds(l, b,e, force)
}
#[inline]
fn focusable(&self) -> bool {
(**self).focusable()
}
#[allow(deprecated)]
#[inline]
fn child_paths(&self, own_path: E::WidgetPath) -> Vec<E::WidgetPath> {
(**self).child_paths(own_path)
}
#[inline]
fn resolve(&self, i: E::WidgetPath) -> Result<Resolvable<E>,GuionError<E>> where {
(**self).resolve(i)
}
#[inline]
fn into_resolve<'w>(self: Box<Self>, i: E::WidgetPath) -> Result<Resolvable<'w,E>,GuionError<E>> where Self: 'w {
(*self).into_resolve(i)
}
#[inline]
fn resolve_child(&self, p: &E::WidgetPath) -> Result<(usize,E::WidgetPath),GuionError<E>> {
(**self).resolve_child(p)
}
#[inline]
fn trace_bounds(&self, l: Link<E>, i: E::WidgetPath, b: &Bounds, e: &EStyle<E>, force: bool) -> Result<Bounds,GuionError<E>> {
(**self).trace_bounds(l, i, b,e, force)
}
#[allow(deprecated)]
#[inline]
fn in_parent_path(&self, parent: E::WidgetPath) -> E::WidgetPath {
(**self).in_parent_path(parent)
}
#[allow(deprecated)]
#[inline]
fn resolved_by_path(&self, sub_path: &E::WidgetPath) -> Option<ResolvesThruResult<E>> {
(**self).resolved_by_path(sub_path)
}
#[inline]
fn _focus_on_mouse_down(&self) -> bool {
(**self)._focus_on_mouse_down()
}
#[inline]
fn _tabulate_by_tab(&self) -> bool {
(**self)._tabulate_by_tab()
}
fn debug_type_name(&self, dest: &mut Vec<&'static str>) {
dest.push(self.type_name());
(**self).debug_type_name(dest);
}
#[inline]
fn inner(&self) -> Option<&dyn Widget<E>> {
Some((**self).base())
}
#[inline]
fn child(&self, i: usize) -> Result<Resolvable<E>,()> {
(**self).child(i)
}
#[inline]
fn into_child<'w>(self: Box<Self>, i: usize) -> Result<Resolvable<'w,E>,()> where Self: 'w {
(*self).into_child(i)
}
#[inline]
fn box_ref(&self) -> WidgetRef<E> {
(**self).box_ref()
}
#[inline]
fn box_box<'w>(self: Box<Self>) -> WidgetRef<'w,E> where Self: 'w {
(*self).box_box()
}
#[inline]
fn boxed<'w>(self) -> WidgetRef<'w,E> where Self: Sized+'w {
self.box_box()
}
}
impl<E> WidgetMut<E> for Box<(dyn WidgetMut<E>+'_)> where E: Env {
#[allow(deprecated)]
#[inline]
fn childs_mut(&mut self) -> Vec<ResolvableMut<E>> {
(**self).childs_mut()
}
#[inline]
fn into_childs_mut<'w>(self: Box<Self>) -> Vec<ResolvableMut<'w,E>> where Self: 'w {
(*self).into_childs_mut()
}
#[inline]
fn _set_invalid(&mut self, v: bool) {
(**self)._set_invalid(v)
}
#[inline]
fn resolve_mut(&mut self, i: E::WidgetPath) -> Result<ResolvableMut<E>,GuionError<E>> {
(**self).resolve_mut(i)
}
#[inline]
fn into_resolve_mut<'w>(self: Box<Self>, i: E::WidgetPath) -> Result<ResolvableMut<'w,E>,GuionError<E>> where Self: 'w {
(*self).into_resolve_mut(i)
}
#[inline]
fn resolve_child_mut(&mut self, p: &E::WidgetPath) -> Result<(usize,E::WidgetPath),GuionError<E>> {
(**self).resolve_child_mut(p)
}
#[inline]
fn inner_mut(&mut self) -> Option<&mut dyn WidgetMut<E>> {
Some(&mut(**self))
}
#[inline]
fn child_mut(&mut self, i: usize) -> Result<ResolvableMut<E>,()> {
(**self).child_mut(i)
}
#[inline]
fn into_child_mut<'w>(self: Box<Self>, i: usize) -> Result<ResolvableMut<'w,E>,()> where Self: 'w {
(*self).into_child_mut(i)
}
#[inline]
fn message(&mut self, m: E::Message) {
(**self).message(m)
}
fn debug_type_name_mut(&mut self, dest: &mut Vec<&'static str>) {
dest.push(self.type_name());
(**self).debug_type_name_mut(dest);
}
#[inline]
fn box_mut(&mut self) -> WidgetRefMut<E> {
(**self).box_mut()
}
#[inline]
fn box_box_mut<'w>(self: Box<Self>) -> WidgetRefMut<'w,E> where Self: 'w {
(*self).box_box_mut()
}
#[inline]
fn boxed_mut<'w>(self) -> WidgetRefMut<'w,E> where Self: Sized+'w {
self.box_box_mut()
}
}