1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103

use crate::element_tree::ReconcileCtx;
use crate::flex::FlexParams;
use crate::glue::DruidAppData;
use crate::widget_sequence::FlexWidget;
use crate::widget_sequence::WidgetSequence;
use druid::kurbo::{Rect, Size};
use druid::{
    BoxConstraints, Env, Event, EventCtx, LayoutCtx, LifeCycle, LifeCycleCtx, PaintCtx, UpdateCtx,
    Widget, WidgetPod,
};
use tracing::trace;

pub struct SingleWidget<W: Widget<DruidAppData>> {
    pub pod: WidgetPod<DruidAppData, W>,
    pub flex: FlexParams,
}

impl<W: Widget<DruidAppData>> SingleWidget<W> {
    pub fn new(widget: W, flex: FlexParams) -> Self {
        SingleWidget {
            pod: WidgetPod::new(widget),
            flex,
        }
    }

    pub fn widget(&self) -> &W {
        self.pod.widget()
    }

    pub fn widget_mut(&mut self) -> &mut W {
        self.pod.widget_mut()
    }

    pub fn request_druid_update(&mut self, ctx: &mut ReconcileCtx) {
        self.pod
            .with_event_context(ctx.event_ctx, |_widget: &mut W, ctx: &mut EventCtx| {
                trace!("request_druid_update: {:?}", ctx.widget_id());
                ctx.request_update();
            });
    }
}

impl<W: Widget<DruidAppData>> FlexWidget for SingleWidget<W> {
    fn flex_params(&self) -> FlexParams {
        self.flex
    }

    fn event(&mut self, ctx: &mut EventCtx, event: &Event, data: &mut DruidAppData, env: &Env) {
        self.pod.event(ctx, event, data, env);
    }

    fn lifecycle(
        &mut self,
        ctx: &mut LifeCycleCtx,
        event: &LifeCycle,
        data: &DruidAppData,
        env: &Env,
    ) {
        self.pod.lifecycle(ctx, event, data, env);
    }

    fn update(
        &mut self,
        ctx: &mut UpdateCtx,
        _old_data: &DruidAppData,
        data: &DruidAppData,
        env: &Env,
    ) {
        self.pod.update(ctx, data, env);
    }

    fn layout(
        &mut self,
        ctx: &mut LayoutCtx,
        bc: &BoxConstraints,
        data: &DruidAppData,
        env: &Env,
    ) -> Size {
        self.pod.layout(ctx, bc, data, env)
    }

    fn paint_rect(&self) -> Rect {
        self.pod.paint_rect()
    }

    fn set_layout_rect(&mut self, ctx: &mut LayoutCtx, data: &DruidAppData, env: &Env, rect: Rect) {
        self.pod.set_layout_rect(ctx, data, env, rect)
    }

    fn layout_rect(&self) -> Rect {
        self.pod.layout_rect()
    }

    fn paint(&mut self, ctx: &mut PaintCtx, data: &DruidAppData, env: &Env) {
        self.pod.paint(ctx, data, env);
    }
}

impl<W: Widget<DruidAppData>> WidgetSequence for SingleWidget<W> {
    fn widgets(&mut self) -> Vec<&mut dyn FlexWidget> {
        vec![self]
    }
}