Managing the lifetime of a callbacks passed in to egui UI functions

[barries]

Update: I found the solution: give references have different--and thus, allowed to be shorter--lifetimes than their referencees. I've update the code below to have the additional explicit lifetimes.

We're using egui in an MVVM app's View. I'd like to pass in a callback for our widgets to propagate user responses to the ViewModel. However, we're getting a lifetime issue (error below).

Is there a pattern egui users use to implement callbacks like this, or am "just" overlooking some obvious-to-the-more-experienced way of finessing the lifetimes to let rustc know that the borrow in question has a short enough lifetime after being passed down through the structs and method calls of our methods and widgets?

Many thanks!!!

Very cut-down code sketch:

In view.rs:

struct ViewUpdateContext<'a> {                            
    handle_event: RefCell<Box<dyn FnMut(Event) + 'a>>,
    ...
}                                                         
                                                          
impl<'a> ViewUpdateContext<'a> {                          
    fn handle_event(&self, event: Event) {            
        (*self.handle_event.borrow_mut())(event);         
    }                                                     
}                                                         

...

impl View {
    ...

    fn build_main_ui<'c, 'vuc>(&mut self, ui: &mut egui::Ui, c: &'c ViewUpdateContext<'vuc>) { 
        if ... {
            icon(ui, c, Event::StartClicked, ...);                  
        }                                                                              
    }                                                                                  

    pub fn update(&mut self, ctx: &egui::Context, vm: ViewModel, handle_event: Box<dyn FnMut(Event) + '_>)  {
        let c = ViewUpdateContext {                                                                              
            handle_event: RefCell::new(handle_event),                                                            
            ...
        };                                                                                                       
                                                                                                                 
        egui::CentralPanel::default()                                                                            
            .show(ctx, |ui| {                                                                                    
                self.build_main_ui(ui, &c);                                                                      
            }).inner;
    }                                                                                                            
}

In view/icon.rs:

pub struct Icon<'refs, 'vuc> {
    c:    &'refs ViewUpdateContext<'vuc>,
    ...
}

pub fn icon<'args, 'vuc>(
    ui:    &mut egui::Ui,
    c:     &'args ViewUpdateContext<'vuc>,
    event: Event,
    ...
) {
    if ui.add_enabled(
        ...,
        Icon {
            c:    c,
            ...
        }
    ).clicked() {
        c.handle_event(event);
    }
}

Error:

180 |         let c = ViewUpdateContext {
    |             - binding `c` declared here
...
188 |             .show(ctx, |ui| {
    |                        ---- value captured here
189 |                 self.build_main_ui(ui, &c);
    |                                         ^ borrowed value does not live long enough
190 |             }).inner;
191 |     }
    |     -
    |     |
    |     `c` dropped here while still borrowed
    |     borrow might be used here, when `c` is dropped and runs the destructor for type `ViewUpdateContext<'_>`