Hello Paul,

The key thing here is that the window itself can never toggle the Visible field to true, so it could not possibly raise an event.

From a framework perspective - all that initialization belongs in the view model that hosts all components - the window, its content, the component that shows the window. What is the method that does that initialization and when is called depends on the view-model logic - for example a lifecycle method (such as OnParametersSet), a specific custom event (such as a button click) - the key thing being that this is outside of the Window component.

The way I would handle the described scenario is:

• a component in the window content will house all that logic
• it will use OnParametersSetAsync to fetch the data on demand (that's the initialization logic)
• it will receive a parameter with the original edit model
• it will store a copy of that model (e.g., through OnInitialized) for the Reset functionality - this can be an internal property of its own view-model, the parent does not need to know about it
• if necessary, it will expose an event like MyModelChanged<MyModel> that will fire upon save click - this cal let you handle an event or even use two-way binding at the parent level

This satisfies all the needs:

• initialization on demand
• encapsulating the logic into one place
• providing an event and even two-way binding to the parent

That said, when animations get implemented, they will probably be invoked through calling a method on the window instance, and that can probably allow for events. Here's the page where you can follow the animations implementation and I also added a note about a potential event there: https://feedback.telerik.com/blazor/1462921-animation-for-window

Regards,
Marin Bratanov
Progress Telerik

Hi Paul,

To make the window visible, you always need to toggle the variable that controls that, so the place to raise up necessary info is that particular piece of code. I am not sure I follow how copying the application code from one place to another will make the Window component better - in all cases you'd probably put all the logic in a method that you will call when needed.

Another approach you can consider is using the OnParametersSetAsync event of a component that you put in the window - that's the common way to load data on demand in Blazor. Here's a mockup of that:

<TelerikWindow @bind-Visible="@isWndVisible">
    <WindowContent>
        <MyWindowContentComponent ParentTime="@DateTime.Now" />
    </WindowContent>
    <WindowTitle>Load on demand example</WindowTitle>
</TelerikWindow>

<TelerikButton OnClick="@( () => isWndVisible = !isWndVisible )">Toggle the window</TelerikButton>

@code{
    bool isWndVisible { get; set; }
}

and in the MyWindowContentComponent component:

@* of course, this is a bit simplistic but I trust it showcases the concept *@

@if (string.IsNullOrEmpty(dataLoadedOnDemand))
{
    <div>please wait...loading data</div>
}
else
{
    <div>
        The time at which the parent initialized this component is:
        @ParentTime.Millisecond

        <br />

        New data loaded when the window was made visible:
        @dataLoadedOnDemand
    </div>
}

@code {
    [Parameter] public DateTime ParentTime { get; set; }

    string dataLoadedOnDemand { get; set; }

    protected override async Task OnParametersSetAsync()
    {
        await Task.Delay(500); // simulate database operation
        dataLoadedOnDemand = DateTime.Now.Millisecond.ToString();
    }
}

For closing, we already have an event - VisibleChanged: https://docs.telerik.com/blazor-ui/components/window/events#visiblechanged

With that in mind, would you need a specific event for showing the window, considering that the VIsible parameter uses two-way binding and the corresponding <Parameter>Changed event already fires when the Window changes the visibility through its built-in [x] button (not included in the sample above), and the Window itself does not have a facility to show itself, so it is up to the app to toggle the flag to true?

Looking forward to your thoughts.

Regards,
Marin Bratanov
Progress Telerik