Rect rcnormal; //定义一个全局rect记录还原状态下窗口的位置和大小。 public MainWindow() { InitializeComponent(); icon(); //保证窗体显示在上方。 wsl = WindowState; }
public void Restore(XmlReader reader) { int count = reader.AttributeCount; for (int i = 0; i < count; ++i) { reader.MoveToAttribute(i); switch (reader.Name) { case "top": Top = reader.ReadContentAsDouble(); break; case "left": Left = reader.ReadContentAsDouble(); break; case "width": Width = reader.ReadContentAsDouble(); break; case "height": Height = reader.ReadContentAsDouble(); break; case "state": State = (WindowState) Enum.Parse(typeof (WindowState), reader.Value); break; } } }
static void OpenGeovoxIntegrationWindow(){ Resolution res = Screen.currentResolution; UpdateCurrentSourceDirectory(); if ( window == null ){ window = ScriptableObject.CreateInstance<AGF_IntegrationWindow>(); window.ShowUtility(); window.position = new Rect( res.width * 0.25f, res.height * 0.25f, 500.0f, 200 ); window.title = "Geovox Scene Loader"; window.maxSize = new Vector2( window.position.width, window.position.height ); window.minSize = new Vector2( window.position.width, window.position.height ); window.integrationType = IntegrationType.Geovox; m_CurrentWindowState = WindowState.ModeSelect; } else { window.Focus(); } lightShadows = (LightShadows)PlayerPrefs.GetInt (Main.gameName + "ShadowType", 2); terrainShadows = PlayerPrefs.GetInt (Main.gameName + "TerrainShadowType", 1) == 1; grassShadows = PlayerPrefs.GetInt (Main.gameName + "GrassShadowType", 1) == 1; prefabShadows = PlayerPrefs.GetInt (Main.gameName + "PrefabShadowType", 1) == 1; terrainSpecular = PlayerPrefs.GetInt (Main.gameName + "TerrainSpecular", 1) == 1; prevRunInBackground = Application.runInBackground; Application.runInBackground = true; }
public Sdl2NativeWindow(int x, int y, int width, int height, string title, GameWindowFlags options, DisplayDevice device) { lock (sync) { var bounds = device.Bounds; var flags = TranslateFlags(options); flags |= WindowFlags.OPENGL; flags |= WindowFlags.RESIZABLE; flags |= WindowFlags.HIDDEN; flags |= WindowFlags.ALLOW_HIGHDPI; if ((flags & WindowFlags.FULLSCREEN_DESKTOP) != 0 || (flags & WindowFlags.FULLSCREEN) != 0) window_state = WindowState.Fullscreen; IntPtr handle; lock (SDL.Sync) { EventFilterDelegate = Marshal.GetFunctionPointerForDelegate(EventFilterDelegate_GCUnsafe); handle = SDL.CreateWindow(title, bounds.Left + x, bounds.Top + y, width, height, flags); SDL.AddEventWatch(EventFilterDelegate, handle); SDL.PumpEvents(); } window = new Sdl2WindowInfo(handle, null); window_id = SDL.GetWindowID(handle); windows.Add(window_id, this); window_title = title; exists = true; } }
/// <summary> /// Called when an attached view's Loaded event fires. /// </summary> /// <param name="view"/> protected override void OnViewLoaded(object view) { base.OnViewLoaded(view); _window = Window.GetWindow((DependencyObject)view); if (_window == null) { return; } _window.StateChanged += OnWindowStateChanged; _previousWindowState = _window.WindowState; Stream iconStream = IoC.Get<IResourceManager>() .GetStream("Resources/GoHome.ico", Assembly.GetExecutingAssembly().GetAssemblyName()); _taskbarIcon = new TaskbarIcon { Icon = new Icon(iconStream), ToolTipText = "Show main window" }; _taskbarIcon.TrayMouseDoubleClick += OnTaskbarIconTrayMouseClick; _taskbarIcon.TrayLeftMouseDown += OnTaskbarIconTrayMouseClick; _taskbarIcon.TrayRightMouseDown += OnTaskbarIconTrayMouseClick; if (Settings.Default.StartHiddenToTray) { _window.WindowState = WindowState.Minimized; } }
public static void Initialize() { _window = CoreWindow.GetForCurrentThread(); _windowsBounds = _window.Bounds; _windowState = WindowState.Full; _window.SizeChanged += _window_SizeChanged; }
public static void GoFullScreen(this Window window) { if (IsFullScreen(window)) { return; } windowState = window.WindowState; windowStyle = window.WindowStyle; windowTopmost = window.Topmost; windowResizeMode = window.ResizeMode; windowRect.X = window.Left; windowRect.Y = window.Top; windowRect.Width = window.Width; windowRect.Height = window.Height; window.WindowState = WindowState.Maximized; window.WindowStyle = WindowStyle.None; windowTopmost = false; windowResizeMode = ResizeMode.NoResize; IntPtr handle = new WindowInteropHelper(window).Handle; Screen screen = Screen.FromHandle(handle); window.Width = screen.Bounds.Width; window.Height = screen.Bounds.Height; fullWindow = window; }
public static void ToFullscreen(this Window window) { if (window.IsFullscreen()) { return; } _windowState = window.WindowState; _windowStyle = window.WindowStyle; _windowTopMost = window.Topmost; _windowResizeMode = window.ResizeMode; _windowRect.X = window.Left; _windowRect.Y = window.Top; _windowRect.Width = window.Width; _windowRect.Height = window.Height; window.WindowState = WindowState.Normal; window.WindowStyle = WindowStyle.None; window.ResizeMode = ResizeMode.NoResize; window.Topmost = true; var handle = new WindowInteropHelper(window).Handle; Screen screen = Screen.FromHandle(handle); window.MaxWidth = screen.Bounds.Width; window.MaxHeight = screen.Bounds.Height; window.WindowState = WindowState.Maximized; window.Activated += new EventHandler(window_Activated); window.Deactivated += new EventHandler(window_Deactivated); _fullWindow = window; }
public MainWindowAdapter( Project project, IFieldPathFactory pathFactory, PresetView preset, StandardView standard, AdvancedView advanced, RetrieveFieldsView fields) : base(project) { _appWidth = Properties.Settings.Default.AppWidth; _appHeight = Properties.Settings.Default.AppHeight; _appWindowState = Properties.Settings.Default.AppWindowState; _viewColumnSize = new GridLength(Properties.Settings.Default.ViewColumnSize); Preset = preset; Standard = standard; Advanced = advanced; RetrieveFields = fields; _views.Add("Preset", preset.Adapter); _views.Add("Standard", standard.Adapter); _views.Add("Advanced", advanced.Adapter); Preset.Adapter.Search += Adapter_Search; Standard.Adapter.Search += Adapter_Search; Advanced.Adapter.Search += Adapter_Search; ProjectAdapter = new ProjectAdapter(project); ProjectAdapter.Project.CurrentConnectionChanged += delegate { RefreshPaths(); OnPropertyChanged("ApplicationTitle"); }; PathFactory = pathFactory; CurrentView = Preset.Adapter; SelectedSubjectChanged += delegate { RefreshPaths(); }; RefreshPaths(); }
public SavedWindowState Read(ISettingsSection section) { Bounds = section.Attribute<Rect?>("Bounds") ?? Rect.Empty; IsFullScreen = section.Attribute<bool?>("IsFullScreen") ?? false; WindowState = section.Attribute<WindowState?>("WindowState") ?? WindowState.Normal; return this; }
private void Window_StateChanged(object sender, EventArgs e) { if (this.WindowState != System.Windows.WindowState.Minimized) { FLastRestoreWindowState = this.WindowState; } }
protected override void OnStateChanged(EventArgs e) { base.OnStateChanged(e); if(this.WindowState != WindowState.Minimized) { this.RestoreWindowState = this.WindowState; } }
private static Action<object> SetWindowStateHandler(WindowState newState) { return o => { Window win = ExtractWindowFromParameter(o); win.WindowState = newState; }; }
public void UpdateFrom(MainWindow window) { Left = window.Left; Top = window.Top; Width = window.Width; Height = window.Height; State = window.WindowState; }
public static void OnSceneLoaded() { m_CurrentWindowState = WindowState.ModeSelect; if ( window != null ){ window.Repaint(); } }
public FloatingItemSnapShot(object content, Rect location, int zIndex, WindowState state) { if (content == null) throw new ArgumentNullException("content"); _content = content; _location = location; _zIndex = zIndex; _state = state; }
private void MainWindowLoaded(object sender, RoutedEventArgs e) { dgNotifications.Items.SortDescriptions.Add(new SortDescription("StartTime", ListSortDirection.Descending)); _showStateForNotifyIcon = WindowState; UpdateConnectionSring(); if (miHideAtStart.IsChecked) { WindowState = WindowState.Minimized; } }
public WindowSysMin(Window wind) { window = wind; window.Closing += window_Closing; window.StateChanged += window_StateChanged; //保证窗体显示在上方。 wsl = window.WindowState; Init(); }
public static void Initialize() { _window = CoreWindow.GetForCurrentThread(); _windowsBounds = _window.Bounds; _windowState = WindowState.Full; _window.SizeChanged += _window_SizeChanged; CoreApplication.Suspending += CoreApplication_Suspending; CoreApplication.Resuming += CoreApplication_Resuming; }
// Constructor public MainWindowViewModel() { // Default values windowState = WindowState.Normal; restoreOrMaximiseImageButtonSource = ImageUtil.LoadBitmapImageFromResources(@"../Resources/maximise_normal.png"); // Title bar commands this.minimiseCommand = new RelayCommand(x => windowState = WindowState.Minimized); this.restoreOrMaximiseCommand = new RelayCommand(x => windowState = WindowState.Maximized); this.closeCommand = new RelayCommand(x => Application.Current.Shutdown()); }
public MenuWindow(SpriteFont spriteFont, string menuTitle, Texture2D backgroundImage) { itemList = new List<MenuItem>(); changeSpan = TimeSpan.FromMilliseconds(800.0); selectedItem = 0; changeProgress = 0; windowState = WindowState.Inactive; this.spriteFont = spriteFont; this.menuTitle = menuTitle; this.backgroundImage = backgroundImage; }
void OnStateChanged(object sender, EventArgs args) { if (WindowState == WindowState.Minimized) { Hide(); if (appIcon != null) appIcon.ShowBalloonTip(2000); } else windowState = WindowState; }
public SavedWindowState(MetroWindow window) { this.Bounds = window.RestoreBounds; var source = PresentationSource.FromVisual(window); Debug.Assert(source != null); if (source != null) { var t = this.Bounds; t = Rect.Transform(Bounds, source.CompositionTarget.TransformToDevice); this.Bounds = new Rect(t.TopLeft, this.Bounds.Size); } this.IsFullScreen = window.IsFullScreen; this.WindowState = window.WindowState; }
public AGSGameSettings(string title, AGS.API.Size virtualResolution, WindowState windowState = WindowState.Maximized, AGS.API.Size? windowSize = null, VsyncMode vsync = VsyncMode.Adaptive, bool preserveAspectRatio = true, WindowBorder windowBorder = WindowBorder.Resizable) { Title = title; VirtualResolution = virtualResolution; WindowState = windowState; WindowSize = windowSize.HasValue ? windowSize.Value : virtualResolution; Vsync = vsync; PreserveAspectRatio = preserveAspectRatio; WindowBorder = windowBorder; }
public MainWindow() { InitializeComponent(); _youTubeUrlIdentifier = new IsYouTubeVideoSpecification(); _storedWindowState = WindowState.Normal; _notifier = new System.Windows.Forms.NotifyIcon(); InitializeTrayIcon(); }
/** * ウインドウ GUI */ public void OnWindowGUI() { if (windowState == WindowState.Minimize) { if (GUI.Button(minimizeRect, ">")) { windowState = WindowState.Visible; } } else { windowRect = GUI.Window( windowId, windowRect, OnWindowContentGUI, windowTitle ); } }
protected override void OnStateChanged(EventArgs e) { base.OnStateChanged(e); if (!this.IsLoaded) return; if (this.WindowState == System.Windows.WindowState.Minimized) _icon_DoubleClick(this, e);//Hide else _lastState = this.WindowState; }
// Update is called once per frame void Update() { int val = GameMaster.Instance.Coin; switch(ws){ case WindowState.Appear: progress += 15f*Time.deltaTime; if(progress >= 1f){ ws = WindowState.Wait; progress = 1f; waitCount = waitTime; timeSpan = 0f; } break; case WindowState.Wait: if (timeSpan > 0f){ timeSpan-= Time.deltaTime; }else if (timeSpan <= 0f && viewNumber != val){ viewNumber++; timeSpan = 0.05f; }else{ waitCount -= 2f*Time.deltaTime; if (waitCount<=0f){ ws = WindowState.Close; } } break; case WindowState.Close: progress -= Time.deltaTime; if(progress <= 0f){ ws = WindowState.Off; progress = 0f; } break; case WindowState.Off: break; } Vector3 bufv = transform.localPosition; bufv.y = originalY - (110f * progress); transform.localPosition = bufv; if (viewNumber != val &&(ws == WindowState.Off || ws == WindowState.Close)) { ws = WindowState.Appear; } int buf = viewNumber; for (int i=maxDigit-1; i>=0; i--) { digitText[i].text = (buf % 10).ToString(); buf /= 10; } }
public NotifyIconWrapper(Window window, WindowState showState) { InitializeComponent(); _window = window; notifyIcon.Text = _window.Title; _showState = showState; toolStripMenuItemShow.Text = Res.Show; toolStripMenuItemShow.Click += ToolStripMenuItemShowClick; toolStripMenuItemClose.Text = Res.Close; toolStripMenuItemClose.Click += ToolStripMenuItemCloseClick; }
public MainWindow() { InitializeComponent(); ShowIcon(); //保证窗体显示在上方。 wsl = WindowState; //设置定时器 Timer timeClock = new Timer(); timeClock.Enabled = true; timeClock.Interval = 1000; timeClock.Elapsed += new ElapsedEventHandler(clock); }
public WindowManager(WindowState windowState, Vector2 resolution) { this.windowState = windowState; this.resolution = resolution; current = this; }
public AddPopUp(WindowState ws) { InitializeComponent(); this.CurrentWindowState = ws; UserControllSelecter(); }
private void UpdateWindowState() { // we should wait until window's not fullscreen to resize if (updateClientBounds) { var prevState = window.WindowState; if (CurrentPlatform.OS == OS.Linux) { window.WindowBorder = WindowBorder.Resizable; } updateClientBounds = false; // if the window-state is set from the outside (maximized button pressed) we have to update it here. // if it was set from the inside (.IsFullScreen changed), we have to change the window. // this code might not cover all corner cases // window was maximized if ((windowState == WindowState.Normal && window.WindowState == WindowState.Maximized) || (windowState == WindowState.Maximized && window.WindowState == WindowState.Normal)) { windowState = window.WindowState; // maximize->normal and normal->maximize are usually set from the outside } else { window.WindowState = windowState; // usually fullscreen-stuff is set from the code } if (!Configuration.RunningOnSdl2 && prevState != WindowState.Fullscreen) { int centerOffsetX = -(targetBounds.Width - window.ClientRectangle.Width) / 2; int centerOffsetY = -(targetBounds.Height - window.ClientRectangle.Height) / 2; window.X = Math.Max(0, centerOffsetX + window.X); window.Y = Math.Max(0, centerOffsetY + window.Y); } window.ClientRectangle = new System.Drawing.Rectangle(targetBounds.X, targetBounds.Y, targetBounds.Width, targetBounds.Height); // we need to create a small delay between resizing the window // and changing the border to avoid OpenTK Linux bug if (CurrentPlatform.OS == OS.Linux) { updateborder = 2; } else { UpdateBorder(); } var context = GraphicsContext.CurrentContext; if (context != null) { context.Update(window.WindowInfo); } if (!Window.Visible) { Window.Visible = true; // Bug in OpenTK, it doesn't always set state if window is not visible window.WindowState = windowState; } } }
public abstract void SetWindowState(WindowState value);
public override async Task OnCommandRecieved(Command cmd) { string commandName = cmd.LocalCommand; string userInput = cmd.UserInput; if (string.IsNullOrEmpty(ApiKey)) { if (!cmd.IsLocalCommand) { cmd.Respond("Invalid API Key."); } return; } if (commandName == "Play ID") { string id = RegisteredCommands[commandName].Match(userInput).Groups["id"].Value.ToString(); if (Current != null) { if (Current.IsLoaded) { Current.Close(); } } Application.Current.Dispatcher.Invoke(() => { Current = new YoutubeVideo(id); Current.Show(); }); } if (commandName == "Search") { Match m = RegisteredCommands[commandName].Match(userInput); string name = m.Groups["name"].Value.ToString(); if (!string.IsNullOrWhiteSpace(name)) { if (cmd.IsLocalCommand) { Application.Current.Dispatcher.Invoke(() => { new YoutubeSearch(name).Show(); }); } else { YouTubeService ys = new YouTubeService(new BaseClientService.Initializer() { ApiKey = YoutubeHook.ApiKey, ApplicationName = "Butler-YoutubeViewer" }); SearchResource.ListRequest req = new SearchResource.ListRequest(ys, "snippet") { Q = name, MaxResults = 30 }; LastSearchResponse = req.Execute(); string output = "Search Results:-\n"; for (int i = 0; i < LastSearchResponse.Items.Count; i++) { output += $"{i+1}.] {LastSearchResponse.Items[i].Snippet.Title}\n"; } cmd.Respond(output); } } } if (commandName == "Lucky Search") { Match m = RegisteredCommands[commandName].Match(userInput); YouTubeService ys = new YouTubeService(new BaseClientService.Initializer() { ApiKey = YoutubeHook.ApiKey, ApplicationName = "Butler-YoutubeViewer" }); SearchResource.ListRequest req = new SearchResource.ListRequest(ys, "snippet") { Q = m.Groups["name"].Value.ToString(), MaxResults = 1 }; SearchListResponse resp = req.Execute(); if (Current != null) { if (Current.IsLoaded) { Current.Close(); } } Application.Current.Dispatcher.Invoke(() => { Current = new YoutubeVideo(resp.Items[0].Id.VideoId); Current.Show(); }); } if (commandName == "Choose Option") { string choiceString = RegisteredCommands[cmd.LocalCommand].Match(cmd.UserInput).Groups["choice"].Value; int choiceInt; if (LastSearchResponse == null) { cmd.Respond("You didn't search for anything."); return; } if (!int.TryParse(choiceString, out choiceInt)) { cmd.Respond("That is not a number."); return; } choiceInt -= 1; if (choiceInt < 0 || choiceInt > LastSearchResponse.Items.Count - 1) { cmd.Respond("Dude.. Enter a acceptable value."); return; } if (Current != null) { if (Current.IsLoaded) { Current.Close(); } } Application.Current.Dispatcher.Invoke(() => { Current = new YoutubeVideo(LastSearchResponse.Items[choiceInt].Id.VideoId); Current.Show(); }); // Should I clear the search options after an option has been selected? //LastSearchResponse = null; } if (commandName == "Close") { if (Current != null) { if (Current.IsLoaded) { Current.Close(); } } } if (commandName == "State") { string state = RegisteredCommands[commandName].Match(userInput).Groups["state"].Value.ToLower(); switch (state) { case "min": case "minimize": State = WindowState.Minimized; break; case "max": case "maximize": State = WindowState.Maximized; break; } if (Current != null) { if (Current.IsLoaded) { if (State == WindowState.Maximized) { Current.Maximize(); } else { Current.Minimize(); } } } } }
private void Select_Window(int i, WindowState wd, WindowStartupLocation wd_st) { switch (i) { case 1: { View.View_Thukho.Mathang view = new View.View_Thukho.Mathang(); view.WindowState = wd; view.WindowStartupLocation = wd_st; view.Show(); } break; case 2: { View.View_Thukho.Loaimathang view = new View.View_Thukho.Loaimathang(); view.WindowState = wd; view.WindowStartupLocation = wd_st; view.Show(); } break; case 3: { View.View_Thukho.Donvi view = new View.View_Thukho.Donvi(); view.WindowState = wd; view.WindowStartupLocation = wd_st; view.Show(); } break; case 4: { View.View_Thukho.Xuathang view = new View.View_Thukho.Xuathang(); view.WindowState = wd; view.WindowStartupLocation = wd_st; view.Show(); } break; case 5: { View.View_Thukho.Nhaphang view = new View.View_Thukho.Nhaphang(); view.WindowState = wd; view.WindowStartupLocation = wd_st; view.Show(); } break; case 6: { View.View_Thukho.Thongke view = new View.View_Thukho.Thongke(); view.WindowState = wd; view.WindowStartupLocation = wd_st; view.Show(); } break; case 7: { View.View_Thukho.Thungrac view = new View.View_Thukho.Thungrac(); view.WindowState = wd; view.WindowStartupLocation = wd_st; view.Show(); } break; default: break; } }
protected virtual Tuple <WindowStyles, WindowExStyles, ShowWindowCommand> GetWindowStyles(WindowCustomStyle customCreationStyle, WindowState state) { var styles = (WindowStyles)customCreationStyle.WindowStyles; var exStyles = (WindowExStyles)customCreationStyle.WindowExStyles; switch (state) { case WindowState.Normal: return(new Tuple <WindowStyles, WindowExStyles, ShowWindowCommand>(styles, exStyles, ShowWindowCommand.SW_SHOWNORMAL)); case WindowState.Maximize: return(new Tuple <WindowStyles, WindowExStyles, ShowWindowCommand>(styles, exStyles, ShowWindowCommand.SW_SHOWMAXIMIZED)); case WindowState.Fullscreen: return(new Tuple <WindowStyles, WindowExStyles, ShowWindowCommand>(styles, exStyles, ShowWindowCommand.SW_SHOWMAXIMIZED)); } return(new Tuple <WindowStyles, WindowExStyles, ShowWindowCommand>(styles, exStyles, ShowWindowCommand.SW_SHOWNORMAL)); }
/// <summary> /// Dependency property event once the windows state value has changed. /// </summary> /// <param name="sender">The sender.</param> /// <param name="e">The <see cref="System.Windows.DependencyPropertyChangedEventArgs"/> instance containing the event data.</param> private static void WindowStateValueChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e) { MdiChild mdiChild = (MdiChild)sender; WindowState previousWindowState = (WindowState)e.OldValue; WindowState windowState = (WindowState)e.NewValue; if (mdiChild.Container == null || previousWindowState == windowState) { return; } if (previousWindowState == WindowState.Maximized) { for (int i = 0; i < mdiChild.Container.Children.Count; i++) { if (mdiChild.Container.Children[i] != mdiChild && mdiChild.Container.Children[i].WindowState == WindowState.Maximized && mdiChild.Container.Children[i].MaximizeBox) { mdiChild.Container.Children[i].WindowState = WindowState.Normal; } } ScrollViewer sv = (ScrollViewer)((Grid)mdiChild.Container.Content).Children[1]; sv.HorizontalScrollBarVisibility = ScrollBarVisibility.Auto; sv.VerticalScrollBarVisibility = ScrollBarVisibility.Auto; if (mdiChild.Buttons != null) { mdiChild.Buttons.Children.Clear(); } try { mdiChild.buttonsPanel.Children.Add(mdiChild.minimizeButton); mdiChild.buttonsPanel.Children.Add(mdiChild.maximizeButton); mdiChild.buttonsPanel.Children.Add(mdiChild.closeButton); } catch { } } if (previousWindowState == WindowState.Minimized) { mdiChild.minimizedPosition = mdiChild.Position; } switch (windowState) { case WindowState.Normal: { mdiChild.Position = new Point(mdiChild.originalDimension.X, mdiChild.originalDimension.Y); if (mdiChild._minimizedWidth > 0 && mdiChild._minimizedHeight > 0) { mdiChild.MinWidth = mdiChild._minimizedWidth; mdiChild.MinHeight = mdiChild._minimizedHeight; } mdiChild.Width = mdiChild.originalDimension.Width; mdiChild.Height = mdiChild.originalDimension.Height; } break; case WindowState.Minimized: { if (previousWindowState == WindowState.Normal) { mdiChild.originalDimension = new Rect(mdiChild.Position.X, mdiChild.Position.Y, mdiChild.ActualWidth, mdiChild.ActualHeight); } //double newLeft, newTop; //if (mdiChild.minimizedPosition.X >= 0 || mdiChild.minimizedPosition.Y >= 0) //{ // newLeft = mdiChild.minimizedPosition.X; // newTop = mdiChild.minimizedPosition.Y; //} //else //{ // int minimizedWindows = 0; // for (int i = 0; i < mdiChild.Container.Children.Count; i++) // if (mdiChild.Container.Children[i] != mdiChild && mdiChild.Container.Children[i].WindowState == WindowState.Minimized) // minimizedWindows++; // int capacity = Convert.ToInt32(mdiChild.Container.InnerWidth) / mdiChild.MinimizedWidth, // row = minimizedWindows / capacity + 1, // col = minimizedWindows % capacity; // newTop = mdiChild.Container.InnerHeight - mdiChild.MinimizedHeight * row; // newLeft = mdiChild.MinimizedWidth * col; //} //mdiChild.Position = new Point(newLeft, newTop); int minimizedWindows = 0; for (int i = 0; i < mdiChild.Container.Children.Count; i++) { if (mdiChild.Container.Children[i] != mdiChild && mdiChild.Container.Children[i].WindowState == WindowState.Minimized) { minimizedWindows++; } } int cols = (int)(mdiChild.Container.InnerWidth / mdiChild.MinimizedWidth); int count = 0; foreach (var item in mdiChild.Container.Children) { if (item.WindowState == WindowState.Minimized) { item.Position = new Point((int)(count % cols) * item.MinimizedWidth, mdiChild.Container.InnerHeight - ((int)((int)(count / cols) + 1)) * item.MinimizedHeight); count++; } } mdiChild._minimizedWidth = (int)mdiChild.MinWidth; mdiChild._minimizedHeight = (int)mdiChild.MinHeight; mdiChild.MinWidth = mdiChild.MinimizedWidth; mdiChild.MinHeight = mdiChild.MinimizedHeight; mdiChild.Width = mdiChild.MinimizedWidth; mdiChild.Height = mdiChild.MinimizedHeight; } break; case WindowState.Maximized: { if (previousWindowState == WindowState.Normal) { mdiChild.originalDimension = new Rect(mdiChild.Position.X, mdiChild.Position.Y, mdiChild.ActualWidth, mdiChild.ActualHeight); } try { StackPanel sp = new StackPanel { Orientation = Orientation.Horizontal }; mdiChild.Buttons = sp; if (mdiChild.Container.Theme != ThemeType.Metro) { if (mdiChild.buttonsPanel != null) { mdiChild.buttonsPanel.Children.Clear(); } sp.Children.Add(mdiChild.minimizeButton); sp.Children.Add(mdiChild.maximizeButton); sp.Children.Add(mdiChild.closeButton); } } catch { } mdiChild.Position = new Point(0, 0); if (mdiChild._minimizedWidth > 0 && mdiChild._minimizedHeight > 0) { mdiChild.MinWidth = mdiChild._minimizedWidth; mdiChild.MinHeight = mdiChild._minimizedHeight; } mdiChild.Width = mdiChild.Container.InnerWidth; mdiChild.Height = mdiChild.Container.InnerHeight; if (mdiChild.Container.AllowWindowStateMax) { MdiContainer mdiContainer = mdiChild.Container; mdiContainer.AllowWindowStateMax = false; for (int i = 0; i < mdiContainer.Children.Count; i++) { if (mdiContainer.Children[i] != mdiChild) { if (mdiContainer.Children[i].WindowState == WindowState.Normal && mdiContainer.Children[i].MaximizeBox) { mdiContainer.Children[i].WindowState = WindowState.Maximized; } else if (mdiContainer.Children[i].WindowState == WindowState.Maximized) { mdiContainer.Children[i].Height = mdiContainer.InnerHeight; } } } ScrollViewer sv = (ScrollViewer)((Grid)mdiContainer.Content).Children[1]; sv.HorizontalScrollBarVisibility = ScrollBarVisibility.Hidden; sv.VerticalScrollBarVisibility = ScrollBarVisibility.Hidden; mdiChild.Focus(); mdiContainer.InvalidateSize(); mdiContainer.AllowWindowStateMax = true; } } break; } mdiChild.RaiseEvent(new RoutedEventArgs(WindowStateChangedEvent)); }
public static void SetWindowState(this IWindowService service, WindowState state) { WindowServiceExtensions.VerifyService(service); service.WindowState = DXWindowStateConverter.ToDXWindowState(state); }
private void MaximizeWindow(object o) { CurrentWindowState = CurrentWindowState == WindowState.Normal ? WindowState.Maximized : WindowState.Normal; }
protected virtual void OnDesignerWindowStatePropertyChanged(WindowState oldValue, WindowState newValue) { if (DesignerProperties.GetIsInDesignMode(this)) { Visibility = newValue == Orm.Toolkit.WindowState.Open ? Visibility.Visible : Visibility.Collapsed; } }
private void MinimizeWindow(object o) { CurrentWindowState = WindowState.Minimized; }
protected virtual IntPtr WndProc(IntPtr hWnd, uint msg, IntPtr wParam, IntPtr lParam) { bool unicode = UnmanagedMethods.IsWindowUnicode(hWnd); const double wheelDelta = 120.0; uint timestamp = unchecked ((uint)UnmanagedMethods.GetMessageTime()); RawInputEventArgs e = null; WindowsMouseDevice.Instance.CurrentWindow = this; switch ((UnmanagedMethods.WindowsMessage)msg) { case UnmanagedMethods.WindowsMessage.WM_ACTIVATE: var wa = (UnmanagedMethods.WindowActivate)(ToInt32(wParam) & 0xffff); switch (wa) { case UnmanagedMethods.WindowActivate.WA_ACTIVE: case UnmanagedMethods.WindowActivate.WA_CLICKACTIVE: Activated?.Invoke(); break; case UnmanagedMethods.WindowActivate.WA_INACTIVE: Deactivated?.Invoke(); break; } return(IntPtr.Zero); case UnmanagedMethods.WindowsMessage.WM_CLOSE: bool?preventClosing = Closing?.Invoke(); if (preventClosing == true) { return(IntPtr.Zero); } break; case UnmanagedMethods.WindowsMessage.WM_DESTROY: //Window doesn't exist anymore _hwnd = IntPtr.Zero; //Remove root reference to this class, so unmanaged delegate can be collected s_instances.Remove(this); Closed?.Invoke(); //Free other resources Dispose(); return(IntPtr.Zero); case UnmanagedMethods.WindowsMessage.WM_DPICHANGED: var dpi = ToInt32(wParam) & 0xffff; var newDisplayRect = Marshal.PtrToStructure <UnmanagedMethods.RECT>(lParam); Position = new Point(newDisplayRect.left, newDisplayRect.top); _scaling = dpi / 96.0; ScalingChanged?.Invoke(_scaling); return(IntPtr.Zero); case UnmanagedMethods.WindowsMessage.WM_KEYDOWN: case UnmanagedMethods.WindowsMessage.WM_SYSKEYDOWN: e = new RawKeyEventArgs( WindowsKeyboardDevice.Instance, timestamp, RawKeyEventType.KeyDown, KeyInterop.KeyFromVirtualKey(ToInt32(wParam)), WindowsKeyboardDevice.Instance.Modifiers); break; case UnmanagedMethods.WindowsMessage.WM_KEYUP: case UnmanagedMethods.WindowsMessage.WM_SYSKEYUP: e = new RawKeyEventArgs( WindowsKeyboardDevice.Instance, timestamp, RawKeyEventType.KeyUp, KeyInterop.KeyFromVirtualKey(ToInt32(wParam)), WindowsKeyboardDevice.Instance.Modifiers); break; case UnmanagedMethods.WindowsMessage.WM_CHAR: // Ignore control chars if (ToInt32(wParam) >= 32) { e = new RawTextInputEventArgs(WindowsKeyboardDevice.Instance, timestamp, new string((char)ToInt32(wParam), 1)); } break; case UnmanagedMethods.WindowsMessage.WM_LBUTTONDOWN: case UnmanagedMethods.WindowsMessage.WM_RBUTTONDOWN: case UnmanagedMethods.WindowsMessage.WM_MBUTTONDOWN: e = new RawMouseEventArgs( WindowsMouseDevice.Instance, timestamp, _owner, msg == (int)UnmanagedMethods.WindowsMessage.WM_LBUTTONDOWN ? RawMouseEventType.LeftButtonDown : msg == (int)UnmanagedMethods.WindowsMessage.WM_RBUTTONDOWN ? RawMouseEventType.RightButtonDown : RawMouseEventType.MiddleButtonDown, DipFromLParam(lParam), GetMouseModifiers(wParam)); break; case UnmanagedMethods.WindowsMessage.WM_LBUTTONUP: case UnmanagedMethods.WindowsMessage.WM_RBUTTONUP: case UnmanagedMethods.WindowsMessage.WM_MBUTTONUP: e = new RawMouseEventArgs( WindowsMouseDevice.Instance, timestamp, _owner, msg == (int)UnmanagedMethods.WindowsMessage.WM_LBUTTONUP ? RawMouseEventType.LeftButtonUp : msg == (int)UnmanagedMethods.WindowsMessage.WM_RBUTTONUP ? RawMouseEventType.RightButtonUp : RawMouseEventType.MiddleButtonUp, DipFromLParam(lParam), GetMouseModifiers(wParam)); break; case UnmanagedMethods.WindowsMessage.WM_MOUSEMOVE: if (!_trackingMouse) { var tm = new UnmanagedMethods.TRACKMOUSEEVENT { cbSize = Marshal.SizeOf <UnmanagedMethods.TRACKMOUSEEVENT>(), dwFlags = 2, hwndTrack = _hwnd, dwHoverTime = 0, }; UnmanagedMethods.TrackMouseEvent(ref tm); } e = new RawMouseEventArgs( WindowsMouseDevice.Instance, timestamp, _owner, RawMouseEventType.Move, DipFromLParam(lParam), GetMouseModifiers(wParam)); break; case UnmanagedMethods.WindowsMessage.WM_MOUSEWHEEL: e = new RawMouseWheelEventArgs( WindowsMouseDevice.Instance, timestamp, _owner, PointToClient(PointFromLParam(lParam)), new Vector(0, (ToInt32(wParam) >> 16) / wheelDelta), GetMouseModifiers(wParam)); break; case UnmanagedMethods.WindowsMessage.WM_MOUSEHWHEEL: e = new RawMouseWheelEventArgs( WindowsMouseDevice.Instance, timestamp, _owner, PointToClient(PointFromLParam(lParam)), new Vector(-(ToInt32(wParam) >> 16) / wheelDelta, 0), GetMouseModifiers(wParam)); break; case UnmanagedMethods.WindowsMessage.WM_MOUSELEAVE: _trackingMouse = false; e = new RawMouseEventArgs( WindowsMouseDevice.Instance, timestamp, _owner, RawMouseEventType.LeaveWindow, new Point(), WindowsKeyboardDevice.Instance.Modifiers); break; case UnmanagedMethods.WindowsMessage.WM_NCLBUTTONDOWN: case UnmanagedMethods.WindowsMessage.WM_NCRBUTTONDOWN: case UnmanagedMethods.WindowsMessage.WM_NCMBUTTONDOWN: e = new RawMouseEventArgs( WindowsMouseDevice.Instance, timestamp, _owner, msg == (int)UnmanagedMethods.WindowsMessage.WM_NCLBUTTONDOWN ? RawMouseEventType.NonClientLeftButtonDown : msg == (int)UnmanagedMethods.WindowsMessage.WM_NCRBUTTONDOWN ? RawMouseEventType.RightButtonDown : RawMouseEventType.MiddleButtonDown, new Point(0, 0), GetMouseModifiers(wParam)); break; case UnmanagedMethods.WindowsMessage.WM_PAINT: UnmanagedMethods.PAINTSTRUCT ps; if (UnmanagedMethods.BeginPaint(_hwnd, out ps) != IntPtr.Zero) { var f = Scaling; var r = ps.rcPaint; Paint?.Invoke(new Rect(r.left / f, r.top / f, (r.right - r.left) / f, (r.bottom - r.top) / f)); UnmanagedMethods.EndPaint(_hwnd, ref ps); } return(IntPtr.Zero); case UnmanagedMethods.WindowsMessage.WM_SIZE: var size = (UnmanagedMethods.SizeCommand)wParam; if (Resized != null && (size == UnmanagedMethods.SizeCommand.Restored || size == UnmanagedMethods.SizeCommand.Maximized)) { var clientSize = new Size(ToInt32(lParam) & 0xffff, ToInt32(lParam) >> 16); Resized(clientSize / Scaling); } var windowState = size == SizeCommand.Maximized ? WindowState.Maximized : (size == SizeCommand.Minimized ? WindowState.Minimized : WindowState.Normal); if (windowState != _lastWindowState) { _lastWindowState = windowState; WindowStateChanged?.Invoke(windowState); } return(IntPtr.Zero); case UnmanagedMethods.WindowsMessage.WM_MOVE: PositionChanged?.Invoke(new Point((short)(ToInt32(lParam) & 0xffff), (short)(ToInt32(lParam) >> 16))); return(IntPtr.Zero); case UnmanagedMethods.WindowsMessage.WM_GETMINMAXINFO: MINMAXINFO mmi = Marshal.PtrToStructure <UnmanagedMethods.MINMAXINFO>(lParam); if (_minSize.Width > 0) { mmi.ptMinTrackSize.X = (int)((_minSize.Width * Scaling) + BorderThickness.Left + BorderThickness.Right); } if (_minSize.Height > 0) { mmi.ptMinTrackSize.Y = (int)((_minSize.Height * Scaling) + BorderThickness.Top + BorderThickness.Bottom); } if (!Double.IsInfinity(_maxSize.Width) && _maxSize.Width > 0) { mmi.ptMaxTrackSize.X = (int)((_maxSize.Width * Scaling) + BorderThickness.Left + BorderThickness.Right); } if (!Double.IsInfinity(_maxSize.Height) && _maxSize.Height > 0) { mmi.ptMaxTrackSize.Y = (int)((_maxSize.Height * Scaling) + BorderThickness.Top + BorderThickness.Bottom); } Marshal.StructureToPtr(mmi, lParam, true); return(IntPtr.Zero); case UnmanagedMethods.WindowsMessage.WM_DISPLAYCHANGE: (Screen as ScreenImpl)?.InvalidateScreensCache(); return(IntPtr.Zero); } #if USE_MANAGED_DRAG if (_managedDrag.PreprocessInputEvent(ref e)) { return(UnmanagedMethods.DefWindowProc(hWnd, msg, wParam, lParam)); } #endif if (e != null && Input != null) { Input(e); if (e.Handled) { return(IntPtr.Zero); } } return(UnmanagedMethods.DefWindowProc(hWnd, msg, wParam, lParam)); }
/// <summary> /// /// </summary> /// <param name="m"></param> public W_截圖(MainWindow m, e_截圖類型 e_type) { this.M = m; //取得螢幕總其實坐標、總大小 int_螢幕起始坐標_x = 0; foreach (var screen in System.Windows.Forms.Screen.AllScreens) //列出所有螢幕資訊 { if (screen.Bounds.X < int_螢幕起始坐標_x) { int_螢幕起始坐標_x = screen.Bounds.X; } if (screen.Bounds.Y < int_螢幕起始坐標_y) { int_螢幕起始坐標_y = screen.Bounds.Y; } int yy = screen.Bounds.Y + screen.Bounds.Height; if (yy > d_螢幕_h) { d_螢幕_h = yy; } int xx = screen.Bounds.X + screen.Bounds.Width; if (xx > d_螢幕_w) { d_螢幕_w = xx; } } d_螢幕_w -= int_螢幕起始坐標_x; d_螢幕_h -= int_螢幕起始坐標_y; if (M.ShowInTaskbar && M.WindowState != WindowState.Minimized) { //截圖前記錄視窗狀態 ws_全螢幕前的狀態 = M.WindowState; d_記錄視窗位子 = M.Top; //避免全螢幕導致視窗無法隱藏 M.fun_鎖定視窗(true); M.WindowStyle = System.Windows.WindowStyle.None;//無邊框 M.WindowState = WindowState.Normal; M.Top = -5000; } this.Closed += (object sender, EventArgs e) => { if (M.ShowInTaskbar && M.WindowState != WindowState.Minimized) { M.Top = d_記錄視窗位子; M.WindowState = ws_全螢幕前的狀態; M.WindowStyle = System.Windows.WindowStyle.SingleBorderWindow; M.fun_鎖定視窗(false); } }; bimg = CaptureScreen();//全螢幕截圖 InitializeComponent(); this.Top = -5000; this.Show(); st_按鈕群.Visibility = Visibility.Hidden; /*var tim = new System.Windows.Forms.Timer(); * tim.Interval = 100; * tim.Tick += (sender, e) => {*/ func_初始化(e_type); /*tim.Stop(); * }; * tim.Start();*/ }
private void _SetRoundingRegion(WINDOWPOS?wp) { const int MONITOR_DEFAULTTONEAREST = 0x00000002; // We're early - WPF hasn't necessarily updated the state of the window. // Need to query it ourselves. WINDOWPLACEMENT wpl = NativeMethods.GetWindowPlacement(_hwnd); if (wpl.showCmd == SW.SHOWMAXIMIZED) { int left; int top; if (wp.HasValue) { left = wp.Value.x; top = wp.Value.y; } else { Rect r = _GetWindowRect(); left = (int)r.Left; top = (int)r.Top; } IntPtr hMon = NativeMethods.MonitorFromWindow(_hwnd, MONITOR_DEFAULTTONEAREST); MONITORINFO mi = NativeMethods.GetMonitorInfo(hMon); RECT rcMax = mi.rcWork; // The location of maximized window takes into account the border that Windows was // going to remove, so we also need to consider it. rcMax.Offset(-left, -top); IntPtr hrgn = NativeMethods.CreateRectRgnIndirect(rcMax); NativeMethods.SetWindowRgn(_hwnd, hrgn, NativeMethods.IsWindowVisible(_hwnd)); } else { int width; int height; // Use the size if it's specified. if (null != wp && !Utility.IsFlagSet(wp.Value.flags, (int)SWP.NOSIZE)) { width = wp.Value.cx; height = wp.Value.cy; } else if (null != wp && (_lastRoundingState == _window.WindowState)) { return; } else { Rect r = _GetWindowRect(); width = (int)r.Width; height = (int)r.Height; } _lastRoundingState = _window.WindowState; IntPtr hrgn = IntPtr.Zero; if (RoundCorners && 0 != RoundCornersRadius) { Point radius = DpiHelper.LogicalPixelsToDevice(new Point(RoundCornersRadius, RoundCornersRadius)); hrgn = NativeMethods.CreateRoundRectRgn(0, 0, width, height, (int)radius.X, (int)radius.Y); } else { hrgn = NativeMethods.CreateRectRgn(0, 0, width, height); } NativeMethods.SetWindowRgn(_hwnd, hrgn, NativeMethods.IsWindowVisible(_hwnd)); } }
IntPtr WindowProcedure(IntPtr handle, WindowMessage message, IntPtr wParam, IntPtr lParam) { switch (message) { #region Size / Move / Style events case WindowMessage.ACTIVATE: // See http://msdn.microsoft.com/en-us/library/ms646274(VS.85).aspx (WM_ACTIVATE notification): // wParam: The low-order word specifies whether the window is being activated or deactivated. bool new_focused_state = Focused; if (IntPtr.Size == 4) { focused = (wParam.ToInt32() & 0xFFFF) != 0; } else { focused = (wParam.ToInt64() & 0xFFFF) != 0; } if (new_focused_state != Focused) { FocusedChanged(this, EventArgs.Empty); } break; case WindowMessage.ENTERMENULOOP: case WindowMessage.ENTERSIZEMOVE: // Entering the modal size/move loop: we don't want rendering to // stop during this time, so we register a timer callback to continue // processing from time to time. StartTimer(handle); break; case WindowMessage.EXITMENULOOP: case WindowMessage.EXITSIZEMOVE: // ExitingmModal size/move loop: the timer callback is no longer // necessary. StopTimer(handle); break; case WindowMessage.ERASEBKGND: return(new IntPtr(1)); case WindowMessage.WINDOWPOSCHANGED: unsafe { WindowPosition *pos = (WindowPosition *)lParam; if (window != null && pos->hwnd == window.WindowHandle) { Point new_location = new Point(pos->x, pos->y); if (Location != new_location) { bounds.Location = new_location; Move(this, EventArgs.Empty); } Size new_size = new Size(pos->cx, pos->cy); if (Size != new_size) { bounds.Width = pos->cx; bounds.Height = pos->cy; Win32Rectangle rect; Functions.GetClientRect(handle, out rect); client_rectangle = rect.ToRectangle(); Functions.SetWindowPos(child_window.WindowHandle, IntPtr.Zero, 0, 0, ClientRectangle.Width, ClientRectangle.Height, SetWindowPosFlags.NOZORDER | SetWindowPosFlags.NOOWNERZORDER | SetWindowPosFlags.NOACTIVATE | SetWindowPosFlags.NOSENDCHANGING); if (suppress_resize <= 0) { Resize(this, EventArgs.Empty); } } // Ensure cursor remains grabbed if (!CursorVisible) { GrabCursor(); } } } break; case WindowMessage.STYLECHANGED: unsafe { if (wParam.ToInt64() == (long)GWL.STYLE) { WindowStyle style = ((StyleStruct *)lParam)->New; if ((style & WindowStyle.Popup) != 0) { windowBorder = WindowBorder.Hidden; } else if ((style & WindowStyle.ThickFrame) != 0) { windowBorder = WindowBorder.Resizable; } else if ((style & ~(WindowStyle.ThickFrame | WindowStyle.MaximizeBox)) != 0) { windowBorder = WindowBorder.Fixed; } } } // Ensure cursor remains grabbed if (!CursorVisible) { GrabCursor(); } break; case WindowMessage.SIZE: SizeMessage state = (SizeMessage)wParam.ToInt64(); WindowState new_state = windowState; switch (state) { case SizeMessage.RESTORED: new_state = borderless_maximized_window_state ? WindowState.Maximized : WindowState.Normal; break; case SizeMessage.MINIMIZED: new_state = WindowState.Minimized; break; case SizeMessage.MAXIMIZED: new_state = WindowBorder == WindowBorder.Hidden ? WindowState.Fullscreen : WindowState.Maximized; break; } if (new_state != windowState) { windowState = new_state; WindowStateChanged(this, EventArgs.Empty); } // Ensure cursor remains grabbed if (!CursorVisible) { GrabCursor(); } break; #endregion #region Input events case WindowMessage.CHAR: if (IntPtr.Size == 4) { key_press.KeyChar = (char)wParam.ToInt32(); } else { key_press.KeyChar = (char)wParam.ToInt64(); } KeyPress(this, key_press); break; case WindowMessage.MOUSEMOVE: Point point = new Point( (short)((uint)lParam.ToInt32() & 0x0000FFFF), (short)(((uint)lParam.ToInt32() & 0xFFFF0000) >> 16)); mouse.Position = point; if (mouse_outside_window) { // Once we receive a mouse move event, it means that the mouse has // re-entered the window. mouse_outside_window = false; EnableMouseTracking(); MouseEnter(this, EventArgs.Empty); } break; case WindowMessage.MOUSELEAVE: mouse_outside_window = true; // Mouse tracking is disabled automatically by the OS MouseLeave(this, EventArgs.Empty); break; case WindowMessage.MOUSEWHEEL: // This is due to inconsistent behavior of the WParam value on 64bit arch, whese // wparam = 0xffffffffff880000 or wparam = 0x00000000ff100000 mouse.WheelPrecise += ((long)wParam << 32 >> 48) / 120.0f; break; case WindowMessage.LBUTTONDOWN: Functions.SetCapture(window.WindowHandle); mouse[MouseButton.Left] = true; break; case WindowMessage.MBUTTONDOWN: Functions.SetCapture(window.WindowHandle); mouse[MouseButton.Middle] = true; break; case WindowMessage.RBUTTONDOWN: Functions.SetCapture(window.WindowHandle); mouse[MouseButton.Right] = true; break; case WindowMessage.XBUTTONDOWN: Functions.SetCapture(window.WindowHandle); mouse[((wParam.ToInt32() & 0xFFFF0000) >> 16) != (int)MouseKeys.XButton1 ? MouseButton.Button1 : MouseButton.Button2] = true; break; case WindowMessage.LBUTTONUP: Functions.ReleaseCapture(); mouse[MouseButton.Left] = false; break; case WindowMessage.MBUTTONUP: Functions.ReleaseCapture(); mouse[MouseButton.Middle] = false; break; case WindowMessage.RBUTTONUP: Functions.ReleaseCapture(); mouse[MouseButton.Right] = false; break; case WindowMessage.XBUTTONUP: Functions.ReleaseCapture(); mouse[((wParam.ToInt32() & 0xFFFF0000) >> 16) != (int)MouseKeys.XButton1 ? MouseButton.Button1 : MouseButton.Button2] = false; break; // Keyboard events: case WindowMessage.KEYDOWN: case WindowMessage.KEYUP: case WindowMessage.SYSKEYDOWN: case WindowMessage.SYSKEYUP: bool pressed = message == WindowMessage.KEYDOWN || message == WindowMessage.SYSKEYDOWN; // Shift/Control/Alt behave strangely when e.g. ShiftRight is held down and ShiftLeft is pressed // and released. It looks like neither key is released in this case, or that the wrong key is // released in the case of Control and Alt. // To combat this, we are going to release both keys when either is released. Hacky, but should work. // Win95 does not distinguish left/right key constants (GetAsyncKeyState returns 0). // In this case, both keys will be reported as pressed. bool extended = (lParam.ToInt64() & ExtendedBit) != 0; switch ((VirtualKeys)wParam) { case VirtualKeys.SHIFT: // The behavior of this key is very strange. Unlike Control and Alt, there is no extended bit // to distinguish between left and right keys. Moreover, pressing both keys and releasing one // may result in both keys being held down (but not always). // The only reliable way to solve this was reported by BlueMonkMN at the forums: we should // check the scancodes. It looks like GLFW does the same thing, so it should be reliable. // Note: we release both keys when either shift is released. // Otherwise, the state of one key might be stuck to pressed. if (ShiftRightScanCode != 0 && pressed) { unchecked { if (((lParam.ToInt64() >> 16) & 0xFF) == ShiftRightScanCode) { keyboard[Input.Key.ShiftRight] = pressed; } else { keyboard[Input.Key.ShiftLeft] = pressed; } } } else { // Windows 9x and NT4.0 or key release event. keyboard[Input.Key.ShiftLeft] = keyboard[Input.Key.ShiftRight] = pressed; } return(IntPtr.Zero); case VirtualKeys.CONTROL: if (extended) { keyboard[Input.Key.ControlRight] = pressed; } else { keyboard[Input.Key.ControlLeft] = pressed; } return(IntPtr.Zero); case VirtualKeys.MENU: if (extended) { keyboard[Input.Key.AltRight] = pressed; } else { keyboard[Input.Key.AltLeft] = pressed; } return(IntPtr.Zero); case VirtualKeys.RETURN: if (extended) { keyboard[Key.KeypadEnter] = pressed; } else { keyboard[Key.Enter] = pressed; } return(IntPtr.Zero); default: if (!KeyMap.ContainsKey((VirtualKeys)wParam)) { Debug.Print("Virtual key {0} ({1}) not mapped.", (VirtualKeys)wParam, (long)lParam); break; } else { keyboard[KeyMap[(VirtualKeys)wParam]] = pressed; } return(IntPtr.Zero); } break; case WindowMessage.SYSCHAR: return(IntPtr.Zero); case WindowMessage.KILLFOCUS: keyboard.ClearKeys(); break; #endregion #region Creation / Destruction events case WindowMessage.CREATE: CreateStruct cs = (CreateStruct)Marshal.PtrToStructure(lParam, typeof(CreateStruct)); if (cs.hwndParent == IntPtr.Zero) { bounds.X = cs.x; bounds.Y = cs.y; bounds.Width = cs.cx; bounds.Height = cs.cy; Win32Rectangle rect; Functions.GetClientRect(handle, out rect); client_rectangle = rect.ToRectangle(); invisible_since_creation = true; } break; case WindowMessage.CLOSE: System.ComponentModel.CancelEventArgs e = new System.ComponentModel.CancelEventArgs(); Closing(this, e); if (!e.Cancel) { DestroyWindow(); break; } return(IntPtr.Zero); case WindowMessage.DESTROY: exists = false; Functions.UnregisterClass(ClassName, Instance); window.Dispose(); child_window.Dispose(); Closed(this, EventArgs.Empty); break; #endregion } return(Functions.DefWindowProc(handle, message, wParam, lParam)); }
/// <summary> /// Sets window state /// </summary> public virtual void SetWindowState(WindowState windowState) { }
void ICurrentWindowService.SetWindowState(WindowState state) { ActualWindow.Do(x => x.WindowState = state); }
public static void SetWindowState(IntPtr hWnd, WindowState windowState) { ShowWindow(hWnd, (int)windowState); }
public GameBuilder SetWindowState(WindowState state) { _game.WindowState = state; return(this); }
protected virtual Tuple <WindowStyles, WindowExStyles, ShowWindowCommand> GetWindowStyles(WindowState state) { if (_options.UseCustomStyle && _options != null && _options.CustomStyle.IsValid()) { return(GetWindowStyles(_options.CustomStyle, state)); } var styles = WindowStyles.WS_OVERLAPPEDWINDOW | WindowStyles.WS_CLIPCHILDREN | WindowStyles.WS_CLIPSIBLINGS; var exStyles = WindowExStyles.WS_EX_APPWINDOW | WindowExStyles.WS_EX_WINDOWEDGE; if (_options.DisableResizing) { styles = WindowStyles.WS_OVERLAPPEDWINDOW & ~WindowStyles.WS_THICKFRAME | WindowStyles.WS_CLIPCHILDREN | WindowStyles.WS_CLIPSIBLINGS; styles &= ~WindowStyles.WS_MAXIMIZEBOX; } if (_options.DisableMinMaximizeControls) { styles &= ~WindowStyles.WS_MINIMIZEBOX; styles &= ~WindowStyles.WS_MAXIMIZEBOX; } if (_options.WindowFrameless) { styles = WindowStyles.WS_POPUPWINDOW | WindowStyles.WS_CLIPCHILDREN | WindowStyles.WS_CLIPSIBLINGS; styles |= WindowStyles.WS_SIZEBOX; } if (_options.KioskMode) { styles &= ~(WindowStyles.WS_CAPTION | WindowStyles.WS_THICKFRAME); exStyles &= ~(WindowExStyles.WS_EX_DLGMODALFRAME | WindowExStyles.WS_EX_WINDOWEDGE | WindowExStyles.WS_EX_CLIENTEDGE | WindowExStyles.WS_EX_STATICEDGE); } switch (state) { case WindowState.Normal: return(new Tuple <WindowStyles, WindowExStyles, ShowWindowCommand>(styles, exStyles, ShowWindowCommand.SW_SHOWNORMAL)); case WindowState.Maximize: { styles |= WindowStyles.WS_MAXIMIZE; return(new Tuple <WindowStyles, WindowExStyles, ShowWindowCommand>(styles, exStyles, ShowWindowCommand.SW_SHOWMAXIMIZED)); } case WindowState.Fullscreen: { styles |= WindowStyles.WS_MAXIMIZE; exStyles = WindowExStyles.WS_EX_TOOLWINDOW; return(new Tuple <WindowStyles, WindowExStyles, ShowWindowCommand>(styles, exStyles, ShowWindowCommand.SW_SHOWMAXIMIZED)); } } return(new Tuple <WindowStyles, WindowExStyles, ShowWindowCommand>(styles, exStyles, ShowWindowCommand.SW_SHOWNORMAL)); }
public WindowStateAction(WindowState state) { State = state; }
partial void AfterWindowStateChanged() { Settings.Default.Main_WindowState = WindowState.ToString(); }
/// <summary> Sets window state. Maximise / Minimize / Restore. </summary> /// <param name="state"> The state to set. </param> /// <returns> True if it succeeds, false if it fails. </returns> public bool SetWindowState(WindowState state) { // TODO required for frameless Maccocoa mode return(false); }
/// <summary> /// Executes the minimize command. /// </summary> /// <param name="param">not used.</param> private void ExecuteMinimizeCommand(object param) { this.WindowState = WindowState.Minimized; }
public void Close() { WindowState = WindowState.Closed; }
private void Initialize(Game game) { Game = game; GraphicsContext.ShareContexts = true; window = new NativeWindow(); window.WindowBorder = WindowBorder.Resizable; window.Closing += new EventHandler <CancelEventArgs>(OpenTkGameWindow_Closing); window.Resize += OnResize; window.KeyDown += new EventHandler <OpenTK.Input.KeyboardKeyEventArgs>(Keyboard_KeyDown); window.KeyUp += new EventHandler <OpenTK.Input.KeyboardKeyEventArgs>(Keyboard_KeyUp); window.KeyPress += OnKeyPress; var assembly = Assembly.GetEntryAssembly(); var t = Type.GetType("Mono.Runtime"); Title = assembly != null?AssemblyHelper.GetDefaultWindowTitle() : "MonoGame Application"; // In case when DesktopGL dll is compiled using .Net, and you // try to load it using Mono, it will cause a crash because of this. try { if (t == null && assembly != null) { window.Icon = Icon.ExtractAssociatedIcon(assembly.Location); } else { using (var stream = Assembly.GetEntryAssembly().GetManifestResourceStream(string.Format("{0}.Icon.ico", Assembly.GetEntryAssembly().EntryPoint.DeclaringType.Namespace)) ?? Assembly.GetExecutingAssembly().GetManifestResourceStream("Microsoft.Xna.Framework.monogame.ico")) { if (stream != null) { window.Icon = new Icon(stream); } } } } catch { } updateClientBounds = false; clientBounds = new Rectangle(window.ClientRectangle.X, window.ClientRectangle.Y, window.ClientRectangle.Width, window.ClientRectangle.Height); windowState = window.WindowState; _windowHandle = window.WindowInfo.Handle; keys = new List <Keys>(); // mouse // TODO review this when opentk 1.1 is released #if DESKTOPGL || ANGLE Mouse.setWindows(this); #else Mouse.UpdateMouseInfo(window.Mouse); #endif // Default no resizing AllowUserResizing = false; // Default mouse cursor hidden SetMouseVisible(false); }
public void Show() { WindowState = WindowState.Open; }
/// <summary>Initializes a new instance of the <see cref="WindowManager" /> class.</summary> public WindowManager() { windowState = WindowState.Normal; resolution = new Vector2(1024, 640); current = this; }
protected virtual void OnWindowStateChanged(WindowState windowState) => WindowStateChanged?.Invoke(windowState);