public WindowMessage(string text, WindowPosition position = WindowPosition.Down, bool slowText = false) { Height = 40; Width = 150; switch (position) { case WindowPosition.Up: Position = new Vector2(5,5); break; case WindowPosition.Down: Position = new Vector2(5,85); break; } SplitMessage(text); }
/// <summary> /// Docks the form to the scanner form in the relative /// position specified /// </summary> /// <param name="form">form to dock</param> /// <param name="scanner">scanner form to dock to</param> /// <param name="scannerPosition">relative position</param> public static void DockWithScanner(Form form, Form scanner, WindowPosition scannerPosition) { if (form == scanner) { return; } switch (scannerPosition) { case WindowPosition.TopRight: form.Location = new Point(scanner.Left - form.Width, scanner.Top); break; case WindowPosition.TopLeft: form.Location = new Point(scanner.Left + scanner.Width, scanner.Top); break; case WindowPosition.BottomLeft: form.Location = new Point(scanner.Left + scanner.Width, Screen.PrimaryScreen.WorkingArea.Height - form.Height); break; case WindowPosition.BottomRight: form.Location = new Point(scanner.Left - form.Width, Screen.PrimaryScreen.WorkingArea.Height - form.Height); break; case WindowPosition.MiddleRight: form.Location = new Point(scanner.Left - form.Width, (Screen.PrimaryScreen.WorkingArea.Height - form.Height) / 2); break; case WindowPosition.MiddleLeft: form.Location = new Point(scanner.Width, (Screen.PrimaryScreen.WorkingArea.Height - form.Height) / 2); break; } }
/// <summary> /// Partial maximize. Sets the window width to /// a percent of the display width. /// </summary> /// <param name="handle">handle of the window</param> /// <param name="scannerPosition">which corner should the window be positioned at?</param> /// <param name="percent">percentage of display monitor width</param> public static void SetWindowSizePercent(IntPtr handle, WindowPosition scannerPosition, int percent) { Log.Debug("Entering...scannerPosition=" + scannerPosition.ToString() + " percent=" + percent.ToString()); int screenOffset = 0; int moveX = 0; int moveY = 0; // not really using Y-axis yet but something to keep in mind for the future if (percent <= 10) { return; } if (percent > 100) percent = 100; screenOffset = 100 - percent; if (handle != IntPtr.Zero) { Rectangle r = Screen.PrimaryScreen.WorkingArea; if (r.Width > 0 && r.Height > 0) { Log.Debug("Resize window to " + (r.Width * percent) / 100 + ", " + r.Height); switch (scannerPosition) { case WindowPosition.TopRight: moveX = 0; moveY = 0; break; case WindowPosition.TopLeft: moveX = (r.Width * screenOffset) / 100; moveY = 0; break; case WindowPosition.BottomLeft: moveX = (r.Width * screenOffset) / 100; moveY = 0; break; case WindowPosition.BottomRight: moveX = 0; moveY = 0; break; } Log.Debug("screenOffset=" + screenOffset + " moveX=" + moveX.ToString() + " moveY=" + moveY.ToString()); User32Interop.SetWindowPos(handle.ToInt32(), 0, moveX, moveY, (r.Width * percent) / 100, r.Height, 0x0040 | 0x0004); } } else { Log.Debug("fgWnd is zero"); } }
/// <summary> /// Set window pos to the specified position and notify when window position /// has changed /// </summary> /// <param name="form">The form</param> /// <param name="position">Where to set the position</param> public static void SetWindowPositionAndNotify(Form form, WindowPosition position) { Log.Debug("Setting position to " + position); SetWindowPosition(form, position); if (EvtWindowPositionChanged != null) { Log.Debug("Calling evtpositionchanged with " + position); EvtWindowPositionChanged(form, position); } }
/// <summary> /// Set the window position /// </summary> /// <param name="form">form to reposition</param> /// <param name="position">the new position</param> public static void SetWindowPosition(Form form, WindowPosition position) { form.StartPosition = FormStartPosition.Manual; Log.Debug("Before setposition " + position); switch (position) { case WindowPosition.TopRight: form.Location = new Point(Screen.PrimaryScreen.WorkingArea.Width - form.Width, 0); break; case WindowPosition.TopLeft: form.Location = new Point(0, 0); break; case WindowPosition.BottomRight: form.Location = new Point(Screen.PrimaryScreen.WorkingArea.Width - form.Width, Screen.PrimaryScreen.WorkingArea.Height - form.Height); break; case WindowPosition.BottomLeft: form.Location = new Point(0, Screen.PrimaryScreen.WorkingArea.Height - form.Height); break; case WindowPosition.MiddleRight: form.Location = new Point(Screen.PrimaryScreen.WorkingArea.Width - form.Width, (Screen.PrimaryScreen.WorkingArea.Height - form.Height) / 2); break; case WindowPosition.MiddleLeft: form.Location = new Point(0, (Screen.PrimaryScreen.WorkingArea.Height - form.Height) / 2); break; case WindowPosition.CenterScreen: form.Location = new Point((Screen.PrimaryScreen.WorkingArea.Width - form.Width) / 2, (Screen.PrimaryScreen.WorkingArea.Height - form.Height) / 2); break; } Log.Debug("After setposition " + position); }
public static void MoveWindow( WindowPosition p ) { MoveWindow(p, 0, 0); }
public static void MoveWindow( WindowPosition p ) { if (p == WindowPosition.NotSet) { return; } else if (p == WindowPosition.Minimized) { // TODO throw new NotImplementedException(); } else if (p == WindowPosition.Restore) { // TODO throw new NotImplementedException(); } IntPtr hWin; Rect rc; Screen scr; int maxColWidth = Console.LargestWindowWidth - 4, maxColHeight = Console.LargestWindowHeight - 1; hWin = GetConsoleWindow(); GetWindowRect(hWin, out rc); scr = Screen.FromPoint(new Point(rc.left, rc.top)); int cols = Console.WindowWidth, rows = Console.WindowHeight; int x = rc.left, y = rc.top; // Figure out the window size. if (p == WindowPosition.Center) { cols = Console.WindowWidth; } else if (p == WindowPosition.Top || p == WindowPosition.Bottom || p == WindowPosition.Maximized) { cols = maxColWidth; } else if (p == WindowPosition.TopRight || p == WindowPosition.Right || p == WindowPosition.BottomRight || p == WindowPosition.TopLeft || p == WindowPosition.Left || p == WindowPosition.BottomLeft) { cols = (int)Math.Round(maxColWidth / 2F, 0); } if (p == WindowPosition.Center) { rows = Console.WindowHeight; } else if (p == WindowPosition.Left || p == WindowPosition.Right || p == WindowPosition.Maximized) { rows = maxColHeight; } else if (p == WindowPosition.TopLeft || p == WindowPosition.Top || p == WindowPosition.TopRight || p == WindowPosition.BottomLeft || p == WindowPosition.Bottom || p == WindowPosition.BottomRight) { rows = (int)Math.Round(maxColHeight / 2F, 0); } // Set the window size.. if (cols > Console.BufferWidth) { Console.BufferWidth = cols; } Console.WindowWidth = cols; Console.BufferWidth = cols; if (rows > Console.BufferHeight) { Console.BufferHeight = rows; } Console.WindowHeight = rows; if (p == WindowPosition.Maximized || p == WindowPosition.Center) { ConsoleUtils.CenterWindow(); } else { // Figure out the window location. if (p == WindowPosition.Top || p == WindowPosition.Bottom || p == WindowPosition.TopLeft || p == WindowPosition.Left || p == WindowPosition.BottomLeft) { x = scr.WorkingArea.Left; } else if (p == WindowPosition.TopRight || p == WindowPosition.Right || p == WindowPosition.BottomRight) { x = (int)Math.Round(scr.WorkingArea.Width / 2F, 0); } if (p == WindowPosition.Left || p == WindowPosition.Right || p == WindowPosition.TopLeft || p == WindowPosition.Top || p == WindowPosition.TopRight) { y = scr.WorkingArea.Top; } else if (p == WindowPosition.BottomLeft || p == WindowPosition.Bottom || p == WindowPosition.BottomRight) { y = (int)Math.Round(scr.WorkingArea.Height / 2F, 0); } // Set the window location.. MoveWindow(x, y); } }
public static void SetNegativePosition(DependencyObject obj, WindowPosition value) { obj.SetValue(NegativePositionProperty, value); }
private EventHandler GetWindowPositionEventHandler(WindowPosition position) { switch (position) { case WindowPosition.LeftOneThird: return LeftThird_EventHandler; case WindowPosition.LeftHalf: return LeftHalf_EventHandler; case WindowPosition.LeftTwoThirds: return LeftTwoThirds_EventHandler; case WindowPosition.RightOneThird: return RightThird_EventHandler; case WindowPosition.RightHalf: return RightHalf_EventHandler; case WindowPosition.RightTwoThirds: return RightTwoThirds_EventHandler; case WindowPosition.TopHalf: return TopHalf_EventHandler; case WindowPosition.BottomHalf: return BottomHalf_EventHandler; case WindowPosition.Center: return Center_EventHandler; case WindowPosition.Fill: return Fill_EventHandler; default: return Fill_EventHandler; } }
public static extern void gtk_window_set_position(IntPtr self, WindowPosition window);
private static void WindowParametryChanged(DependencyObject d, DependencyPropertyChangedEventArgs a) { if (d is Window) { Window w = d as Window; var size = System.Windows.Forms.Screen.AllScreens[GetWindowScreen(w)].Bounds.Size; var location = System.Windows.Forms.Screen.AllScreens[GetWindowScreen(w)].Bounds.Location; WindowPosition position = GetWindowPosition(d); w.SizeChanged -= WindowRight_SizeChanged; w.SizeChanged -= WindowBottom_SizeChanged; Thickness th = GetWindowThickness(w); Point indent = new Point(); if (w.Owner != null) { position = WindowPositionBehaviour.GetWindowPosition(w.Owner); switch (WindowPositionBehaviour.GetWindowPosition(w.Owner)) { case WindowPosition.Left: case WindowPosition.LeftBottom: case WindowPosition.LeftTop: indent.X = w.Owner.Width + (HideButtonBehaviour.GetUseHideButton(w.Owner) ? -30 + w.Owner.Left - location.X - 6 : 0); break; case WindowPosition.Right: case WindowPosition.RightBottom: case WindowPosition.RightTop: indent.X = -(w.Owner.Width - (HideButtonBehaviour.GetUseHideButton(w.Owner) ? 30 : 0)); break; case WindowPosition.Top: indent.Y = w.Owner.Height + (HideButtonBehaviour.GetUseHideButton(w.Owner) ? -30 + w.Owner.Top - location.Y - 6 : 0); break; case WindowPosition.Bottom: indent.Y = -w.Owner.Height + (HideButtonBehaviour.GetUseHideButton(w.Owner) ? 30 : 0); break; } } switch (position) { case WindowPosition.Left: w.SizeToContent = SizeToContent.Height; w.Left = location.X + th.Left + indent.X; w.Top = location.Y + th.Top + indent.Y;; w.SizeChanged -= WindowRightBottom_SizeChanged; w.SizeChanged -= WindowRight_SizeChanged; w.SizeChanged -= WindowBottom_SizeChanged; break; case WindowPosition.Right: w.SizeToContent = SizeToContent.Height; w.Left = location.X + size.Width + th.Left - th.Right - NTW.Common.GetIndentTaskBar(false) + indent.X; w.Top = location.Y + th.Top + indent.Y; w.SizeChanged -= WindowRightBottom_SizeChanged; w.SizeChanged -= WindowBottom_SizeChanged; w.SizeChanged += WindowRight_SizeChanged; break; case WindowPosition.Top: w.SizeToContent = SizeToContent.Width; w.Left = location.X + th.Left + indent.X; w.Top = location.Y + th.Top + indent.Y; w.SizeChanged -= WindowRightBottom_SizeChanged; w.SizeChanged -= WindowRight_SizeChanged; w.SizeChanged -= WindowBottom_SizeChanged; break; case WindowPosition.Bottom: w.SizeToContent = SizeToContent.Width; w.Left = location.X + th.Left + indent.X; w.Top = location.Y * 2 + size.Height + th.Top - th.Bottom - NTW.Common.GetIndentTaskBar(true) + indent.Y; w.SizeChanged -= WindowRightBottom_SizeChanged; w.SizeChanged -= WindowRight_SizeChanged; w.SizeChanged += WindowBottom_SizeChanged; break; case WindowPosition.None: break; case WindowPosition.LeftTop: w.SizeToContent = SizeToContent.WidthAndHeight; w.Left = location.X + th.Left + indent.X; w.Top = location.Y + th.Top + indent.Y; w.SizeChanged -= WindowRightBottom_SizeChanged; w.SizeChanged -= WindowRight_SizeChanged; w.SizeChanged -= WindowBottom_SizeChanged; break; case WindowPosition.LeftBottom: w.SizeToContent = SizeToContent.WidthAndHeight; w.Left = location.X + th.Left + indent.X; w.Top = location.Y + size.Height + th.Top - th.Bottom - NTW.Common.GetIndentTaskBar(true) + indent.Y; w.SizeChanged -= WindowRightBottom_SizeChanged; w.SizeChanged -= WindowRight_SizeChanged; w.SizeChanged += WindowBottom_SizeChanged; break; case WindowPosition.RightTop: w.SizeToContent = SizeToContent.WidthAndHeight; w.Left = location.X + size.Width + th.Left - th.Right - NTW.Common.GetIndentTaskBar(false) + indent.X; w.Top = location.Y + th.Top + indent.Y; w.SizeChanged -= WindowBottom_SizeChanged; w.SizeChanged -= WindowRightBottom_SizeChanged; w.SizeChanged += WindowRight_SizeChanged; break; case WindowPosition.RightBottom: w.SizeToContent = SizeToContent.WidthAndHeight; w.Left = location.X + size.Width + th.Left - th.Right - NTW.Common.GetIndentTaskBar(false) + indent.X; w.Top = location.Y + size.Height + th.Top - th.Bottom - NTW.Common.GetIndentTaskBar(true) + indent.Y; w.SizeChanged -= WindowRight_SizeChanged; w.SizeChanged -= WindowBottom_SizeChanged; w.SizeChanged += WindowRightBottom_SizeChanged; break; } } }
public static void SetMinOnParentPosition(DependencyObject element, WindowPosition value) { element.SetValue(MinOnParentPositionProperty, value); }
/// <summary> /// Sets the window position, z-order. /// </summary> /// <param name="handle">The window handle.</param> /// <param name="insertAfter">Z-Order flags</param> /// <param name="bounds">The new position and size.</param> /// <param name="flags">Options for showing the window.</param> /// <returns></returns> public static bool SetWindowPos(IWin32Window handle, IntPtr insertAfter, Rectangle bounds, WindowPosition flags) { return UnsafeNativeMethods.SetWindowPos(new HandleRef(handle, handle.Handle), new HandleRef(handle, insertAfter), bounds.X, bounds.Y, bounds.Width, bounds.Height, (int) flags); }
void WritePos(WindowPosition pos, int buf) { if (1 == pos.Offset) { uint pixel = m_input[buf]; if (1 == pos.Length || -1 == Array.FindIndex (m_input, buf+1, pos.Length-1, x => x != pixel)) { m_out.Write ((byte)0); m_out.Write ((byte)pos.Length); } else { m_out.Write ((byte)1); m_out.Write ((byte)pos.Length); m_out.Write ((byte)1); } } else if (1 == pos.Length) { if (pos.Offset < 0x100) { m_out.Write ((byte)3); m_out.Write ((byte)pos.Offset); } else { m_out.Write ((byte)4); m_out.Write (pos.Offset); } } else if (pos.Offset < 0x100) { m_out.Write ((byte)1); m_out.Write ((byte)pos.Length); m_out.Write ((byte)pos.Offset); } else { m_out.Write ((byte)2); m_out.Write ((byte)pos.Length); m_out.Write (pos.Offset); } }
public static void SetTargetPosition(DependencyObject obj, WindowPosition value) { obj.SetValue(TargetPositionProperty, value); }
protected override void OnInitialized(EventArgs e) { WindowPosition.Move(this); base.OnInitialized(e); }
/// <summary> /// Set media window /// </summary> /// <param name="MediaWindow">Media window</param> /// <param name="Width">Floating window width</param> /// <param name="Height">Floating window height</param> /// <param name="Position">Floating window position</param> /// <param name="TitleBar">Floating window title bar</param> /// <param name="Resize">Floating window resize</param> /// <param name="Title">Floating window title</param> /// <remarks> /// <para> /// All optional arguments are applicable to floating window only. /// </para> /// </remarks> public void SetMediaWindow( MediaWindow MediaWindow, Int32 Width = 0, Int32 Height = 0, WindowPosition Position = WindowPosition.Center, WindowTitleBar TitleBar = WindowTitleBar.TitleBarWithCloseButton, WindowResize Resize = WindowResize.KeepAspectRatio, String Title = null ) { // set media play window code MediaScreenParamBE.AddInteger("/W", (Int32) MediaWindow); // all choices but floating window if(MediaWindow != MediaWindow.Floating) { MediaScreenParamBE.Remove("/F"); return; } // play rendition in floating window // Table 9.19 page 774 PdfDictionary FloatingWindow = new PdfDictionary(this); MediaScreenParamBE.AddDictionary("/F", FloatingWindow); // window's dimensions if(Width == 0 || Height == 0) { Width = 320; Height = 180; } FloatingWindow.AddFormat("/D", "[{0} {1}]", Width, Height); FloatingWindow.AddInteger("/P", (Int32) Position); FloatingWindow.AddBoolean("/T", TitleBar != WindowTitleBar.NoTitleBar); if(TitleBar == WindowTitleBar.NoTitleBar) return; FloatingWindow.AddInteger("/R", (Int32) Resize); if(Title != null) { // if(Document.Encryption == null) // { // FloatingWindow.AddFormat("/TT", "[() ({0})]", Title); // } // else // { FloatingWindow.AddFormat("/TT", "[{0} {1}]", Document.TextToPdfString(String.Empty, this), Document.TextToPdfString(Title, this)); // } } return; }
private void Load(XmlReader reader, Form mainForm) { var comparer = StringComparison.OrdinalIgnoreCase; List <SvgTestSuite> testSuites = new List <SvgTestSuite>(SvgTestSuite.TestSuiteCount); while (reader.Read()) { if (reader.NodeType == XmlNodeType.Element) { if (string.Equals(reader.Name, "option", comparer)) { string optionName = reader.GetAttribute("name"); string optionType = reader.GetAttribute("type"); if (string.Equals(optionType, "String", comparer)) { string optionValue = reader.ReadElementContentAsString(); switch (optionName) { //case "WebSuitePath": // _webSuitePath = optionValue; // break; //case "LocalSuitePath": // if (optionValue.StartsWith(ParentSymbol, comparer)) // { // var inputPath = string.Copy(_localSuitePath); // int indexOf = inputPath.IndexOf(SharpVectors, comparer); // if (indexOf > 0) // { // var basePath = inputPath.Substring(0, indexOf); // _localSuitePath = Path.Combine(basePath, optionValue.Replace(ParentSymbol, "")); // } // else // { // _localSuitePath = optionValue; // } // } // else // { // _localSuitePath = optionValue; // } // // Ignore old test suite directory, if found // if (string.IsNullOrWhiteSpace(_localSuitePath) || // !this.IsLocalSuitePathChanged(Path.GetFullPath(TestsSvg))) // { // _localSuitePath = Path.GetFullPath(TestsSvg10); // } // break; case "SelectedValuePath": _selectedValuePath = optionValue; break; } } else if (string.Equals(optionType, "Boolean", comparer)) { bool optionValue = reader.ReadElementContentAsBoolean(); switch (optionName) { case "HidePathsRoot": _hidePathsRoot = optionValue; break; } } else if (string.Equals(optionType, "Other", comparer)) { string optionValue = reader.ReadElementContentAsString(); switch (optionName) { case "Theme": _theme = (DockingTheme)Enum.Parse(typeof(DockingTheme), optionValue, true); break; } } } else if (string.Equals(reader.Name, "testSuite", comparer)) { if (!reader.IsEmptyElement) { SvgTestSuite testSuite = new SvgTestSuite(reader); if (testSuite.IsValid()) { testSuites.Add(testSuite); } } } else if (string.Equals(reader.Name, "placements", comparer)) { if (reader.IsEmptyElement == false) { if (reader.ReadToFollowing("WindowPosition")) { var xs = new XmlSerializer(typeof(WindowPosition)); _winPosition = xs.Deserialize(reader) as WindowPosition; } } } } } if (testSuites.Count == SvgTestSuite.TestSuiteCount) { var selectedSuite = SvgTestSuite.GetSelected(testSuites); if (selectedSuite != null) { _localSuitePath = selectedSuite.LocalSuitePath; _webSuitePath = selectedSuite.WebSuitePath; _testSuites = testSuites; } } if (mainForm != null && _winPosition != null) { try { switch (_winPosition.WindowState) { case FormWindowState.Maximized: mainForm.Location = _winPosition.MaximisedPoint; mainForm.StartPosition = FormStartPosition.Manual; break; case FormWindowState.Normal: if (_winPosition.IsIdenticalScreen()) { mainForm.Location = _winPosition.Location; mainForm.Size = _winPosition.Size; mainForm.StartPosition = FormStartPosition.Manual; } break; case FormWindowState.Minimized: _winPosition.WindowState = FormWindowState.Normal; break; default: break; } mainForm.WindowState = _winPosition.WindowState; } catch (Exception ex) { Trace.TraceError(ex.ToString()); } } }
public WindowPosition Clone() { WindowPosition cloned = new WindowPosition(this); return(cloned); }
public static void SetHideButtonPosition(DependencyObject element, WindowPosition value) { element.SetValue(HideButtonPositionProperty, value); }
WindowPosition FindLongest(int win_begin, int win_end, int buf_begin, int buf_end) { buf_end = Math.Min (buf_begin + MaxMatchSize, buf_end); WindowPosition pos = new WindowPosition { Offset = 0, Length = 0 }; if (win_begin == win_end) return pos; SortedSet<int> found; if (m_dict.TryGetValue (m_input[buf_begin], out found)) { foreach (var win_pos in found.Reverse()) { var match_end = Mismatch (buf_begin+1, buf_end, win_pos+1); int weight = match_end - win_pos; int distance = buf_begin - win_pos; if (weight > pos.Length) { pos.Offset = (ushort)distance; pos.Length = (ushort)weight; if (MaxMatchSize == weight) break; } } } return pos; }
public static void MoveWindow(WindowPosition p) { if (p == WindowPosition.NotSet) { return; } else if (p == WindowPosition.Minimized) { // TODO throw new NotImplementedException(); } else if (p == WindowPosition.Restore) { // TODO throw new NotImplementedException(); } IntPtr hWin; Rect rc; Screen scr; int maxColWidth = Console.LargestWindowWidth - 4, maxColHeight = Console.LargestWindowHeight - 1; hWin = GetConsoleWindow(); GetWindowRect(hWin, out rc); scr = Screen.FromPoint(new Point(rc.left, rc.top)); int cols = Console.WindowWidth, rows = Console.WindowHeight; int x = rc.left, y = rc.top; // Figure out the window size. if (p == WindowPosition.Center) { cols = Console.WindowWidth; } else if (p == WindowPosition.Top || p == WindowPosition.Bottom || p == WindowPosition.Maximized) { cols = maxColWidth; } else if (p == WindowPosition.TopRight || p == WindowPosition.Right || p == WindowPosition.BottomRight || p == WindowPosition.TopLeft || p == WindowPosition.Left || p == WindowPosition.BottomLeft) { cols = (int)Math.Round(maxColWidth / 2F, 0); } if (p == WindowPosition.Center) { rows = Console.WindowHeight; } else if (p == WindowPosition.Left || p == WindowPosition.Right || p == WindowPosition.Maximized) { rows = maxColHeight; } else if (p == WindowPosition.TopLeft || p == WindowPosition.Top || p == WindowPosition.TopRight || p == WindowPosition.BottomLeft || p == WindowPosition.Bottom || p == WindowPosition.BottomRight) { rows = (int)Math.Round(maxColHeight / 2F, 0); } // Set the window size.. if (cols > Console.BufferWidth) { Console.BufferWidth = cols; } Console.WindowWidth = cols; Console.BufferWidth = cols; if (rows > Console.BufferHeight) { Console.BufferHeight = rows; } Console.WindowHeight = rows; if (p == WindowPosition.Maximized || p == WindowPosition.Center) { ConsoleUtils.CenterWindow(); } else { // Figure out the window location. if (p == WindowPosition.Top || p == WindowPosition.Bottom || p == WindowPosition.TopLeft || p == WindowPosition.Left || p == WindowPosition.BottomLeft) { x = scr.WorkingArea.Left; } else if (p == WindowPosition.TopRight || p == WindowPosition.Right || p == WindowPosition.BottomRight) { x = (int)Math.Round(scr.WorkingArea.Width / 2F, 0); } if (p == WindowPosition.Left || p == WindowPosition.Right || p == WindowPosition.TopLeft || p == WindowPosition.Top || p == WindowPosition.TopRight) { y = scr.WorkingArea.Top; } else if (p == WindowPosition.BottomLeft || p == WindowPosition.Bottom || p == WindowPosition.BottomRight) { y = (int)Math.Round(scr.WorkingArea.Height / 2F, 0); } // Set the window location.. MoveWindow(x, y); } }
/// <summary> /// Sets the window position, z-order. /// </summary> /// <param name="handle">The window handle.</param> /// <param name="insertAfter">Z-Order flags</param> /// <param name="bounds">The new position and size.</param> /// <param name="flags">Options for showing the window.</param> /// <returns></returns> public static bool SetWindowPos(IWin32Window handle, IntPtr insertAfter, Rectangle bounds, WindowPosition flags) { return(UnsafeNativeMethods.SetWindowPos(new HandleRef(handle, handle.Handle), new HandleRef(handle, insertAfter), bounds.X, bounds.Y, bounds.Width, bounds.Height, (int)flags)); }
private void UpdateWindowPlacement() { Window window = Form.Tag as Window; if (window == null) { return; } Rect2i oldbounds = null; Point2i pos = null; Size2i size = null; WindowSize initsize = window.InitialSize; WindowPosition initpos = window.InitialPosition; if (initsize == WindowSize.Minimal) { if (oldbounds == null) { window.Refresh(); oldbounds = window.Bounds; } size = oldbounds.Size; // window.LayoutInfo.MinSize; } else if (initsize == WindowSize.Current) { if (oldbounds == null) { oldbounds = window.Bounds; } size = oldbounds.Size; } else { throw new Exception("Unimplemented initial size"); } if (pos == null && initpos == WindowPosition.Current) { //if (oldbounds == null) oldbounds = Bounds; pos = new Point2i(oldbounds.X, oldbounds.Y); } if (pos == null && initpos == WindowPosition.CenterParent) { Form frm = Form.ActiveForm; //form to center to //Dont center invisible windows, this is actually a hack //around centering to visual studios so called 'parking window' if this //is the app:s first window shown if (frm != null && frm.Visible == false) { frm = null; } //now we got a form to center to? if (frm != null) { var fb = frm.Bounds; int x = fb.Left + fb.Width / 2 - size.Width / 2; int y = fb.Top + fb.Height / 2 - size.Height / 2; pos = new Point2i(x, y); } else //no active window, fallback to screen center { initpos = WindowPosition.CenterScreen; } } if (pos == null && initpos == WindowPosition.CenterScreen) { var rs = Guppy.ScreenResolution; int x = rs.Width / 2 - size.Width / 2; int y = rs.Height / 2 - size.Height / 2; pos = new Point2i(x, y); } if (pos == null) //unresolvable { throw new Exception("Unimplemented initial position"); } //next time we show, use the current size and position window.InitialPosition = WindowPosition.Current; window.InitialSize = WindowSize.Current; Bounds = new Rect2i(pos, size); } //End UpdateWindowPlacement
/// <summary> /// Set the window position /// </summary> /// <param name="form">form to reposition</param> /// <param name="insertAfter">insert after this window</param> /// <param name="position">new position</param> public static void SetWindowPosition(Form form, IntPtr insertAfter, WindowPosition position) { form.StartPosition = FormStartPosition.Manual; var location = new Point(0, 0); switch (position) { case WindowPosition.TopRight: location = new Point(Screen.PrimaryScreen.WorkingArea.Width - form.Width, 0); break; case WindowPosition.TopLeft: location = new Point(0, 0); break; case WindowPosition.BottomRight: location = new Point(Screen.PrimaryScreen.WorkingArea.Width - form.Width, Screen.PrimaryScreen.WorkingArea.Height - form.Height); break; case WindowPosition.BottomLeft: location = new Point(0, Screen.PrimaryScreen.WorkingArea.Height - form.Height); break; case WindowPosition.CenterScreen: location = new Point((Screen.PrimaryScreen.WorkingArea.Width - form.Width) / 2, (Screen.PrimaryScreen.WorkingArea.Height - form.Height) / 2); break; } User32Interop.SetWindowPos(form.Handle.ToInt32(), insertAfter.ToInt32(), location.X, location.Y, 0, 0, 0x0040 | 0x0001); }
private void MainForm_FormClosing(object sender, FormClosingEventArgs e) { Program.WriteSetting("WindowPosition", WindowPosition.SerializePosition(this)); }
/// <summary> /// Set window pos to the specified position and notify when window position /// has changed /// </summary> /// <param name="form">The form</param> /// <param name="position">Where to set the position</param> public static void SetWindowPositionAndNotify(Form form, IntPtr insertAfter, WindowPosition position) { SetWindowPosition(form, insertAfter, position); if (EvtWindowPositionChanged != null) { EvtWindowPositionChanged(form, position); } }
public Window(string title, WindowPosition x, int y, int width, int height, WindowOptions options) : this(title, (int)x, y, width, height, options) { }
/// <summary> /// Toggles size of the fg window between maximized to partially /// maximized /// </summary> /// <param name="scannerPosition">where to position the window</param> /// <param name="percent">the partial maximize percentage</param> public static void ToggleFgWindowMaximizeAndPartialMaximize(WindowPosition scannerPosition, int percent) { IntPtr fgWindow = GetForegroundWindow(); if (fgWindow != IntPtr.Zero) { if (IsMaximized(fgWindow)) { RestoreWindow(fgWindow); SetForegroundWindowSizePercent(scannerPosition, percent); } else { MaximizeWindow(fgWindow); } } }
public Window(string title, int x, WindowPosition y, int width, int height, WindowOptions options) : this(title, x, (int)y, width, height, options) { }
/// <summary> /// Sets the width of the foreground window to a certain /// percentage of the display monitor width. /// </summary> /// <param name="scannerPosition">where to position the window?</param> /// <param name="percent">the percent width</param> public static void SetForegroundWindowSizePercent(WindowPosition scannerPosition, int percent) { SetWindowSizePercent(User32Interop.GetForegroundWindow(), scannerPosition, percent); }
public Window(string title, WindowPosition position, int width, int height, WindowOptions options) : this(title, (int)position, (int)position, width, height, options) { }
private async Task MoveApplication() { if (String.IsNullOrWhiteSpace(Settings.Screen)) { Logger.Instance.LogMessage(TracingLevel.WARN, $"Screen not specified."); await Connection.ShowAlert(); return; } if (Settings.AppSpecific && String.IsNullOrWhiteSpace(Settings.ApplicationName)) { Logger.Instance.LogMessage(TracingLevel.WARN, $"Application not specified."); await Connection.ShowAlert(); return; } if (String.IsNullOrWhiteSpace(Settings.XPosition) || String.IsNullOrWhiteSpace(Settings.YPosition)) { Logger.Instance.LogMessage(TracingLevel.WARN, $"X or Y position not specified."); await Connection.ShowAlert(); return; } if (!int.TryParse(Settings.XPosition, out int xPosition)) { Logger.Instance.LogMessage(TracingLevel.WARN, $"Invalid X position: {Settings.XPosition}"); await Connection.ShowAlert(); return; } if (!int.TryParse(Settings.YPosition, out int yPosition)) { Logger.Instance.LogMessage(TracingLevel.WARN, $"Invalid Y position: {Settings.YPosition}"); await Connection.ShowAlert(); return; } WindowSize windowSize = null; WindowResize windowResize = WindowResize.NoResize; if (Settings.ResizeWindow) { windowResize = WindowResize.ResizeWindow; if (String.IsNullOrWhiteSpace(Settings.Height) || String.IsNullOrWhiteSpace(Settings.Width)) { Logger.Instance.LogMessage(TracingLevel.WARN, $"Height or Width position not specified."); await Connection.ShowAlert(); return; } if (!int.TryParse(Settings.Height, out int height)) { Logger.Instance.LogMessage(TracingLevel.WARN, $"Invalid height: {Settings.Height}"); await Connection.ShowAlert(); return; } if (!int.TryParse(Settings.Width, out int width)) { Logger.Instance.LogMessage(TracingLevel.WARN, $"Invalid width: {Settings.Width}"); await Connection.ShowAlert(); return; } windowSize = new WindowSize(height, width); } else if (Settings.MaximizeWindow) { windowResize = WindowResize.Maximize; } else if (Settings.MinimizeWindow) { windowResize = WindowResize.Minimize; } else if (Settings.OnlyTopmost) { windowResize = WindowResize.OnlyTopmost; } Screen screen = MonitorManager.Instance.GetScreenFromUniqueValue(Settings.Screen); if (screen == null) { Logger.Instance.LogMessage(TracingLevel.ERROR, $"Could not find screen {Settings.Screen}"); await Connection.ShowAlert(); return; } var processCount = WindowPosition.MoveProcess(new MoveProcessSettings() { AppSpecific = Settings.AppSpecific, Name = Settings.ApplicationName, DestinationScreen = screen, Position = new System.Drawing.Point(xPosition, yPosition), WindowResize = windowResize, WindowSize = windowSize, MakeTopmost = Settings.TopmostWindow, LocationFilter = Settings.ShouldFilterLocation ? Settings.LocationFilter : null, TitleFilter = Settings.ShouldFilterTitle ? Settings.TitleFilter : null }); if (processCount > 0) { tmrRetryProcess.Stop(); } else if (processCount == 0 && !tmrRetryProcess.Enabled) { if (!Int32.TryParse(Settings.RetryAttempts, out retryAttempts)) { Logger.Instance.LogMessage(TracingLevel.WARN, $"Invalid RetryAttempts: {Settings.RetryAttempts}"); return; } tmrRetryProcess.Start(); } }
public Window(string title, int x, WindowPosition y, ScreenResolution resolution, WindowOptions options) : this(title, x, (int)y, resolution.Width(), resolution.Height(), options) { }
private void Window_Loaded(object sender, RoutedEventArgs e) { WindowPosition.Move(this); }
public Window(string title, WindowPosition position, ScreenResolution resolution, WindowOptions options) : this(title, (int)position, (int)position, resolution.Width(), resolution.Height(), options) { }
private void Load(XmlReader reader, Form mainForm) { var comparer = StringComparison.OrdinalIgnoreCase; while (reader.Read()) { if (reader.NodeType == XmlNodeType.Element) { if (string.Equals(reader.Name, "option", comparer)) { string optionName = reader.GetAttribute("name"); string optionType = reader.GetAttribute("type"); if (string.Equals(optionType, "String", comparer)) { string optionValue = reader.ReadElementContentAsString(); switch (optionName) { case "WebSuitePath": _webSuitePath = optionValue; break; case "LocalSuitePath": if (optionValue.StartsWith(ParentSymbol, comparer)) { var inputPath = string.Copy(_localSuitePath); int indexOf = inputPath.IndexOf(SharpVectors, comparer); if (indexOf > 0) { var basePath = inputPath.Substring(0, indexOf); _localSuitePath = Path.Combine(basePath, optionValue.Replace(ParentSymbol, "")); } else { _localSuitePath = optionValue; } } else { _localSuitePath = optionValue; } break; case "SelectedValuePath": _selectedValuePath = optionValue; break; } } else if (string.Equals(optionType, "Boolean", comparer)) { bool optionValue = reader.ReadElementContentAsBoolean(); switch (optionName) { case "HidePathsRoot": _hidePathsRoot = optionValue; break; } } } else if (string.Equals(reader.Name, "placements", StringComparison.OrdinalIgnoreCase)) { if (reader.IsEmptyElement == false) { if (reader.ReadToFollowing("WindowPosition")) { var xs = new XmlSerializer(typeof(WindowPosition)); _winPosition = xs.Deserialize(reader) as WindowPosition; } } } } } if (mainForm != null && _winPosition != null) { try { switch (_winPosition.WindowState) { case FormWindowState.Maximized: mainForm.Location = _winPosition.MaximisedPoint; mainForm.StartPosition = FormStartPosition.Manual; break; case FormWindowState.Normal: if (_winPosition.IsIdenticalScreen()) { mainForm.Location = _winPosition.Location; mainForm.Size = _winPosition.Size; mainForm.StartPosition = FormStartPosition.Manual; } break; case FormWindowState.Minimized: _winPosition.WindowState = FormWindowState.Normal; break; default: break; } mainForm.WindowState = _winPosition.WindowState; } catch (Exception ex) { Trace.TraceError(ex.ToString()); } } }
public void ResizeAndPositionWindow(WindowSize windowSize, WindowPosition windowPosition) { RunOnHandle(handle => ResizeAndPositionWindow(handle, windowSize, windowPosition)); }
public PlayerStatsGui(WindowPosition windowPosition = WindowPosition.Down) { if (windowPosition == WindowPosition.Up) _lessY = 128; }
static extern IntPtr SetWindowPos(IntPtr hWnd, int hWndInsertAfter, int x, int Y, int cx, int cy, WindowPosition uFlags);
/// ------------------------------------------------------------------- /// <summary></summary> /// ------------------------------------------------------------------- void TestMove1(bool canMove, CheckType checkType, Type expectedException, WindowPosition placement, EventFired eventFired, Point point, bool moveWindowBackToOriginalPostion, HasFocus hasFocus) { Point oldPoint = new Point(m_le.Current.BoundingRectangle.Left, m_le.Current.BoundingRectangle.Top); try { //"Precondition: TransformPattern.CanMove == true", TSC_VerifyPropertyEqual(pCanMove, canMove, TransformPattern.CanMoveProperty, CheckType.IncorrectElementConfiguration); //"Step: Ensure the AutomationElement does not have focus by calling SetFocus(AutomationElement.RootElement.FirstChild) - "OS's Start Button"", switch (hasFocus) { case HasFocus.No: TSC_SetFocusVerifyWithEvent(ControlFirstChild(AutomationElement.RootElement), CheckType.Verification); break; case HasFocus.DontCare: break; default: throw new ArgumentException("Need to handle a HasFocus enum"); } //"Step: Setup a BoundingRectangle PropertyChange event", TSC_AddPropertyChangedListener(m_le, TreeScope.Element, new AutomationProperty[] { AutomationElement.BoundingRectangleProperty }, CheckType.Verification); //"Step: Verify that Move with the random point is called successfully", TS_Move(point, expectedException, CheckType.Verification); //"Step: Wait for event to get fired", TSC_WaitForEvents(2); if (placement == WindowPosition.Exact) { //"Verify: The BoundingRectangle PropertyChange event is fired", TSC_VerifyPropertyChangedListener(m_le, new EventFired[] { eventFired }, new AutomationProperty[] { AutomationElement.BoundingRectangleProperty }, CheckType.Verification); if (eventFired == EventFired.True) { // Verify element was moved to the correct position by validating the BoundingRectangle TS_VerifyBoundingRect(new Rect(point.X, point.Y, m_le.Current.BoundingRectangle.Width, m_le.Current.BoundingRectangle.Height), m_le.Current.BoundingRectangle, CheckType.Verification); } else { // Verify element was not moved to the correct position by validating the BoundingRectangle TS_VerifyBoundingRect(new Rect(oldPoint.X, oldPoint.Y, m_le.Current.BoundingRectangle.Width, m_le.Current.BoundingRectangle.Height), m_le.Current.BoundingRectangle, CheckType.Verification); } } else if (placement == WindowPosition.Within) { // "Verify: The BoundingRectangle PropertyChange event is fired if the element is moved", if (m_le.Current.BoundingRectangle.Left == point.X && m_le.Current.BoundingRectangle.Top == point.Y) { TSC_VerifyPropertyChangedListener(m_le, new EventFired[] { EventFired.False }, new AutomationProperty[] { AutomationElement.BoundingRectangleProperty }, CheckType.Verification); } else { TSC_VerifyPropertyChangedListener(m_le, new EventFired[] { EventFired.True }, new AutomationProperty[] { AutomationElement.BoundingRectangleProperty }, CheckType.Verification); } // OS does not allow off the screen so will move it back to a good location TS_VerifyPlacedWithinScreen(CheckType.Verification); } } finally // incase we throw expection, come back and clean up { if (moveWindowBackToOriginalPostion) { //"Step: Move the window back to it's original position", Comment("Moving window back to it's original position"); if (oldPoint != new Point(m_le.Current.BoundingRectangle.Left, m_le.Current.BoundingRectangle.Top)) TS_Move(oldPoint, null, CheckType.Verification); else m_TestStep++; } } }
public MainWindow() { InitializeComponent(); // Set the viewmodel as this view isn't invoked by ReactiveUI ViewModel = new MainViewModel(); this.OneWayBind(ViewModel, x => x.Title, x => x.Title); this.OneWayBind(ViewModel, x => x.Title, x => x.Tray.ToolTipText); // TaskbarIcon context menu bindings this.BindCommand(ViewModel, x => x.Profile, x => x.MenuProfile); this.BindCommand(ViewModel, x => x.Dashboard, x => x.MenuDash); this.BindCommand(ViewModel, x => x.Community, x => x.MenuForums); this.BindCommand(ViewModel, x => x.Exit, x => x.MenuExit); this.WhenAnyObservable(x => x.ViewModel.Exit).Subscribe(_ => Close()); // Lowest level UserError handler, any UserError's thrown that aren't handled will hit this. UserError.RegisterHandler(error => { Tray.ShowBalloonTip("Error", error.ErrorMessage, BalloonIcon.Error); return(Observable.Return(RecoveryOptionResult.CancelOperation)); }); // Change the content in the ViewModelViewHost based on the `Content` property in the ViewModel this.WhenAnyValue(x => x.ViewModel.Content) .Where(x => x != null) .Subscribe(model => ContentView.ViewModel = model); // Sets the position of the window when the height changes. this.WhenAnyValue(x => x.Height) .Subscribe(_ => SetWindowLocation()); // TaskbarIcon left-click handler // Will show the window, or do nothing, based on the `_shouldNotShow` property Observable.FromEventPattern <RoutedEventHandler, RoutedEventArgs>( h => Tray.TrayLeftMouseUp += h, h => Tray.TrayLeftMouseUp -= h) .Subscribe(_ => { if (!_shouldNotShow) { SetWindowLocation(); Show(); Activate(); } _shouldNotShow = false; }); // TaskbarIcon right-click handler // Sets the `_shouldNotShow` property to false so that the window will show next left-click // Logic here: // Right-click is outside the bounds of the window so the `Deactivated` event is fired // `Deactivated` event will hide the window and set `_shouldNotShow` to true // This event handler is hit and sets `_shouldNotShow` to false so the application works as expected. Observable.FromEventPattern <RoutedEventHandler, RoutedEventArgs>( h => Tray.TrayRightMouseDown += h, h => Tray.TrayRightMouseDown -= h) .Subscribe(_ => _shouldNotShow = false); // Hides the window when the user clicks anywhere outside the Window // Sets the `_shouldNotShow` property based on whether the cursor is within the TaskbarIcon's rect. this.Events().Deactivated.Subscribe(_ => { _shouldNotShow = WindowPosition.IsCursorOverNotifyIcon(Tray) && WindowPosition.IsNotificationAreaActive; Hide(); }); this.Events().SourceInitialized.Subscribe(_ => { // The following code disables the ability to resize the window // while still retaining the chrome border var windowHandle = new WindowInteropHelper(this).Handle; var windowSource = HwndSource.FromHwnd(windowHandle); if (windowSource == null) { return; } var resizeHook = new ResizeHook(); windowSource.AddHook(resizeHook.WndProc); }); }