refactor of the foundational code per the updated spec

examples/multi_window_ref_app/lib/app/main_window.dart

@@ -1,32 +1,27 @@
 import 'package:flutter/material.dart';
+import 'package:multi_window_ref_app/app/window_controller_render.dart';
 
-import 'regular_window.dart';
 import 'window_settings.dart';
 import 'window_settings_dialog.dart';
+import 'window_manager_model.dart';
 
 class MainWindow extends StatefulWidget {
-  const MainWindow({super.key});
+  MainWindow({super.key, required WindowController mainController}) {
+    _windowManagerModel.add(
+        KeyedWindowController(isMainWindow: true, controller: mainController));
+  }
+
+  final WindowManagerModel _windowManagerModel = WindowManagerModel();
+  final WindowSettings _settings = WindowSettings();
 
   @override
   State<MainWindow> createState() => _MainWindowState();
 }
 
 class _MainWindowState extends State<MainWindow> {
-  int selectedRowIndex = -1;
-  final List<Window> _managedWindows = <Window>[];
-
   @override
   Widget build(BuildContext context) {
-    List<Window> getWindowsInTree(List<Window> windows) {
-      return windows
-          .expand((window) => [window, ...getWindowsInTree(window.children)])
-          .toList();
-    }
-
-    final List<Window> windows =
-        getWindowsInTree(MultiWindowAppContext.of(context)!.windows);
-
-    final widget = Scaffold(
+    final child = Scaffold(
       appBar: AppBar(
         title: const Text('Multi Window Reference App'),
       ),
@@ -38,162 +33,166 @@ class _MainWindowState extends State<MainWindow> {
             child: SingleChildScrollView(
               scrollDirection: Axis.vertical,
               child: _ActiveWindowsTable(
-                windows: windows,
-                selectedRowIndex: selectedRowIndex,
-                onSelectedRowIndexChanged: (int index) =>
-                    setState(() => selectedRowIndex = index),
-              ),
+                  windowManagerModel: widget._windowManagerModel),
             ),
           ),
           Expanded(
             flex: 40,
             child: Column(
               crossAxisAlignment: CrossAxisAlignment.stretch,
               children: [
-                _WindowCreatorCard(
-                    selectedWindow: selectedRowIndex < 0 ||
-                            selectedRowIndex >= windows.length
-                        ? null
-                        : windows[selectedRowIndex],
-                    onDialogOpened: (window) => _managedWindows.add(window),
-                    onDialogClosed: (window) => _managedWindows.remove(window)),
+                ListenableBuilder(
+                    listenable: widget._windowManagerModel,
+                    builder: (BuildContext context, Widget? child) {
+                      return _WindowCreatorCard(
+                          selectedWindow: widget._windowManagerModel.selected,
+                          windowManagerModel: widget._windowManagerModel,
+                          windowSettings: widget._settings);
+                    })
               ],
             ),
           ),
         ],
       ),
     );
 
