public KStreamWindowAggregate(WindowOptions <W> windowOptions, string storeName, Initializer <Agg> initializer, Aggregator <K, V, Agg> aggregator) { WindowOptions = windowOptions; this.storeName = storeName; this.initializer = initializer; this.aggregator = aggregator; }
private void btnOptions_Click(object sender, RibbonControlEventArgs e) { using (var options = new WindowOptions(OutlookHelpers.GetDictionaryStores())) { options.ShowDialog(); } }
/// <summary> /// Create a new GlfwWindow. /// </summary> /// <param name="options">The options to use for this window.</param> public unsafe GlfwWindow(WindowOptions options, GlfwWindow parent, GlfwMonitor monitor) { // Title and Size must be set before the window is created. _title = options.Title; _size = options.Size; _windowBorder = WindowBorder; FramesPerSecond = options.FramesPerSecond; UpdatesPerSecond = options.UpdatesPerSecond; RunningSlowTolerance = options.RunningSlowTolerance; UseSingleThreadedWindow = options.UseSingleThreadedWindow; ShouldSwapAutomatically = options.ShouldSwapAutomatically; _initialOptions = options; _initialMonitor = monitor; Parent = (IWindowHost)parent ?? _initialMonitor; GlfwProvider.GLFW.Value.GetVersion(out var major, out var minor, out _); if (new Version(major, minor) < new Version(3, 3)) { throw new NotSupportedException("GLFW 3.3 or later is required for Silk.NET.Windowing.Desktop."); } }
public GlfwWindow(WindowOptions optionsCache, GlfwWindow?parent, GlfwMonitor?monitor) : base(optionsCache) { _glfw = GlfwProvider.GLFW.Value; _parent = parent; _initialMonitor = monitor; _localTitleCache = optionsCache.Title; }
public void OnCustomThemeButtonClick(object sender, RoutedEventArgs e) { string ButtonName = string.Empty; try { ButtonName = ((Button)sender).Name; if (ButtonName == "PART_CustomSsvButton") { Common.LogDebug(true, $"OnCustomThemeButtonClick()"); WindowOptions windowOptions = new WindowOptions { ShowMinimizeButton = false, ShowMaximizeButton = true, ShowCloseButton = true }; var ViewExtension = new SsvScreenshotsView(PluginDatabase.GameContext); Window windowExtension = PlayniteUiHelper.CreateExtensionWindow(PlayniteApi, resources.GetString("LOCSsvTitle"), ViewExtension, windowOptions); windowExtension.ResizeMode = ResizeMode.CanResize; windowExtension.ShowDialog(); } } catch (Exception ex) { Common.LogError(ex, false, true, PluginDatabase.PluginName); } }
public void Initialize(WindowOptions windowOptions) { this.Window.Show(windowOptions.InitialSize, windowOptions.Title); var rootWidget = (IWidget)this.ServiceProvider.GetRequiredService(windowOptions.RootWidgetType); this.Window.InitializeRootWidget(rootWidget); }
public Engine Build() { RegisterLogger(); _containerBuilder .Register(c => new GameWindow(WindowOptions.CreateWindowOptions())) .SingleInstance() .AsSelf(); // Input manager _containerBuilder.Register(c => new Input()) .SingleInstance() .AsSelf() .As <IPostUpdateSystem>(); // TODO: Remove this? _containerBuilder.Register(c => new EntityManager()) .SingleInstance() .AsSelf(); var engine = new Engine(); _containerBuilder.RegisterInstance(engine) .As <Engine>(); engine.Container = _containerBuilder.Build(); engine.Initialize(); return(engine); }
/// <summary> /// Creates a window and a graphics device with the given options. /// </summary> /// <param name="windowCI">The window options, used to create the window.</param> /// <param name="deviceOptions">The device options, used to create the graphics device.</param> /// <param name="window">The new window.</param> /// <param name="gd">The new graphics device.</param> public static void CreateWindowAndGraphicsDevice ( WindowOptions windowCI, GraphicsDeviceOptions deviceOptions, out IWindow window, out GraphicsDevice gd ) => CreateWindowAndGraphicsDevice(windowCI, deviceOptions, GetPlatformDefaultBackend(), out window, out gd);
/// <summary> /// Initializes a new instance of <see cref="DefaultConfiguration"/>. /// </summary> public DefaultConfiguration() { AppName = Assembly.GetEntryAssembly()?.GetName().Name ?? "Chromely App"; Platform = ChromelyRuntime.Platform; AppExeLocation = AppDomain.CurrentDomain.BaseDirectory; StartUrl = "local://app/index.html"; DebuggingMode = true; UrlSchemes = new List <UrlScheme>(); CefDownloadOptions = new CefDownloadOptions(); WindowOptions = new WindowOptions(); if (string.IsNullOrWhiteSpace(WindowOptions.Title)) { WindowOptions.Title = AppName; } // These are all default schemes. // They can be removed or replaced. UrlSchemes.AddRange(new List <UrlScheme>() { new UrlScheme(DefaultSchemeName.LOCALRESOURCE, "local", string.Empty, string.Empty, UrlSchemeType.LocalResource), new UrlScheme(DefaultSchemeName.LOCALREQUEST, "http", "chromely.com", string.Empty, UrlSchemeType.LocalRequest), new UrlScheme(DefaultSchemeName.OWIN, "http", "chromely.owin.com", string.Empty, UrlSchemeType.Owin), new UrlScheme(DefaultSchemeName.GITHUBSITE, string.Empty, string.Empty, "https://github.com/chromelyapps/Chromely", UrlSchemeType.ExternalBrowser, true) }); CustomSettings = new Dictionary <string, string>() { ["cefLogFile"] = "logs\\chromely.cef.log", ["logSeverity"] = "info", ["locale"] = "en-US" }; }
private void btn_Options_Click(object sender, RoutedEventArgs e) { this.Opacity = 0.4; this.Effect = new BlurEffect(); WindowOptions options = new WindowOptions() { Owner = Parent as Window, ShowInTaskbar = false }; options.ShowDialog(); this.Opacity = 1; this.Effect = null; if ((bool)Settings.Default["music"] == false) { player.Stop(); } else { player.Position = TimeSpan.Zero; player.Play(); } }
/// <summary> /// Creates a client window. /// </summary> public RootWindow(GraphicsDevice graphicsDevice, IWindowManager windowManager, string title, string titleGroup, WindowOptions windowOptions, Vector2i position, Vector2i size, Vector2i?minSize, Vector2i?maxSize, WindowState windowState, IWidget widget, uint multisampleCount, uint multisampleQuality) { // 1) Copy data. this.graphicsDevice = graphicsDevice; // 2) We create render target. TypelessTexture2D texture = new TypelessTexture2D(graphicsDevice, Usage.Default, TextureUsage.RenderTarget | TextureUsage.Texture, CPUAccess.None, PixelFormat.Parse("R.UN8 G.UN8 B.UN8 A.UN8"), (uint)size.X, (uint)size.Y, 1, multisampleCount, multisampleQuality, GraphicsLocality.DeviceOrSystemMemory, null); texture.DisposeOnViewDispose = true; Guid shareGuid = graphicsDevice.RegisterShared(texture, TextureUsage.Texture); RenderTargetView renderTarget = texture.CreateRenderTarget( PixelFormat.Parse("R.UN8 G.UN8 B.UN8 A.UN8")); window = windowManager.CreateWindow(shareGuid, title, titleGroup, this, windowOptions, position, size, minSize, maxSize, windowState, null, false); // 3) We create graphics canvas. GraphicsCanvas canvas = new GraphicsCanvas(graphicsDevice, renderTarget, new Vector2f(1, 1)); // 4) We create GUI manager. GuiManager manager = new GuiManager(canvas); manager.RootObject = widget; manager.PreRendering += new Action <GuiManager>(PreRenderingInternal); manager.Rendered += new Action <GuiManager>(RenderedInternal); this.root = manager; }
public DialogWindow(object model, object context, WindowOptions options) { DataContext = options; InitializeComponent(); Form.Environment.Add(options.EnvironmentFlags); Form.Context = context; Form.Model = model; }
public TimeWindowedKStream(WindowOptions <W> windowOptions, GroupedStreamAggregateBuilder <K, V> aggBuilder, string name, ISerDes <K> keySerde, ISerDes <V> valSerde, List <string> sourceNodes, StreamGraphNode streamsGraphNode, InternalStreamBuilder builder) : base(name, keySerde, valSerde, sourceNodes, streamsGraphNode, builder) { CheckIfParamNull(windowOptions, "windowOptions"); this.windowOptions = windowOptions; this.aggBuilder = aggBuilder; }
private static void Main(string[] args) { WindowOptions options = WindowOptions.Default; options.Size = new Vector2D <int>(800, 600); options.Title = "BuildCraft"; Init(options, OnLoad, OnUpdate, OnRender, OnClose); RunWindow(); }
public void onReady() { setConnectButtonState("Disconnect", true, true); interAppBus_ = controller_.getInterApplicationBus(); interAppBus_.addSubscribeListener((uuid, topic) => { bool exists = false; if (!subscriptionMap.TryGetValue(topic, out exists)) { subscriptionMap.Add(topic, true); if (subscriptionCallback != null) { subscriptionCallback(); } } }); Console.WriteLine("OnReady."); ApplicationOptions mainAppOptions = new ApplicationOptions(htmlDemoUuid_, htmlDemoUuid_, "https://developer.openf.in/htmlinterappcommdemo/1/index.html"); mainAppOptions.Version = "v1.0.0.0b"; mainAppOptions.IsAdmin = true; WindowOptions mainWindowOptions = mainAppOptions.MainWindowOptions; mainWindowOptions.AutoShow = true; mainWindowOptions.DefaultLeft = 100; mainWindowOptions.DefaultTop = 100; mainWindowOptions.DefaultWidth = 510; mainWindowOptions.DefaultHeight = 350; mainWindowOptions.Maximizable = false; mainWindowOptions.ShowTaskbarIcon = true; AckCallback afterAppCreation = (ack) => { Console.WriteLine("afterAppCreation"); Console.WriteLine(ack.getJsonObject().ToString()); AckCallback afterRun = (runAck) => { Console.WriteLine("afterRun"); Console.WriteLine(runAck.getJsonObject().ToString()); }; Console.WriteLine("app.run()"); // Using same callback for success and error in case app is already running htmlApplication_.run(afterRun, afterRun); }; // Using same callback for success and error in case app already exists Console.WriteLine("Creating App"); htmlApplication_ = new Application(mainAppOptions, controller_, afterAppCreation, afterAppCreation); htmlApplication_.addEventListener("closed", (ack) => { controller_.disconnect(); System.Windows.Forms.Application.ExitThread(); }); }
public unsafe IWindow CreateWindow(WindowOptions opts) { if (IsViewOnly) { throw new PlatformNotSupportedException("Platform is view-only."); } return(new SdlWindow(opts, null, null)); }
public NativeWindow(GraphicsMode mode, WindowOptions options) { if (options.ScreenMode == ScreenMode.Native) { options.Width = DisplayDevice.Default.Width; options.Height = DisplayDevice.Default.Height; } GameWindowFlags windowFlags = GameWindowFlags.Default; if (options.ScreenMode == ScreenMode.FixedWindow) windowFlags = GameWindowFlags.FixedWindow; else if (options.ScreenMode == ScreenMode.Fullscreen || options.ScreenMode == ScreenMode.Native) windowFlags = GameWindowFlags.Fullscreen; this.refreshMode = options.RefreshMode; this.internalWindow = new InternalWindow( this, options.Width, options.Height, mode, options.Title, windowFlags); this.internalWindow.MakeCurrent(); this.internalWindow.CursorVisible = true; if (!options.SystemCursorVisible) this.internalWindow.Cursor = MouseCursor.Empty; this.internalWindow.VSync = (options.RefreshMode != RefreshMode.VSync) ? VSyncMode.Off : VSyncMode.On; Log.Core.Write("Window Specification: {0}Mode: {1}{0}VSync: {2}{0}SwapInterval: {3}{0}", Environment.NewLine, this.internalWindow.Context.GraphicsMode, this.internalWindow.VSync, this.internalWindow.Context.SwapInterval); // Retrieve icon from executable file and set it as window icon Assembly entryAssembly = Assembly.GetEntryAssembly(); if (entryAssembly != null) { string executablePath = Path.GetFullPath(entryAssembly.Location); if (File.Exists(executablePath)) { this.internalWindow.Icon = Icon.ExtractAssociatedIcon(executablePath); } } if (options.ScreenMode == ScreenMode.FullWindow) this.internalWindow.WindowState = WindowState.Fullscreen; DualityApp.TargetResolution = new Vector2(this.internalWindow.ClientSize.Width, this.internalWindow.ClientSize.Height); DualityApp.Mouse.Source = new GameWindowMouseInputSource(this.internalWindow); DualityApp.Keyboard.Source = new GameWindowKeyboardInputSource(this.internalWindow); DualityApp.UserDataChanged += this.OnUserDataChanged; // Determine OpenGL capabilities and log them GraphicsBackend.LogOpenGLSpecs(); }
/// <summary>Show an option window for this instance of <see cref="TCfg" /></summary> /// <param name="options">Optional window display options</param> /// <returns>Dialog result</returns> public Task <DialogResult <TCfg> > ShowWindow(WindowOptions options = null) { options ??= new WindowOptions { CanResize = true, }; return(Show.Window(this, options).For <TCfg>(_mapper.Map <TCfg>(this))); }
private static extern IntPtr SDL_CreateWindow( string title, int x, int y, int width, int height, [MarshalAs(UnmanagedType.U4)] WindowOptions options );
public DialogWindow(object model, object context, WindowOptions options) { DataContext = options; InitializeComponent(); Loaded += (sender, e) => MoveFocus(new TraversalRequest(FocusNavigationDirection.Next)); Form.Environment.Add(options.EnvironmentFlags); Form.Context = context; Form.Model = model; }
public void Should_Determine_Virtual_Screen() { var options = new WindowOptions { FillScreen = ScreenFill.VirtualScreen }; var frame = options.GetFrame(); var virtualFrame = SystemInformation.VirtualScreen; Assert.AreEqual(virtualFrame, frame); }
static void Main(string[] args) { var options = new WindowOptions(true, true, new Point(20, 40), new Size(1024, 768), 60, 60, GraphicsAPI.Default, "ShowCase", WindowState.Normal, WindowBorder.Fixed, VSyncMode.Off, int.MaxValue, false, new VideoMode(60)); var window = Window.Create(options); ComponentManager.Run(typeof(MyComponent), window, new Renderer.OpenGL.ControlRendererFactory()); }
public IWindow CreateWindow(WindowOptions opts) { if (opts.WindowState == WindowState.Fullscreen) { return(new GlfwWindow(opts, null, this)); } opts.Position = new Point(opts.Position.X + Bounds.X, opts.Position.Y + Bounds.Y); return(new GlfwWindow(opts, null, null)); }
public MainWindow(IViewModel <MainWindowViewModel> model, WindowOptions windowOptions) : base(model) { _setBlocker = windowOptions.BlockSet(); _windowOptions = windowOptions; InitializeComponent(); WindowStartupLocation = WindowStartupLocation.Manual; }
/// <inheritdoc /> public IWindow CreateWindow(WindowOptions options) { if (!IsApplicable) { ThrowUnsupported(); return(null !); } return(_lastCreatedWindow = new GlfwWindow(options, null, null)); }
private void OnOkExecute() { if (HasBuilding) { InsPoint.Building.BuildingType = BuildingType; InsPoint.Window = WindowVM.Window; defaultWindow = WindowVM.Window; } InsPoint.Height = Height; }
/// <summary> /// Initializes duality but does not yet run it. /// </summary> /// <param name="launcherArgs"></param> public DualityLauncher(LauncherArgs launcherArgs = null) { if (launcherArgs == null) { launcherArgs = new LauncherArgs(); } System.Threading.Thread.CurrentThread.CurrentCulture = System.Globalization.CultureInfo.InvariantCulture; System.Threading.Thread.CurrentThread.CurrentUICulture = System.Globalization.CultureInfo.InvariantCulture; // Set up console logging this.AddGlobalOutput(new ConsoleLogOutput()); // Set up file logging try { StreamWriter logfileWriter = new StreamWriter("logfile.txt"); logfileWriter.AutoFlush = true; this.disposables.Push(logfileWriter); this.AddGlobalOutput(new TextWriterLogOutput(logfileWriter)); } catch (Exception e) { Logs.Core.WriteWarning("Text Logfile unavailable: {0}", LogFormat.Exception(e)); } // Set up a global exception handler to log errors AppDomain.CurrentDomain.UnhandledException += CurrentDomain_UnhandledException; // Write initial log message before actually booting Duality Logs.Core.Write("Running DualityLauncher with flags: {1}{0}", Environment.NewLine, launcherArgs); // Initialize the Duality core DualityApp.Init( DualityApp.ExecutionEnvironment.Launcher, DualityApp.ExecutionContext.Game, new DefaultAssemblyLoader(), launcherArgs); // Open up a new window WindowOptions options = new WindowOptions { Size = DualityApp.UserData.Instance.WindowSize, ScreenMode = launcherArgs.IsDebugging ? ScreenMode.Window : DualityApp.UserData.Instance.WindowMode, RefreshMode = launcherArgs.IsProfiling ? RefreshMode.NoSync : DualityApp.UserData.Instance.WindowRefreshMode, Title = DualityApp.AppData.Instance.AppName, SystemCursorVisible = launcherArgs.IsDebugging || DualityApp.UserData.Instance.SystemCursorVisible }; this.window = DualityApp.OpenWindow(options); }
public WindowOptionsViewModel(WindowOptions window) { if (window != null) { HasWindow = true; Window = window.Copy(); WindowConstructions = new ObservableCollection <WindowConstruction>(WindowConstruction.WindowConstructions); Quarters = new ObservableCollection <double>(WindowOptions.Quarters);// { 0.07, 0.13, 0.26 }; } Reset = new RelayCommand(OnResetExecute, CanResetExecute); }
public static WindowOptions AddWindow(this IApplicationBuilder applicationBuilder, Size initialSize, string title) { var windowList = new List <WindowOptions>(applicationBuilder.Options.Windows); var newWindow = new WindowOptions { InitialSize = initialSize, Title = title }; windowList.Add(newWindow); applicationBuilder.Options.Windows = windowList; return(newWindow); }
public NativeWindow(WindowOptions options) { this.ScreenMode = options.ScreenMode; window = (JSObject)Runtime.GetGlobalObject("window"); updateDelegate = new Action <double>(OnUpdate); // ToDo //DualityApp.Mouse.Source = new GameWindowMouseInputSource(this.internalWindow); DualityApp.Keyboard.Source = new KeyboardInputSource(); }
private void OpenPageInternal(string id) { var url = string.Format("{0}{1}", CPApplication.Current.PortalBaseAddress, "Pages/SendMail.aspx?MessageID={0}&LanguageCode={1}"); var option = new WindowOptions(); option.Size = new System.Windows.Size { Width = 1024, Height = 768 }; option.Resizable = true; UtilityHelper.OpenPage(string.Format(url, id, CPApplication.Current.LanguageCode), option); }
INativeWindow IGraphicsBackend.CreateWindow(WindowOptions options) { return new DummyNativeWindow(); }
public NativeWindow(GraphicsMode mode, WindowOptions options) { if (options.ScreenMode == ScreenMode.Native) { options.Width = DisplayDevice.Default.Width; options.Height = DisplayDevice.Default.Height; } GameWindowFlags windowFlags = GameWindowFlags.Default; if (options.ScreenMode == ScreenMode.FixedWindow) windowFlags = GameWindowFlags.FixedWindow; else if (options.ScreenMode == ScreenMode.Fullscreen || options.ScreenMode == ScreenMode.Native) windowFlags = GameWindowFlags.Fullscreen; this.refreshMode = options.RefreshMode; this.internalWindow = new InternalWindow( this, options.Width, options.Height, mode, options.Title, windowFlags); this.internalWindow.MakeCurrent(); this.internalWindow.CursorVisible = true; if (!options.SystemCursorVisible) this.internalWindow.Cursor = MouseCursor.Empty; this.internalWindow.VSync = (options.RefreshMode != RefreshMode.VSync) ? VSyncMode.Off : VSyncMode.On; Log.Core.Write( "Window Specification: " + Environment.NewLine + "Buffers: {0}" + Environment.NewLine + "Samples: {1}" + Environment.NewLine + "ColorFormat: {2}" + Environment.NewLine + "AccumulatorFormat: {3}" + Environment.NewLine + "Depth: {4}" + Environment.NewLine + "Stencil: {5}" + Environment.NewLine + "VSync: {6}" + Environment.NewLine + "SwapInterval: {7}", this.internalWindow.Context.GraphicsMode.Buffers, this.internalWindow.Context.GraphicsMode.Samples, this.internalWindow.Context.GraphicsMode.ColorFormat, this.internalWindow.Context.GraphicsMode.AccumulatorFormat, this.internalWindow.Context.GraphicsMode.Depth, this.internalWindow.Context.GraphicsMode.Stencil, this.internalWindow.VSync, this.internalWindow.Context.SwapInterval); // Retrieve icon from executable file and set it as window icon Assembly entryAssembly = Assembly.GetEntryAssembly(); if (entryAssembly != null) { string executablePath = Path.GetFullPath(entryAssembly.Location); if (File.Exists(executablePath)) { this.internalWindow.Icon = Icon.ExtractAssociatedIcon(executablePath); } } if (options.ScreenMode == ScreenMode.FullWindow) this.internalWindow.WindowState = WindowState.Fullscreen; DualityApp.TargetResolution = new Vector2(this.internalWindow.ClientSize.Width, this.internalWindow.ClientSize.Height); // Register events and input this.HookIntoDuality(); // Determine OpenGL capabilities and log them GraphicsBackend.LogOpenGLSpecs(); }
public NativeWindow(GraphicsMode mode, WindowOptions options) { if (options.ScreenMode == ScreenMode.Native && DisplayDevice.Default != null) { options.Width = DisplayDevice.Default.Width; options.Height = DisplayDevice.Default.Height; } GameWindowFlags windowFlags = GameWindowFlags.Default; if (options.ScreenMode == ScreenMode.FixedWindow) windowFlags = GameWindowFlags.FixedWindow; else if (options.ScreenMode == ScreenMode.Fullscreen || options.ScreenMode == ScreenMode.Native) windowFlags = GameWindowFlags.Fullscreen; this.refreshMode = options.RefreshMode; this.internalWindow = new InternalWindow( this, options.Width, options.Height, mode, options.Title, windowFlags); this.internalWindow.MakeCurrent(); this.internalWindow.CursorVisible = true; if (!options.SystemCursorVisible) this.internalWindow.Cursor = MouseCursor.Empty; this.internalWindow.VSync = (options.RefreshMode != RefreshMode.VSync) ? VSyncMode.Off : VSyncMode.On; Log.Core.Write( "Window Specification: " + Environment.NewLine + " Buffers: {0}" + Environment.NewLine + " Samples: {1}" + Environment.NewLine + " ColorFormat: {2}" + Environment.NewLine + " AccumFormat: {3}" + Environment.NewLine + " Depth: {4}" + Environment.NewLine + " Stencil: {5}" + Environment.NewLine + " VSync: {6}" + Environment.NewLine + " SwapInterval: {7}", this.internalWindow.Context.GraphicsMode.Buffers, this.internalWindow.Context.GraphicsMode.Samples, this.internalWindow.Context.GraphicsMode.ColorFormat, this.internalWindow.Context.GraphicsMode.AccumulatorFormat, this.internalWindow.Context.GraphicsMode.Depth, this.internalWindow.Context.GraphicsMode.Stencil, this.internalWindow.VSync, this.internalWindow.Context.SwapInterval); // Retrieve icon from executable file and set it as window icon string executablePath = null; try { Assembly entryAssembly = Assembly.GetEntryAssembly(); if (entryAssembly != null) { executablePath = Path.GetFullPath(entryAssembly.Location); if (File.Exists(executablePath)) { this.internalWindow.Icon = Icon.ExtractAssociatedIcon(executablePath); } } } // As described in issue 301 (https://github.com/AdamsLair/duality/issues/301), the // icon extraction can fail with an exception under certain circumstances. Don't fail // just because of an icon. Log the error and continue. catch (Exception e) { Log.Core.WriteError( "There was an exception while trying to extract the " + "window icon from the game's main executable '{0}'. This is " + "uncritical, but still an error: {1}", executablePath, Log.Exception(e)); } if (options.ScreenMode == ScreenMode.FullWindow) this.internalWindow.WindowState = WindowState.Fullscreen; DualityApp.TargetResolution = new Vector2(this.internalWindow.ClientSize.Width, this.internalWindow.ClientSize.Height); // Register events and input this.HookIntoDuality(); // Determine OpenGL capabilities and log them GraphicsBackend.LogOpenGLSpecs(); }