Struct Vec2 Copy item path

45fn build_root_widget() -> impl Widget<State> {
46    ZStack::new(
47        Button::from_label(Label::dynamic(|state: &State, _| {
48            format!(
49                "Very large button with text! Count up (currently {})",
50                state.counter
51            )
52        }))
53        .on_click(|_, state: &mut State, _| state.counter += 1),
54    )
55    .with_child(
56        Button::new("Reset").on_click(|_, state: &mut State, _| state.counter = 0),
57        Vec2::new(1.0, 1.0),
58        Vec2::ZERO,
59        UnitPoint::LEFT,
60        Vec2::new(10.0, 0.0),
61    )
62}

99    fn event(&mut self, child: &mut W, ctx: &mut EventCtx, event: &Event, data: &mut T, env: &Env) {
100        let wait_duration = Duration::from_millis(500);
101        let resched_dur = Duration::from_millis(50);
102        let cursor_size = Size::new(15., 15.);
103        let now = Instant::now();
104        let new_state = match &self.state {
105            TooltipState::Fresh => match event {
106                Event::MouseMove(me) if ctx.is_hot() => Some(TooltipState::Waiting {
107                    last_move: now,
108                    timer_expire: now + wait_duration,
109                    token: ctx.request_timer(wait_duration),
110                    position_in_window_coordinates: me.window_pos,
111                }),
112                _ => None,
113            },
114            TooltipState::Waiting {
115                last_move,
116                timer_expire,
117                token,
118                position_in_window_coordinates,
119            } => match event {
120                Event::MouseMove(me) if ctx.is_hot() => {
121                    let (cur_token, cur_expire) = if *timer_expire - now < resched_dur {
122                        (ctx.request_timer(wait_duration), now + wait_duration)
123                    } else {
124                        (*token, *timer_expire)
125                    };
126                    Some(TooltipState::Waiting {
127                        last_move: now,
128                        timer_expire: cur_expire,
129                        token: cur_token,
130                        position_in_window_coordinates: me.window_pos,
131                    })
132                }
133                Event::Timer(tok) if tok == token => {
134                    let deadline = *last_move + wait_duration;
135                    ctx.set_handled();
136                    if deadline > now {
137                        let wait_for = deadline - now;
138                        tracing::info!("Waiting another {:?}", wait_for);
139                        Some(TooltipState::Waiting {
140                            last_move: *last_move,
141                            timer_expire: deadline,
142                            token: ctx.request_timer(wait_for),
143                            position_in_window_coordinates: *position_in_window_coordinates,
144                        })
145                    } else {
146                        let tooltip_position_in_window_coordinates =
147                            (position_in_window_coordinates.to_vec2() + cursor_size.to_vec2())
148                                .to_point();
149                        let win_id = ctx.new_sub_window(
150                            WindowConfig::default()
151                                .show_titlebar(false)
152                                .window_size_policy(WindowSizePolicy::Content)
153                                .set_level(WindowLevel::Tooltip(ctx.window().clone()))
154                                .set_position(tooltip_position_in_window_coordinates),
155                            Label::<()>::new(self.tip.clone()),
156                            (),
157                            env.clone(),
158                        );
159                        Some(TooltipState::Showing(win_id))
160                    }
161                }
162                _ => None,
163            },
164            TooltipState::Showing(win_id) => {
165                match event {
166                    Event::MouseMove(me) if !ctx.is_hot() => {
167                        // TODO another timer on leaving
168                        tracing::info!("Sending close window for {:?}", win_id);
169                        ctx.submit_command(CLOSE_WINDOW.to(*win_id));
170                        Some(TooltipState::Waiting {
171                            last_move: now,
172                            timer_expire: now + wait_duration,
173                            token: ctx.request_timer(wait_duration),
174                            position_in_window_coordinates: me.window_pos,
175                        })
176                    }
177                    _ => None,
178                }
179            }
180        };
181
182        if let Some(state) = new_state {
183            self.state = state;
184        }
185
186        if !ctx.is_handled() {
187            child.event(ctx, event, data, env);
188        }
189    }

70    fn event(&mut self, ctx: &mut EventCtx, ev: &Event, data: &mut Vector<Circle>, _env: &Env) {
71        if let Event::MouseDown(ev) = ev {
72            if ev.mods.shift() {
73                data.push_back(Circle {
74                    pos: ev.pos,
75                    time: Instant::now(),
76                });
77            } else if ev.mods.ctrl() {
78                data.retain(|c| {
79                    if (c.pos - ev.pos).hypot() > RADIUS {
80                        true
81                    } else {
82                        ctx.request_paint_rect(kurbo::Circle::new(c.pos, RADIUS).bounding_box());
83                        false
84                    }
85                });
86            } else {
87                // Move the circle to a new location, invalidating the old locations. The new location
88                // will be invalidated during AnimFrame.
89                for c in data.iter() {
90                    ctx.request_paint_rect(kurbo::Circle::new(c.pos, RADIUS).bounding_box());
91                }
92                data.clear();
93                data.push_back(Circle {
94                    pos: ev.pos,
95                    time: Instant::now(),
96                });
97            }
98            ctx.request_anim_frame();
99        } else if let Event::AnimFrame(_) = ev {
100            for c in &*data {
101                ctx.request_paint_rect(kurbo::Circle::new(c.pos, RADIUS).bounding_box());
102            }
103            if !data.is_empty() {
104                ctx.request_anim_frame();
105            }
106        }
107    }