-    final window = WindowContext.of(context)!.window;
-    final List<Widget> childViews = <Widget>[];
-    for (final Window childWindow in window.children) {
-      if (!_shouldRenderWindow(childWindow)) {
-        continue;
-      }
-
-      childViews.add(View(
-        view: childWindow.view,
-        child: WindowContext(
-          window: childWindow,
-          child: childWindow.builder(context),
-        ),
-      ));
-    }
-
-    return ViewAnchor(view: ViewCollection(views: childViews), child: widget);
-  }
-
-  bool _shouldRenderWindow(Window window) {
-    return !_managedWindows.contains(window);
+    return ViewAnchor(
+        view: ListenableBuilder(
+            listenable: widget._windowManagerModel,
+            builder: (BuildContext context, Widget? _) {
+              final List<Widget> childViews = <Widget>[];
+              for (final KeyedWindowController controller
+                  in widget._windowManagerModel.windows) {
+                if (controller.parent == null && !controller.isMainWindow) {
+                  childViews.add(WindowControllerRender(
+                    controller: controller.controller,
+                    key: controller.key,
+                    windowSettings: widget._settings,
+                    windowManagerModel: widget._windowManagerModel,
+                    onDestroyed: () =>
+                        widget._windowManagerModel.remove(controller),
+                    onError: () =>
+                        widget._windowManagerModel.remove(controller),
+                  ));
+                }
+              }
+
+              return ViewCollection(views: childViews);
+            }),
+        child: child);
   }
 }
 
 class _ActiveWindowsTable extends StatelessWidget {
-  const _ActiveWindowsTable(
-      {required this.windows,
-      required this.selectedRowIndex,
-      required this.onSelectedRowIndexChanged});
+  const _ActiveWindowsTable({required this.windowManagerModel});
 
-  final List<Window> windows;
-  final int selectedRowIndex;
-  final void Function(int) onSelectedRowIndexChanged;
+  final WindowManagerModel windowManagerModel;
 
   @override
   Widget build(BuildContext context) {
-    return DataTable(
-      showBottomBorder: true,
-      onSelectAll: (selected) {
-        onSelectedRowIndexChanged(-1);
-      },
-      columns: const [
-        DataColumn(
-          label: SizedBox(
-            width: 20,
-            child: Text(
-              'ID',
-              style: TextStyle(
-                fontSize: 16,
+    return ListenableBuilder(
+        listenable: windowManagerModel,
+        builder: (BuildContext context, Widget? widget) {
+          return DataTable(
+            showBottomBorder: true,
+            onSelectAll: (selected) {
+              windowManagerModel.select(null);
+            },
+            columns: const [
+              DataColumn(
+                label: SizedBox(
+                  width: 20,
+                  child: Text(
+                    'ID',
+                    style: TextStyle(
+                      fontSize: 16,
+                    ),
+                  ),
+                ),
               ),
-            ),
-          ),
-        ),
-        DataColumn(
-          label: SizedBox(
-            width: 120,
-            child: Text(
-              'Type',
-              style: TextStyle(
-                fontSize: 16,
+              DataColumn(
+                label: SizedBox(
+                  width: 120,
+                  child: Text(
+                    'Type',
+                    style: TextStyle(
+                      fontSize: 16,
+                    ),
+                  ),
+                ),
               ),
-            ),
-          ),
-        ),
-        DataColumn(
-            label: SizedBox(
-              width: 20,
-              child: Text(''),
-            ),
-            numeric: true),
-      ],
-      rows: windows.asMap().entries.map<DataRow>((indexedEntry) {
-        final index = indexedEntry.key;
-        final Window entry = indexedEntry.value;
-        final window = entry;
-        final viewId = window.view.viewId;
-        final archetype = window.archetype;
-        final isSelected = selectedRowIndex == index;
-
-        return DataRow(
-          color: WidgetStateColor.resolveWith((states) {
-            if (states.contains(WidgetState.selected)) {
-              return Theme.of(context).colorScheme.primary.withOpacity(0.08);
-            }
-            return Colors.transparent;
-          }),
-          selected: isSelected,
-          onSelectChanged: (selected) {
-            if (selected != null) {
-              onSelectedRowIndexChanged(selected ? index : -1);
-            }
-          },
-          cells: [
-            DataCell(
-              Text('$viewId'),
-            ),
-            DataCell(
-              Text(archetype.toString().replaceFirst('WindowArchetype.', '')),
-            ),
-            DataCell(
-              IconButton(
-                icon: const Icon(Icons.delete_outlined),
-                onPressed: () {
-                  destroyWindow(context, window);
+              DataColumn(
+                  label: SizedBox(
+                    width: 20,
+                    child: Text(''),
+                  ),
+                  numeric: true),
+            ],
+            rows: (windowManagerModel.windows)
+                .map<DataRow>((KeyedWindowController controller) {
+              return DataRow(
+                key: controller.key,
+                color: WidgetStateColor.resolveWith((states) {
+                  if (states.contains(WidgetState.selected)) {
+                    return Theme.of(context)
+                        .colorScheme
+                        .primary
+                        .withAlpha(20);
+                  }
+                  return Colors.transparent;
+                }),
+                selected: controller.controller == windowManagerModel.selected,
+                onSelectChanged: (selected) {
+                  if (selected != null) {
+                    windowManagerModel.select(
+                        selected ? controller.controller.view?.viewId : null);
+                  }
                 },
-              ),
-            ),
-          ],
-        );
-      }).toList(),
-    );
+                cells: [
+                  DataCell(
+                    ListenableBuilder(
+                        listenable: controller.controller,
+                        builder: (BuildContext context, Widget? _) => Text(
+                            controller.controller.view != null
+                                ? '${controller.controller.view?.viewId}'
+                                : 'Loading...')),
+                  ),
+                  DataCell(
+                    ListenableBuilder(
+                        listenable: controller.controller,
+                        builder: (BuildContext context, Widget? _) => Text(
+                            controller.controller.type
+                                .toString()
+                                .replaceFirst('WindowArchetype.', ''))),
+                  ),
+                  DataCell(
+                    ListenableBuilder(
+                        listenable: controller.controller,
+                        builder: (BuildContext context, Widget? _) =>
+                            IconButton(
+                              icon: const Icon(Icons.delete_outlined),
+                              onPressed: () async {
+                                await controller.controller.destroy();
+                              },
+                            )),
+                  ),
+                ],
+              );
+            }).toList(),
+          );
+        });
   }
 }
 
-class _WindowCreatorCard extends StatefulWidget {
+class _WindowCreatorCard extends StatelessWidget {
   const _WindowCreatorCard(
       {required this.selectedWindow,
-      required this.onDialogOpened,
-      required this.onDialogClosed});
-
-  final Window? selectedWindow;
-  final void Function(Window) onDialogOpened;
-  final void Function(Window) onDialogClosed;
-
-  @override
-  State<StatefulWidget> createState() => _WindowCreatorCardState();
-}
+      required this.windowManagerModel,
+      required this.windowSettings});
 
-class _WindowCreatorCardState extends State<_WindowCreatorCard> {
-  WindowSettings _settings = WindowSettings();
+  final WindowController? selectedWindow;
+  final WindowManagerModel windowManagerModel;
+  final WindowSettings windowSettings;
 
   @override
   Widget build(BuildContext context) {
@@ -219,12 +218,8 @@ class _WindowCreatorCardState extends State<_WindowCreatorCard> {
               children: [
                 OutlinedButton(
                   onPressed: () async {
-                    await createRegular(
-                        context: context,
-                        size: _settings.regularSize,
-                        builder: (BuildContext context) {
-                          return const MaterialApp(home: RegularWindowContent());
-                        });
+                    windowManagerModel.add(KeyedWindowController(
+                        controller: RegularWindowController()));
                   },
                   child: const Text('Regular'),
                 ),
@@ -234,15 +229,7 @@ class _WindowCreatorCardState extends State<_WindowCreatorCard> {
                   child: TextButton(
                     child: const Text('SETTINGS'),
                     onPressed: () {
-                      windowSettingsDialog(context, _settings,
-                              widget.onDialogOpened, widget.onDialogClosed)
-                          .then(
-                        (WindowSettings? settings) {
-                          if (settings != null) {
-                            _settings = settings;
-                          }
-                        },
-                      );
+                      windowSettingsDialog(context, windowSettings);
                     },
                   ),
                 ),