From d40fed5ce2bc806a91245adb18039634eac13ed0 Mon Sep 17 00:00:00 2001 From: MichaelTheShifter Date: Wed, 20 Jul 2016 09:40:36 -0400 Subject: Move ShiftUI source code to ShiftOS This'll be a lot easier to work on. --- source/ShiftUI/Internal/NativeWindow.cs | 324 ++++++++++++++++++++++++++++++++ 1 file changed, 324 insertions(+) create mode 100644 source/ShiftUI/Internal/NativeWindow.cs (limited to 'source/ShiftUI/Internal/NativeWindow.cs') diff --git a/source/ShiftUI/Internal/NativeWindow.cs b/source/ShiftUI/Internal/NativeWindow.cs new file mode 100644 index 0000000..4657276 --- /dev/null +++ b/source/ShiftUI/Internal/NativeWindow.cs @@ -0,0 +1,324 @@ +// Permission is hereby granted, free of charge, to any person obtaining +// a copy of this software and associated documentation files (the +// "Software"), to deal in the Software without restriction, including +// without limitation the rights to use, copy, modify, merge, publish, +// distribute, sublicense, and/or sell copies of the Software, and to +// permit persons to whom the Software is furnished to do so, subject to +// the following conditions: +// +// The above copyright notice and this permission notice shall be +// included in all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE +// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +// +// Copyright (c) 2004-2008 Novell, Inc. +// +// Authors: +// Peter Dennis Bartok pbartok@novell.com +// Ivan N. Zlatev +// + + +// COMPLETE + +#define ExternalExceptionHandler + +using System.Runtime.Remoting; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Threading; +using System.Collections; +using System.Diagnostics; +using System.Drawing; +using System; + +namespace ShiftUI +{ + public class NativeWindow : MarshalByRefObject, IWin32Window + { + IntPtr window_handle = IntPtr.Zero; + static Hashtable window_collection = new Hashtable(); + + [ThreadStatic] + static NativeWindow WindowCreating; + + #region Public Constructors + public NativeWindow() + { + window_handle=IntPtr.Zero; + } + #endregion // Public Constructors + + #region Public Instance Properties + public IntPtr Handle { + get { + return window_handle; + } + } + #endregion // Public Instance Properties + + #region Public Static Methods + public static NativeWindow FromHandle(IntPtr handle) + { + return FindFirstInTable (handle); + } + #endregion // Public Static Methods + + #region Private and Internal Methods + internal void InvalidateHandle() + { + RemoveFromTable (this); + window_handle = IntPtr.Zero; + } + #endregion + + #region Public Instance Methods + public void AssignHandle(IntPtr handle) + { + RemoveFromTable (this); + window_handle = handle; + AddToTable (this); + OnHandleChange(); + } + + private static void AddToTable (NativeWindow window) + { + IntPtr handle = window.Handle; + if (handle == IntPtr.Zero) + return; + + lock (window_collection) { + object current = window_collection[handle]; + if (current == null) { + window_collection.Add (handle, window); + } else { + NativeWindow currentWindow = current as NativeWindow; + if (currentWindow != null) { + if (currentWindow != window) { + ArrayList windows = new ArrayList (); + windows.Add (currentWindow); + windows.Add (window); + window_collection[handle] = windows; + } + } else { // list of windows + ArrayList windows = (ArrayList) window_collection[handle]; + if (!windows.Contains (window)) + windows.Add (window); + } + } + } + } + + private static void RemoveFromTable (NativeWindow window) + { + IntPtr handle = window.Handle; + if (handle == IntPtr.Zero) + return; + + lock (window_collection) { + object current = window_collection[handle]; + if (current != null) { + NativeWindow currentWindow = current as NativeWindow; + if (currentWindow != null) { + window_collection.Remove (handle); + } else { // list of windows + ArrayList windows = (ArrayList) window_collection[handle]; + windows.Remove (window); + if (windows.Count == 0) + window_collection.Remove (handle); + else if (windows.Count == 1) + window_collection[handle] = windows[0]; + } + } + } + } + + private static NativeWindow FindFirstInTable (IntPtr handle) + { + if (handle == IntPtr.Zero) + return null; + + NativeWindow window = null; + lock (window_collection) { + object current = window_collection[handle]; + if (current != null) { + window = current as NativeWindow; + if (window == null) { + ArrayList windows = (ArrayList) current; + if (windows.Count > 0) + window = (NativeWindow) windows[0]; + } + } + } + return window; + } + + public virtual void CreateHandle(CreateParams cp) + { + if (cp != null) { + WindowCreating = this; + window_handle=XplatUI.CreateWindow(cp); + WindowCreating = null; + + if (window_handle != IntPtr.Zero) + AddToTable (this); + } + + } + + public void DefWndProc(ref Message m) + { + m.Result=XplatUI.DefWndProc(ref m); + } + + public virtual void DestroyHandle() + { + if (window_handle != IntPtr.Zero) { + XplatUI.DestroyWindow(window_handle); + } + } + + public virtual void ReleaseHandle() + { + RemoveFromTable (this); + window_handle=IntPtr.Zero; + OnHandleChange(); + } + + #endregion // Public Instance Methods + + #region Protected Instance Methods + ~NativeWindow() + { + } + + protected virtual void OnHandleChange() + { + } + + protected virtual void OnThreadException(Exception e) + { + Application.OnThreadException(e); + } + + protected virtual void WndProc(ref Message m) + { + DefWndProc(ref m); + } + + internal static IntPtr WndProc(IntPtr hWnd, Msg msg, IntPtr wParam, IntPtr lParam) + { + IntPtr result = IntPtr.Zero; + Message m = new Message(); + m.HWnd = hWnd; + m.Msg = (int)msg; + m.WParam = wParam; + m.LParam = lParam; + m.Result = IntPtr.Zero; + +#if debug + Console.WriteLine("NativeWindow.cs ({0}, {1}, {2}, {3}): result {4}", hWnd, msg, wParam, lParam, m.Result); +#endif + NativeWindow window = null; + + try { + object current = null; + lock (window_collection) { + current = window_collection[hWnd]; + } + + window = current as NativeWindow; + if (current == null) + window = EnsureCreated (window, hWnd); + + if (window != null) { + window.WndProc (ref m); + result = m.Result; + } else if (current is ArrayList) { + ArrayList windows = (ArrayList) current; + lock (windows) { + if (windows.Count > 0) { + window = EnsureCreated ((NativeWindow)windows[0], hWnd); + window.WndProc (ref m); + // the first one is the Widget's one. all others are synthetic, + // so we want only the result from the Widget + result = m.Result; + for (int i=1; i < windows.Count; i++) + ((NativeWindow)windows[i]).WndProc (ref m); + } + } + } else { + result = XplatUI.DefWndProc (ref m); + } + } + catch (Exception ex) { +#if !ExternalExceptionHandler + if (window != null) { + if (msg == Msg.WM_PAINT && window is Widget.WidgetNativeWindow) { + // Replace Widget with a red cross + var Widget = ((Widget.WidgetNativeWindow)window).Owner; + Widget.Hide (); + var redCross = new Widget (Widget.Parent, string.Empty); + redCross.BackColor = Color.White; + redCross.ForeColor = Color.Red; + redCross.Bounds = Widget.Bounds; + redCross.Paint += HandleRedCrossPaint; + } + window.OnThreadException (ex); + } +#else + throw ex; +#endif + } + #if debug + Console.WriteLine("NativeWindow.cs: Message {0}, result {1}", msg, m.Result); + #endif + + return result; + } + + private static void HandleRedCrossPaint (object sender, PaintEventArgs e) + { + var Widget = sender as Widget; + using (var pen = new Pen (Widget.ForeColor, 2)) { + var paintRect = Widget.DisplayRectangle; + e.Graphics.DrawRectangle (pen, paintRect.Left + 1, + paintRect.Top + 1, paintRect.Width - 1, paintRect.Height - 1); + // NOTE: .NET's drawing of the red cross seems to have a bug + // that draws the bottom and right of the rectangle only 1 pixel + // wide. We would get a nicer rectangle using the following code, + // but that runs into a problem with libgdiplus. + //var paintRect = Widget.DisplayRectangle; + //paintRect.Inflate (-1, -1); + //e.Graphics.DrawRectangle (pen, paintRect); + e.Graphics.DrawLine (pen, paintRect.Location, + paintRect.Location + paintRect.Size); + e.Graphics.DrawLine (pen, new Point (paintRect.Left, paintRect.Bottom), + new Point (paintRect.Right, paintRect.Top)); + } + } + + private static NativeWindow EnsureCreated (NativeWindow window, IntPtr hWnd) + { + // we need to do this AssignHandle here instead of relying on + // Widget.WndProc to do it, because subclasses can override + // WndProc, install their own WM_CREATE block, and look at + // this.Handle, and it needs to be set. Otherwise, we end up + // recursively creating windows and emitting WM_CREATE. + if (window == null && WindowCreating != null) { + window = WindowCreating; + WindowCreating = null; + if (window.Handle == IntPtr.Zero) + window.AssignHandle (hWnd); + } + return window; + } + #endregion // Protected Instance Methods + } +} -- cgit v1.2.3