public static Window CreateWindow()
{
IntPtr hInstance = Process.GetCurrentProcess().Handle;
WindowConfiguration config = new WindowConfiguration();
Window window;
config.ClassName = Engine.ScriptingInterface.GetCvarValue <string>("w_className");
config.Title = Engine.ScriptingInterface.GetCvarValue <string>("w_title");
config.X = Engine.ScriptingInterface.GetCvarValue <int>("w_x");
config.Y = Engine.ScriptingInterface.GetCvarValue <int>("w_y");
config.Width = Engine.ScriptingInterface.GetCvarValue <int>("w_width");
config.Height = Engine.ScriptingInterface.GetCvarValue <int>("w_height");
config.Mode = Engine.ScriptingInterface.GetCvarValue <bool>("w_noBorder") ? WindowMode.NoBorder : WindowMode.Windowed;
try
{
window = Window.CreateWindow(hInstance, config);
window.Create();
}
catch (WindowException e)
{
throw new InitializeException("Failed to create window: {0}", e.Message);
}
return(window);
}
public void Setup(WindowConfiguration config)
{
this.WindowConfiguration = config;
this.WindowTitle = config.Title;
this.ShowFPS = config.ShowFPS;
Player.Setup(config.Player);
}
protected override async void OnStartup(StartupEventArgs e)
{
var assembly = typeof(App).Assembly;
var windowConfig = WindowConfiguration.CreateWithDefaultIcon(assembly, "Test UI");
var appConfig = new WpfAppConfiguration(assembly, windowConfig);
await AppStartService.StartAppAsync(appConfig);
}
private static void Window_Closing(object sender, System.ComponentModel.CancelEventArgs e)
{
if (e.Cancel)
{
return;
}
var window = sender as Window;
var view = window.Content as FrameworkElement;
var viewModel = view.DataContext as IViewModel;
if (WindowConfiguration.GetIsWindowPersistent(view))
{
PersistentWindowInformation.Save(window, viewModel.GetType());
}
if (viewModel is ICloseAwareViewModel closeAware)
{
e.Cancel = true;
Factory.Create <IDispatcher>().RunAsync(async() =>
{
if (await closeAware.CanClose())
{
window.Closing -= Window_Closing;
window.Closing += (s, args) => e.Cancel |= !Close(window);
window.Close();
}
});
}
else
{
e.Cancel |= !Close(window);
}
}
public CocoaWindow(WindowConfiguration config, WebviewBridge bridge)
{
if (config == null)
{
throw new ArgumentNullException(nameof(config));
}
if (bridge == null)
{
throw new ArgumentNullException(nameof(bridge));
}
Handle = AppKit.Call("NSWindow", "alloc");
canResizeField = config.CanResize;
var style = GetWantedStyleMask();
ObjC.SendMessage(
Handle,
ObjC.RegisterName("initWithContentRect:styleMask:backing:defer:"),
new CGRect(0, 0, config.Size.Width, config.Size.Height),
new UIntPtr((uint)style),
new UIntPtr(2),
false);
webview = new CocoaWebview(bridge);
ObjC.Call(Handle, "setContentView:", webview.Handle);
webview.TitleChanged += Webview_TitleChanged;
windowDelegate = WindowDelegateDefinition.CreateInstance(this);
ObjC.Call(Handle, "setDelegate:", windowDelegate.Handle);
}
private void LightWindow_SourceInitialized(object sender, EventArgs e)
{
this.hwnd = this.GetWindowHandle();
this.hwndSource = HwndSource.FromHwnd(this.hwnd);
this.hwndSource.AddHook(this.WindowProc);
this.border = this.Template.FindName("border", this) as Border;
this.title = this.Template.FindName("title", this) as TextBlock;
this.icon = this.Template.FindName("icon", this) as Image;
this.minimizeButton = this.Template.FindName("MinimizeButton", this) as Button;
this.maximizeButton = this.Template.FindName("MaximizeButton", this) as Button;
this.restoreButton = this.Template.FindName("RestoreButton", this) as Button;
this.closeButton = this.Template.FindName("CloseButton", this) as Button;
this.SetWindowStateDependentEffects();
if (this.icon != null)
{
this.icon.Effect = new GrayscaleEffect {
DesaturationFactor = 1.0
}
}
;
if (WindowConfiguration.GetWindowStyle(this) == WindowStyle.None)
{
this.icon.IsNotNull(x => x.Visibility = Visibility.Collapsed);
this.title.IsNotNull(x => x.Visibility = Visibility.Collapsed);
}
//Win32Api.AddShadow(this, hwnd);
}
static ProgramOptions()
{
document = new Document();
language = AppLanguage.English;
vocabulary = new Vocabulary();
windowConfiguration = new WindowConfiguration();
}
public CocoaWebview(WindowConfiguration config, IContentProvider contentProvider, WebviewBridge bridge)
{
this.config = config ?? throw new ArgumentNullException(nameof(config));
this.contentProvider = contentProvider ?? throw new ArgumentNullException(nameof(contentProvider));
this.bridge = bridge ?? throw new ArgumentNullException(nameof(bridge));
Interlocked.Increment(ref count);
// need to keep the delegates around or they will get garbage collected
loadDelegate = LoadCallback;
loadFailedDelegate = LoadFailedCallback;
observedValueChangedDelegate = ObservedValueChanged;
scriptDelegate = ScriptCallback;
uriSchemeStartDelegate = UriSchemeStartCallback;
uriSchemeStopDelegate = UriSchemeStopCallback;
IntPtr configuration = WebKit.Call("WKWebViewConfiguration", "new");
IntPtr manager = ObjC.Call(configuration, "userContentController");
IntPtr callbackClass = CreateCallbackClass();
customHost = CreateSchemeHandler(configuration);
if (config.EnableScriptInterface)
{
ObjC.Call(manager, "addScriptMessageHandler:name:", callbackClass, NSString.Create("external"));
IntPtr script = WebKit.Call("WKUserScript", "alloc");
ObjC.Call(
script,
"initWithSource:injectionTime:forMainFrameOnly:",
NSString.Create(Resources.GetInitScript("Mac")),
IntPtr.Zero,
IntPtr.Zero);
ObjC.Call(manager, "addUserScript:", script);
}
Handle = WebKit.Call("WKWebView", "alloc");
ObjC.Call(Handle, "initWithFrame:configuration:", CGRect.Zero, configuration);
ObjC.Call(Handle, "setNavigationDelegate:", callbackClass);
IntPtr bgColor = NSColor.FromHex(config.BackgroundColor);
ObjC.Call(Handle, "setBackgroundColor:", bgColor);
IntPtr boolValue = Foundation.Call("NSNumber", "numberWithBool:", 0);
ObjC.Call(Handle, "setValue:forKey:", boolValue, NSString.Create("drawsBackground"));
if (config.UseBrowserTitle)
{
ObjC.Call(Handle, "addObserver:forKeyPath:options:context:", callbackClass, NSString.Create("title"), IntPtr.Zero, IntPtr.Zero);
}
if (enableDevTools)
{
var preferences = ObjC.Call(configuration, "preferences");
ObjC.Call(preferences, "setValue:forKey:", new IntPtr(1), NSString.Create("developerExtrasEnabled"));
}
}
#pragma warning disable VSTHRD100 // Avoid async void methods
protected override async void OnStartup(StartupEventArgs e)
#pragma warning restore VSTHRD100 // Avoid async void methods
{
var assembly = typeof(App).Assembly;
var windowConfig = WindowConfiguration.CreateWithDefaultIcon(assembly, "Website Download System");
var appConfig = new WpfAppConfiguration(assembly, windowConfig);
await AppStartService.StartAppAsync(appConfig);
}
public CocoaWindow(WindowConfiguration config, IUiFactory windowFactory)
{
if (windowFactory == null)
{
throw new ArgumentNullException(nameof(windowFactory));
}
this.config = config ?? throw new ArgumentNullException(nameof(config));
Interlocked.Increment(ref count);
// need to keep the delegates around or they will get garbage collected
windowShouldCloseDelegate = WindowShouldCloseCallback;
windowWillCloseDelegate = WindowWillCloseCallback;
Handle = AppKit.Call("NSWindow", "alloc");
var style = NSWindowStyleMask.Titled | NSWindowStyleMask.Closable | NSWindowStyleMask.Miniaturizable;
if (config.CanResize)
{
style |= NSWindowStyleMask.Resizable;
}
ObjC.SendMessage(
Handle,
ObjC.RegisterName("initWithContentRect:styleMask:backing:defer:"),
new CGRect(0, 0, config.Width, config.Height),
(int)style,
2,
0);
Title = config.Title;
IntPtr bgColor = NSColor.FromHex(config.BackgroundColor);
ObjC.Call(Handle, "setBackgroundColor:", bgColor);
var contentProvider = new EmbeddedFileProvider(config.ContentAssembly, config.ContentFolder);
bridge = new WebviewBridge();
webview = new CocoaWebview(config, contentProvider, bridge);
ObjC.Call(Handle, "setContentView:", webview.Handle);
if (config.EnableScriptInterface)
{
bridge.Init(this, webview, windowFactory);
}
if (config.UseBrowserTitle)
{
webview.TitleChanged += Webview_TitleChanged;
bridge.TitleChanged += Webview_TitleChanged;
}
SetWindowDelegate(Handle);
}
public WinFormsWindow(WindowConfiguration config, IUiFactory windowFactory)
{
if (windowFactory == null)
{
throw new ArgumentNullException(nameof(windowFactory));
}
this.config = config ?? throw new ArgumentNullException(nameof(config));
bridge = new WebviewBridge();
var contentProvider = new EmbeddedFileProvider(config.ContentAssembly, config.ContentFolder);
if (!config.ForceWindowsLegacyWebview && IsEdgeAvailable())
{
webview = new WinFormsWebview(config, contentProvider, bridge);
}
else
{
string hostAddress;
if (string.IsNullOrWhiteSpace(config.ExternalHost))
{
server = new ContentServer(contentProvider);
server.Start();
hostAddress = server.HostAddress;
}
else
{
hostAddress = config.ExternalHost;
}
webview = new WinFormsLegacyWebview(config, hostAddress, bridge);
}
webview.Control.Location = new Point(0, 0);
webview.Control.Dock = DockStyle.Fill;
Controls.Add(webview.Control);
Text = config.Title;
Width = config.Width;
Height = config.Height;
CanResize = config.CanResize;
ColorTools.ParseHex(config.BackgroundColor, out byte r, out byte g, out byte b);
BackColor = Color.FromArgb(r, g, b);
if (config.EnableScriptInterface)
{
bridge.Init(this, webview, windowFactory);
}
if (config.UseBrowserTitle)
{
bridge.TitleChanged += Webview_TitleChanged;
}
SetIcon(config.Icon);
}
public static void Store(WindowConfiguration config)
{
Properties.Settings.Default.Left = config.Left;
Properties.Settings.Default.Top = config.Top;
Properties.Settings.Default.Width= config.Width;
Properties.Settings.Default.Height = config.Height;
Properties.Settings.Default.IsMaximized = config.State == WindowState.Maximized;
Properties.Settings.Default.IsMinimized = config.State == WindowState.Minimized;
Properties.Settings.Default.Save();
}
public GtkWindow(WindowConfiguration config, IUiFactory windowFactory)
{
if (windowFactory == null)
{
throw new ArgumentNullException(nameof(windowFactory));
}
this.config = config ?? throw new ArgumentNullException(nameof(config));
var contentProvider = new EmbeddedFileProvider(config.ContentAssembly, config.ContentFolder);
bridge = new WebviewBridge();
webview = new GtkWebview(config, contentProvider, bridge);
Handle = Gtk.Window.Create(GtkWindowType.Toplevel);
Title = config.Title;
Gtk.Window.SetResizable(Handle, config.CanResize);
Gtk.Window.SetDefaultSize(Handle, config.Width, config.Height);
string backgroundColor = config.BackgroundColor;
if (string.IsNullOrWhiteSpace(backgroundColor))
{
backgroundColor = "#FFFFFF";
}
SetBackgroundColor(backgroundColor);
IntPtr scroller = Gtk.Window.CreateScrolled(IntPtr.Zero, IntPtr.Zero);
Gtk.Widget.ContainerAdd(Handle, scroller);
Gtk.Widget.ContainerAdd(scroller, webview.Handle);
// need to keep the delegates around or they will get garbage collected
deleteDelegate = DeleteCallback;
destroyDelegate = DestroyCallback;
GLib.ConnectSignal(Handle, "delete-event", deleteDelegate, IntPtr.Zero);
GLib.ConnectSignal(Handle, "destroy", destroyDelegate, IntPtr.Zero);
webview.CloseRequested += Webview_CloseRequested;
if (config.EnableScriptInterface)
{
bridge.Init(this, webview, windowFactory);
}
if (config.UseBrowserTitle)
{
webview.TitleChanged += Webview_TitleChanged;
bridge.TitleChanged += Webview_TitleChanged;
}
SetIcon(config.Icon);
}
public void Initialise(WindowConfiguration configuration)
{
Configuration = new SystemConfiguration(configuration);
InitialiseWindows(configuration.Title);
Window = new Window();
Window.Initialise(configuration.Size, _renderForm.Handle);
_timer = new Timer();
_timer.Initialise();
}
public TimeService(ILogger <TimeService> logger, NtpConfiguration ntpConfiguration,
WindowConfiguration windowConfiguration, DateAndTimeFormat dateAndTimeFormat,
ApplicationConfiguration applicationConfiguration, IStopwatchService stopwatchService, INicService nicService)
{
_logger = logger;
_ntpConfiguration = ntpConfiguration;
_windowConfiguration = windowConfiguration;
_dateAndTimeFormat = dateAndTimeFormat;
_applicationConfiguration = applicationConfiguration;
_stopwatchService = stopwatchService;
_nicService = nicService;
}
public async Task <IWindow> CreateWindow(string windowXaml)
{
var request = new WindowConfiguration()
{
Xaml = windowXaml,
FitToScreen = true
};
LogMessage?.Invoke($"{nameof(IApp)}.{nameof(CreateWindow)}(...)");
if (await Client.CreateWindowAsync(request) is { } reply)
{
if (LogMessage is { })
public GameInitializor()
{
windowConfiguration = new WindowConfiguration()
{
Height = 30,
Width = 90
};
this.projectSettings = new ProjectSettings(windowConfiguration);
this.mainMenu = new MainMenu();
this.combatScreen = new CombatScreen();
this.controls = new Controls();
}
void Awake()
{
if (imageBox == null)
{
imageBox = FindObjectOfType <RawImage>();
}
if (window == null)
{
window = FindObjectOfType <WindowConfiguration>();
}
UpdateConfiguration();
}
public static void Main(string[] args)
{
// Note: Program.cs is shared between all projects for convenience.
// You could just as well have a separate startup logic for each platform.
// this creates a new app configuration with default values
var config = new WindowConfiguration();
// this relates to the path defined in the shared .proj file
config.ContentFolder = "App";
// runs the application and opens a window with the given page loaded
Application.Run(config, "index.html");
}
public WinFormsWebview(WindowConfiguration config, IContentProvider contentProvider, WebviewBridge bridge)
{
if (contentProvider == null)
{
throw new ArgumentNullException(nameof(contentProvider));
}
this.config = config ?? throw new ArgumentNullException(nameof(config));
this.bridge = bridge ?? throw new ArgumentNullException(nameof(bridge));
streamResolver = new EdgeUriToStreamResolver(contentProvider);
Layout += (s, e) => UpdateSize();
Init();
}
protected override void Configure()
{
if (_container == null) //iOC Registration
{
_container = new WinRTContainer();
}
_container.RegisterWinRTServices();
//Register all internal services
RegisterInternalServices.RegisterViewModels(ref _container);
RegisterInternalServices.RegisterSqliteEncryption(ref _container); //Enable Encryption on the Sqlite Storage
Subscriptions();
//UI Configuration
WindowConfiguration.ConfigureApplicationShell();
}
public BaseDialog(PlaylistSource queue, string title, WindowConfiguration windowConfig) : base(title)
{
this.queue = queue;
VBox.Spacing = 6;
HBox filter_box = new HBox();
filter_box.Spacing = 6;
Label search_label = new Label("_Search:");
filter_box.PackStart(search_label, false, false, 0);
search_entry = new MuinsheeSearchEntry();
search_entry.Show();
search_entry.Changed += OnFilterChanged;
search_entry.Ready = true;
OnFilterChanged(null, null);
filter_box.PackStart(search_entry, true, true, 0);
VBox.PackStart(filter_box, false, false, 0);
Hyena.Widgets.ScrolledWindow sw = new Hyena.Widgets.ScrolledWindow();
sw.Add(GetItemWidget());
VBox.PackStart(sw, true, true, 0);
AddDefaultCloseButton();
Button queue_button = new ImageButton(Catalog.GetString("En_queue"), "gtk-add");
AddActionWidget(queue_button, Gtk.ResponseType.Apply);
Button play_button = new ImageButton(Catalog.GetString("_Play"), "media-playback-start");
AddButton(play_button, Gtk.ResponseType.Ok, true);
window_controller = new PersistentWindowController(this, windowConfig, WindowPersistOptions.Size);
window_controller.Restore();
ShowAll();
Response += OnResponse;
}
/// <summary> "Configuration..." menu item </summary>
private void menuItemConfigurationOnClick(object sender, EventArgs eventArgs)
{
foreach (Window window in Application.Current.Windows)
{
if (window is WindowConfiguration)
{
window.Activate();
return;
}
}
var win = new WindowConfiguration();
win.OnCloseWindowSettings += saved =>
{
DataManager.OpenConfiguration();
setWindowVisibilityBehaviour(saved && !_listWindowIsShown);
};
win.Show();
}
public static void Main(string[] args)
{
// Note: Program.cs is shared between all projects for convenience.
// You could just as well have a separate startup logic for each platform.
// this creates a new configuration with default values
var config = new WindowConfiguration();
var icon = AppIcon.FromFile("icon", "Icons");
// we have a separate assembly for the client side files
config.ContentAssembly = typeof(DummyMarker).Assembly;
// this relates to the path defined in the client .csproj file
config.ContentFolder = "Angular\\dist";
config.Icon = icon;
// this is only called in Debug mode:
SetDevServer(config);
// runs the application and opens a window with the given page loaded
Application.Run(config, "index.html");
}
public static WindowConfiguration Restore()
{
var config = new WindowConfiguration
{
Left = Properties.Settings.Default.Left,
Top = Properties.Settings.Default.Top,
Width = Properties.Settings.Default.Width,
Height = Properties.Settings.Default.Height,
};
if (Properties.Settings.Default.IsMaximized)
config.State = WindowState.Maximized;
else if (Properties.Settings.Default.IsMinimized)
config.State = WindowState.Minimized;
else
config.State = WindowState.Normal;
if (config.Width == 0 || config.Height == 0)
return null;
return config;
}
public WinFormsLegacyWebview(WindowConfiguration config, string hostAddress, WebviewBridge scriptingApi)
{
if (scriptingApi == null)
{
throw new ArgumentNullException(nameof(scriptingApi));
}
this.config = config ?? throw new ArgumentNullException(nameof(config));
this.hostAddress = hostAddress ?? throw new ArgumentNullException(nameof(hostAddress));
webview = new WebBrowser();
webview.IsWebBrowserContextMenuEnabled = false;
if (config.EnableScriptInterface)
{
scriptInterface = new ScriptInterface(scriptingApi);
webview.ObjectForScripting = scriptInterface;
}
webview.DocumentCompleted += Webview_DocumentCompleted;
}
public ApplicationService(ILogger <ApplicationService> logger, ITimeService timeService,
IWindowService windowService, DateAndTimeFormat dateAndTimeFormat, WindowConfiguration windowConfiguration,
ApplicationConfiguration applicationConfiguration, IStopwatchService stopwatchService, IHostApplicationLifetime hostApplicationLifetime,
IStorageService storageService, INicService nicService, IInternetService internetService)
{
_logger = logger;
_timeService = timeService;
_windowService = windowService;
_dateAndTimeFormat = dateAndTimeFormat;
_windowConfiguration = windowConfiguration;
_applicationConfiguration = applicationConfiguration;
_stopwatchService = stopwatchService;
_hostApplicationLifetime = hostApplicationLifetime;
_storageService = storageService;
_nicService = nicService;
_internetService = internetService;
_internetService.InternetConnectionAvailable += _internetService_InternetConnectionAvailable;
_hostApplicationLifetime.ApplicationStopping.Register(() =>
{
if (_applicationConfiguration.CountSystemRunningTime)
{
_stopwatchService.StopTimer();
}
if (_applicationConfiguration.CountNetworkActivity)
{
_nicService.StopNicsMonitoring();
}
_storageService.EditData();
_logger.LogDebug("Shutting down application");
_logger.LogDebug(new string('-', 100));
});
}
public static void Load(Window window, WindowConfiguration settings)
{
if (!double.IsNaN(settings.Width))
{
window.Width = settings.Width;
}
if (!double.IsNaN(settings.Height))
{
window.Height = settings.Height;
}
if (!double.IsNaN(settings.X) && !double.IsNaN(settings.Y))
{
window.Position = new PixelPoint((int)settings.X, (int)settings.Y);
window.WindowStartupLocation = WindowStartupLocation.Manual;
}
else
{
window.WindowStartupLocation = WindowStartupLocation.CenterScreen;
}
window.WindowState = settings.WindowState;
}
public WindowService(ILogger <WindowService> logger, WindowConfiguration windowConfiguration)
{
_logger = logger;
_windowConfiguration = windowConfiguration;
}
internal ShellWindowConfiguration(WindowConfiguration configuration)
{
_configuration = configuration;
}
public DashmanWindow(WindowConfiguration windowConfig)
{
_windowConfig = windowConfig;
InitializeComponent();
}
private async Task <Window> CreateWindow <TResult>(Func <TResult, Task> callback1, Func <Task> callback2, FrameworkElement view, IViewModel viewModel)
{
var window = Common.CreateWindow(ref this.windowType);
window.BeginInit();
// Special stuff for splashscreens
if (viewModel is ApplicationBase)
{
window.Tag = SplashScreenWindowTag;
WindowConfiguration.SetHasOwner(view, false);
WindowConfiguration.SetSizeToContent(view, SizeToContent.WidthAndHeight);
WindowConfiguration.SetShowInTaskbar(view, false);
WindowConfiguration.SetWindowStartupLocation(view, WindowStartupLocation.CenterScreen);
WindowConfiguration.SetWindowStyle(view, WindowStyle.None);
WindowConfiguration.SetResizeMode(view, ResizeMode.NoResize);
WindowConfiguration.SetIcon(view, null);
WindowConfiguration.SetTitle(view, null);
}
// Add this new window to the dictionary
windows.Add(new WindowViewModelObject {
window = window, viewModelId = viewModel.Id
});
window.ResizeMode = WindowConfiguration.GetResizeMode(view);
window.WindowStyle = WindowConfiguration.GetWindowStyle(view);
window.Width = WindowConfiguration.GetWidth(view);
window.Height = WindowConfiguration.GetHeight(view);
window.MaxHeight = WindowConfiguration.GetMaxHeight(view);
window.MinHeight = WindowConfiguration.GetMinHeight(view);
window.MaxWidth = WindowConfiguration.GetMaxWidth(view);
window.MinWidth = WindowConfiguration.GetMinWidth(view);
window.ShowInTaskbar = WindowConfiguration.GetShowInTaskbar(view);
window.Topmost = WindowConfiguration.GetTopmost(view);
window.WindowStartupLocation = WindowConfiguration.GetWindowStartupLocation(view);
window.WindowState = WindowConfiguration.GetWindowState(view);
window.SizeToContent = WindowConfiguration.GetSizeToContent(view);
// Add the inputbindings to the window we have to recreate the binding here because the
// sources are all wrong
foreach (InputBinding inputBinding in view.InputBindings)
{
var oldBinding = BindingOperations.GetBinding(inputBinding, InputBinding.CommandProperty);
var newBinding = oldBinding.Clone();
newBinding.Source = viewModel;
BindingOperations.ClearBinding(inputBinding, InputBinding.CommandProperty);
BindingOperations.SetBinding(inputBinding, InputBinding.CommandProperty, newBinding);
window.InputBindings.Add(inputBinding);
}
// remove them from the view
view.InputBindings.Clear();
if (WindowConfiguration.GetIsWindowPersistent(view))
{
PersistentWindowInformation.Load(window, viewModel.GetType());
}
// set the window owner
if (window.Tag != SplashScreenWindowTag && WindowConfiguration.GetHasOwner(view) && Application.Current.MainWindow.Tag != SplashScreenWindowTag)
{
windows.FirstOrDefault(x => x.window.IsActive).IsNotNull(x => window.Owner = x?.window);
}
//if (Application.Current.MainWindow != null && Application.Current.MainWindow.Tag == SplashScreenWindowTag)
// Application.Current.MainWindow = window;
window.SetBinding(Window.IconProperty, new Binding {
Path = new PropertyPath(WindowConfiguration.IconProperty), Source = view
});
window.SetBinding(Window.TitleProperty, new Binding {
Path = new PropertyPath(WindowConfiguration.TitleProperty), Source = view
});
if (window.Icon == null && window.Tag != SplashScreenWindowTag)
{
window.Icon = await UnsafeNative.ExtractAssociatedIcon(Assembly.GetEntryAssembly().Location).ToBitmapImageAsync();
}
if (viewModel is IFrameAware frameAware)
{
window.Activated += (s, e) => frameAware.Activated();
window.Deactivated += (s, e) => frameAware.Deactivated();
}
if (viewModel is ISizeAware sizeAware)
{
window.SizeChanged += (s, e) => sizeAware.SizeChanged(e.NewSize.Width, e.NewSize.Height);
}
window.SizeChanged += (s, e) =>
{
if (window.WindowState == WindowState.Normal)
{
PersistentWindowProperties.SetHeight(window, e.NewSize.Height);
PersistentWindowProperties.SetWidth(window, e.NewSize.Width);
}
};
window.Closing += Window_Closing;
window.Closed += (s, e) =>
{
windows.Remove(x => x.window == s);
if (callback1 != null)
{
(viewModel as IDialogViewModel <TResult>).IsNotNull(async x => await callback1(x.Result));
}
if (callback2 != null)
{
(viewModel as IDialogViewModel).IsNotNull(async x => await callback2());
}
window.Content.As <FrameworkElement>()?.DataContext.TryDispose();
window.Content.TryDispose();
window.Content = null;
window.TryDispose(); // some custom windows have implemented the IDisposable interface
};
// make sure the datacontext of the window is correct
view.DataContextChanged += (s, e) => window.DataContext = view.DataContext;
window.Content = view;
view.DataContext = viewModel;
if (viewModel is IViewAware viewAwareViewModel)
{
viewAwareViewModel.OnAssignToDataContext(window.InputBindings);
}
Common.AddTransistionStoryboard(view);
window.EndInit();
return(window);
}
private async Task <Tuple <Window, bool> > CreateDefaultWindow <TResult>(Func <TResult, Task> callback1, Func <Task> callback2, FrameworkElement view, IViewModel viewModel) => new Tuple <Window, bool>(await this.CreateWindow(callback1, callback2, view, viewModel), WindowConfiguration.GetIsModal(view));
static Config()
{
Window = new WindowConfiguration();
Injection = new InjectionConfiguration();
}
public WindowConfigurationNodeFactory(WindowConfiguration windowConfiguration)
{
_windowConfiguration = windowConfiguration;
}
