Merge pull request #17 from MichaelTheShifter/shiftui_integration

Shiftui integration

1 files changed, 1003 insertions, 0 deletions

diff --git a/source/ShiftUI/Internal/MdiClient.cs b/source/ShiftUI/Internal/MdiClient.cs
new file mode 100644
index 0000000..8c2cf8c
--- /dev/null
+++ b/source/ShiftUI/Internal/MdiClient.cs
@@ -0,0 +1,1003 @@
+// 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) 2005 Novell, Inc. (http://www.novell.com)
+//
+// Authors:
+//	Peter Bartok	[email protected]
+//
+//
+
+// NOT COMPLETE
+
+using System.Collections;
+using System.ComponentModel;
+using System.Drawing;
+using System.Runtime.InteropServices;
+using System;
+
+namespace ShiftUI {
+	[ComVisible (true)]
+	[ClassInterface(ClassInterfaceType.AutoDispatch)]
+	[DesignTimeVisible(false)]
+	[ToolboxItem(false)]
+	public sealed class MdiClient : Widget {
+		#region Local Variables
+		private int mdi_created;
+		private ImplicitHScrollBar hbar;
+		private ImplicitVScrollBar vbar;
+		private SizeGrip sizegrip;
+		private int hbar_value;
+		private int vbar_value;
+		private bool lock_sizing;
+		private bool initializing_scrollbars;
+		private int prev_bottom;
+		private bool setting_windowstates = false;
+		internal ArrayList mdi_child_list;
+		private string form_text;
+		private bool setting_form_text;
+		private Form active_child;
+
+		#endregion	// Local Variables
+
+		#region Public Classes
+		[ComVisible (false)]
+		public new class WidgetCollection : Widget.WidgetCollection {
+
+			private MdiClient owner;
+			
+			public WidgetCollection(MdiClient owner) : base(owner) {
+				this.owner = owner;
+			}
+
+			public override void Add(Widget value) {
+				if ((value is Form) == false || !(((Form)value).IsMdiChild)) {
+					throw new ArgumentException("Form must be MdiChild");
+				}
+				owner.mdi_child_list.Add (value);
+				base.Add (value);
+
+				// newest member is the active one
+				Form form = (Form) value;
+				owner.ActiveMdiChild = form;
+			}
+
+			public override void Remove(Widget value)
+			{
+				Form form = value as Form;
+				if (form != null) {
+					MdiWindowManager wm = form.WindowManager as MdiWindowManager;
+					if (wm != null) {
+						form.Closed -= wm.form_closed_handler;
+					}
+				}
+
+				owner.mdi_child_list.Remove (value);
+				base.Remove (value);
+			}
+		}
+		#endregion	// Public Classes
+
+		#region Public Constructors
+		public MdiClient()
+		{
+			mdi_child_list = new ArrayList ();
+			BackColor = SystemColors.AppWorkspace;
+			Dock = DockStyle.Fill;
+			SetStyle (Widgetstyles.Selectable, false);
+		}
+		#endregion	// Public Constructors
+
+		internal void SendFocusToActiveChild ()
+		{
+			Form active = this.ActiveMdiChild;
+			if (active == null) {
+				ParentForm.SendWidgetFocus (this);
+			} else {
+				active.SendWidgetFocus (active);
+				ParentForm.ActiveWidget = active;
+			}
+		}
+
+		internal bool HorizontalScrollbarVisible {
+			get { return hbar != null && hbar.Visible; }
+		}
+		internal bool VerticalScrollbarVisible {
+			get { return vbar != null && vbar.Visible; }
+		}
+
+		internal void SetParentText(bool text_changed)
+		{
+			if (setting_form_text)
+				return;
+
+			setting_form_text = true;
+
+			if (text_changed)
+				form_text = ParentForm.Text;
+
+			if (ParentForm.ActiveMaximizedMdiChild == null) {
+				ParentForm.Text = form_text;
+			} else {
+				string childText = ParentForm.ActiveMaximizedMdiChild.form.Text;
+				if (childText.Length > 0) {
+					ParentForm.Text = form_text + " - [" + ParentForm.ActiveMaximizedMdiChild.form.Text + "]";
+				} else {
+					ParentForm.Text = form_text;
+				}
+			}
+
+			setting_form_text = false;
+		}
+
+		internal override void OnPaintBackgroundInternal (PaintEventArgs pe)
+		{
+			if (BackgroundImage != null)
+				return;
+
+			if (Parent == null || Parent.BackgroundImage == null)
+				return;
+			Parent.PaintWidgetBackground (pe);
+		}
+
+		internal Form ParentForm {
+			get { return (Form) Parent; }
+		}
+
+		protected override Widget.WidgetCollection CreateWidgetsInstance ()
+		{
+			return new MdiClient.WidgetCollection (this);
+		}
+
+		protected override void WndProc(ref Message m) {
+			switch ((Msg)m.Msg) {
+			case Msg.WM_NCPAINT:
+				PaintEventArgs pe = XplatUI.PaintEventStart (ref m, Handle, false);
+
+				Rectangle clip;
+				clip = new Rectangle (0, 0, Width, Height);
+
+				WidgetPaint.DrawBorder3D (pe.Graphics, clip, Border3DStyle.Sunken);
+				XplatUI.PaintEventEnd (ref m, Handle, false);
+				m.Result = IntPtr.Zero;
+				return ;
+			}
+
+			base.WndProc (ref m);
+		}
+
+		protected override void OnResize (EventArgs e)
+		{
+			base.OnResize (e);
+
+			if (Parent != null && Parent.IsHandleCreated)
+				XplatUI.InvalidateNC (Parent.Handle);
+			// Should probably make this into one loop
+			SizeScrollBars ();
+			ArrangeWindows ();
+		}
+
+		protected override void ScaleWidget (SizeF factor, BoundsSpecified specified)
+		{
+			// Never change the MdiClient's location
+			specified &= ~BoundsSpecified.Location;
+
+			base.ScaleWidget (factor, specified);
+		}
+		
+		[System.ComponentModel.EditorBrowsable (EditorBrowsableState.Never)]
+		protected override void ScaleCore (float dx, float dy)
+		{
+			base.ScaleCore (dx, dy);
+		}
+
+		protected override void SetBoundsCore (int x, int y, int width, int height, BoundsSpecified specified)
+		{
+			base.SetBoundsCore (x, y, width, height, specified);
+		}
+
+		#region Public Instance Properties
+		[Localizable(true)]
+		public override System.Drawing.Image BackgroundImage {
+			get {
+				return base.BackgroundImage;
+			}
+			set {
+				base.BackgroundImage = value;
+			}
+		}
+
+		//[EditorBrowsable (EditorBrowsableState.Never)]
+		[Browsable (false)]
+		public override ImageLayout BackgroundImageLayout {
+			get {
+				return base.BackgroundImageLayout;
+			}
+			set {
+				base.BackgroundImageLayout = value;
+			}
+		}
+
+		public Form [] MdiChildren {
+			get {
+				if (mdi_child_list == null)
+					return new Form [0];
+				return (Form []) mdi_child_list.ToArray (typeof (Form));
+			}
+		}
+		#endregion	// Public Instance Properties
+
+#region Protected Instance Properties
+		protected override CreateParams CreateParams {
+			get {
+				CreateParams result = base.CreateParams;
+				result.ExStyle |= (int) WindowExStyles.WS_EX_CLIENTEDGE;
+				return result;
+			}
+		}
+		#endregion	// Protected Instance Properties
+
+		#region Public Instance Methods
+		public void LayoutMdi (MdiLayout value) {
+
+			// Don't forget to always call ArrangeIconicWindows 
+			ArrangeIconicWindows (true);
+
+			switch (value) {
+			case MdiLayout.Cascade: {
+				int i = 0;
+				for (int c = Widgets.Count - 1; c >= 0; c--) {
+					Form form = (Form) Widgets [c];
+
+					if (form.WindowState == FormWindowState.Minimized)
+						continue;
+
+					if (form.WindowState == FormWindowState.Maximized)
+						form.WindowState = FormWindowState.Normal;
+
+					form.Width = System.Convert.ToInt32 (ClientSize.Width * 0.8);
+					form.Height = Math.Max (
+								System.Convert.ToInt32 (ClientSize.Height * 0.8),
+								SystemInformation.MinimumWindowSize.Height + 2);
+
+					int l = 22 * i;
+					int t = 22 * i;
+
+					if (i != 0 && (l + form.Width > ClientSize.Width || t + form.Height > ClientSize.Height)) {
+						i = 0;
+						l = 22 * i;
+						t = 22 * i;
+					}
+
+					form.Left = l;
+					form.Top = t;
+
+					i++;
+				}
+				break;
+				}
+			case MdiLayout.TileHorizontal:
+			case MdiLayout.TileVertical: {
+				// First count number of windows to tile
+				int total = 0;
+				
+				// And space used by iconic windows
+				int clientHeight = ClientSize.Height;
+				
+				for (int i = 0; i < Widgets.Count; i++) {
+					Form form = Widgets [i] as Form;
+					
+					if (form == null)
+						continue;
+					
+					if (!form.Visible)
+						continue;
+
+					if (form.WindowState == FormWindowState.Maximized)
+						form.WindowState = FormWindowState.Normal;
+					else if (form.WindowState == FormWindowState.Minimized) {
+						if (form.Bounds.Top < clientHeight)
+							clientHeight = form.Bounds.Top;
+						continue;
+					}
+						
+					total++;
+				}
+				if (total <= 0)
+					return;
+
+				// Calculate desired height and width
+				Size newSize;
+				Size offset;
+
+				if (value == MdiLayout.TileHorizontal) {
+					newSize = new Size(ClientSize.Width, clientHeight / total);
+					offset = new Size (0, newSize.Height);
+				} else {
+					newSize = new Size(ClientSize.Width / total, clientHeight);
+					offset = new Size (newSize.Width, 0);
+				}
+				
+				// Loop again and set the size and location.
+				Point nextLocation = Point.Empty;
+				
+				for (int i = 0; i < Widgets.Count; i++) {
+					Form form = Widgets [i] as Form;
+
+					if (form == null)
+						continue;
+
+					if (!form.Visible)
+						continue;
+
+					if (form.WindowState == FormWindowState.Minimized)
+						continue;
+
+					form.Size = newSize;
+					form.Location = nextLocation;
+					nextLocation += offset;
+				}
+				
+				break;
+				}
+			}
+		}
+		#endregion	// Public Instance Methods
+
+		#region Protected Instance Methods
+		#endregion	// Protected Instance Methods
+
+		internal void SizeScrollBars ()
+		{
+			if (lock_sizing)
+				return;
+			
+			if (!IsHandleCreated)
+				return;
+
+			if (Widgets.Count == 0 || ((Form) Widgets [0]).WindowState == FormWindowState.Maximized) {
+				if (hbar != null)
+					hbar.Visible = false;
+				if (vbar != null)
+					vbar.Visible = false;
+				if (sizegrip != null)
+					sizegrip.Visible = false;
+				return;
+			}
+
+			int right = 0;
+			int left = 0;
+			int top = 0;
+			int bottom = 0;
+
+			foreach (Form child in Widgets) {
+				if (!child.Visible)
+					continue;
+				if (child.Right > right)
+					right = child.Right;
+				if (child.Left < left) {
+					left = child.Left;
+				}
+				
+				if (child.Bottom > bottom)
+					bottom = child.Bottom;
+				if (child.Top < 0) {
+					top = child.Top;
+				}
+			}
+
+			int available_width = ClientSize.Width;
+			int available_height = ClientSize.Height;
+
+			bool need_hbar = false;
+			bool need_vbar = false;
+
+			if (right - left > available_width || left < 0) {
+				need_hbar = true;
+				available_height -= SystemInformation.HorizontalScrollBarHeight;
+			}
+			if (bottom - top > available_height || top < 0) {
+				need_vbar = true;
+				available_width -= SystemInformation.VerticalScrollBarWidth;
+
+				if (!need_hbar && (right - left > available_width || left < 0)) {
+					need_hbar = true;
+					available_height -= SystemInformation.HorizontalScrollBarHeight;
+				}
+			}
+			
+			if (need_hbar) {
+				if (hbar == null) {
+					hbar = new ImplicitHScrollBar ();
+					Widgets.AddImplicit (hbar);
+				}
+				hbar.Visible = true;
+				CalcHBar (left, right, need_vbar);
+			} else if (hbar != null)
+				hbar.Visible = false;
+
+			if (need_vbar) {
+				if (vbar == null) {
+					vbar = new ImplicitVScrollBar ();
+					Widgets.AddImplicit (vbar);
+				}
+				vbar.Visible = true;
+				CalcVBar (top, bottom, need_hbar);
+			} else if (vbar != null)
+				vbar.Visible = false;
+
+			if (need_hbar && need_vbar) {
+				if (sizegrip == null) {
+					sizegrip = new SizeGrip (this.ParentForm);
+					Widgets.AddImplicit (sizegrip);
+				}
+				sizegrip.Location = new Point (hbar.Right, vbar.Bottom);
+				sizegrip.Visible = true;
+				XplatUI.SetZOrder (sizegrip.Handle, vbar.Handle, false, false);
+			} else if (sizegrip != null) {
+				sizegrip.Visible = false;
+			}
+			
+			XplatUI.InvalidateNC (Handle);
+		}
+
+		private void CalcHBar (int left, int right, bool vert_vis)
+		{
+			initializing_scrollbars = true;
+
+			hbar.Left = 0;
+			hbar.Top = ClientRectangle.Bottom - hbar.Height;
+			hbar.Width = ClientRectangle.Width - (vert_vis ? SystemInformation.VerticalScrollBarWidth : 0);
+			hbar.LargeChange = 50;
+			hbar.Minimum = Math.Min (left, 0);
+			hbar.Maximum = Math.Max (right - ClientSize.Width + 51 + (vert_vis ? SystemInformation.VerticalScrollBarWidth : 0), 0);
+			hbar.Value = 0;
+			hbar_value = 0;
+			hbar.ValueChanged += new EventHandler (HBarValueChanged);
+			XplatUI.SetZOrder (hbar.Handle, IntPtr.Zero, true, false);
+			
+			initializing_scrollbars = false;
+		}
+
+		private void CalcVBar (int top, int bottom, bool horz_vis)
+		{
+			initializing_scrollbars = true;
+			
+			vbar.Top = 0;
+			vbar.Left = ClientRectangle.Right - vbar.Width;
+			vbar.Height = ClientRectangle.Height - (horz_vis ? SystemInformation.HorizontalScrollBarHeight : 0);
+			vbar.LargeChange = 50;
+			vbar.Minimum = Math.Min (top, 0);
+			vbar.Maximum = Math.Max (bottom - ClientSize.Height + 51 + (horz_vis ? SystemInformation.HorizontalScrollBarHeight : 0), 0);
+			vbar.Value = 0;
+			vbar_value = 0;
+			vbar.ValueChanged += new EventHandler (VBarValueChanged);
+			XplatUI.SetZOrder (vbar.Handle, IntPtr.Zero, true, false);
+			
+			initializing_scrollbars = false;
+		}
+
+		private void HBarValueChanged (object sender, EventArgs e)
+		{
+			if (initializing_scrollbars)
+				return;
+			
+			if (hbar.Value == hbar_value)
+				return;
+
+			lock_sizing = true;
+
+			try {
+				int diff = hbar_value - hbar.Value;
+				foreach (Form child in Widgets) {
+					child.Left += diff;
+				}
+			} finally {
+				lock_sizing = false;
+			}
+
+			hbar_value = hbar.Value;
+		}
+
+		private void VBarValueChanged (object sender, EventArgs e)
+		{
+			if (initializing_scrollbars)
+				return;
+				
+			if (vbar.Value == vbar_value)
+				return;
+
+			lock_sizing = true;
+
+			try {
+				int diff = vbar_value - vbar.Value;
+				foreach (Form child in Widgets) {
+					child.Top += diff;
+				}
+			} finally {
+				lock_sizing = false;
+			}
+
+			vbar_value = vbar.Value;
+		}
+
+		private void ArrangeWindows ()
+		{
+			if (!IsHandleCreated)
+				return;
+				
+			int change = 0;
+			if (prev_bottom != -1)
+				change = Bottom - prev_bottom;
+
+			foreach (Widget c in Widgets) {
+				Form child = c as Form;
+
+				if (c == null || !child.Visible)
+					continue;
+
+				MdiWindowManager wm = child.WindowManager as MdiWindowManager;
+				if (wm.GetWindowState () == FormWindowState.Maximized)
+					child.Bounds = wm.MaximizedBounds;
+
+				if (wm.GetWindowState () == FormWindowState.Minimized) {
+					child.Top += change;
+				}
+					
+			}
+
+			prev_bottom = Bottom;
+		}
+
+		internal void ArrangeIconicWindows (bool rearrange_all)
+		{
+			Rectangle rect = Rectangle.Empty;
+
+			lock_sizing = true;
+			foreach (Form form in Widgets) {
+				if (form.WindowState != FormWindowState.Minimized)
+					continue;
+
+				MdiWindowManager wm = (MdiWindowManager) form.WindowManager;
+				
+				if (wm.IconicBounds != Rectangle.Empty && !rearrange_all) {
+					if (form.Bounds != wm.IconicBounds)
+						form.Bounds = wm.IconicBounds;
+					continue;
+				}
+				
+				bool success = true;
+				int startx, starty, currentx, currenty;
+
+				rect.Size = wm.IconicSize;
+				
+				startx = 0;
+				starty = ClientSize.Height - rect.Height;
+				currentx = startx;
+				currenty = starty;
+				
+				do {
+					rect.X = currentx;
+					rect.Y = currenty;
+					success = true;
+					foreach (Form form2 in Widgets) {
+						if (form2 == form || form2.window_state != FormWindowState.Minimized)
+							continue;
+						
+						if (form2.Bounds.IntersectsWith(rect)) {
+							success = false;
+							break;
+						}
+					}
+					if (!success) {	
+						currentx += rect.Width;
+						if (currentx + rect.Width > Right) {
+							currentx = startx;
+							currenty -= rect.Height;
+						} 
+					}
+				} while (!success);
+				wm.IconicBounds = rect;
+				form.Bounds = wm.IconicBounds;
+			}
+			lock_sizing = false;
+		}
+
+		internal void ChildFormClosed (Form form)
+		{
+			FormWindowState closed_form_windowstate = form.WindowState;
+	
+			form.Visible = false;
+			Widgets.Remove (form);
+			
+			if (Widgets.Count == 0) {
+				((MdiWindowManager) form.window_manager).RaiseDeactivate ();
+			} else if (closed_form_windowstate == FormWindowState.Maximized) {
+				Form current = (Form) Widgets [0];
+				current.WindowState = FormWindowState.Maximized;
+				ActivateChild(current);
+			}
+
+			if (Widgets.Count == 0) {
+				XplatUI.RequestNCRecalc (Parent.Handle);
+				ParentForm.PerformLayout ();
+
+				// If we closed the last child, unmerge the menus.
+				// If it's not the last child, the menu will be unmerged
+				// when another child takes focus.
+				MenuStrip parent_menu = form.MdiParent.MainMenuStrip;
+
+				if (parent_menu != null)
+					if (parent_menu.IsCurrentlyMerged)
+						ToolStripManager.RevertMerge (parent_menu);
+			}
+			SizeScrollBars ();
+			SetParentText (false);
+			form.Dispose();
+		}
+
+		internal void ActivateNextChild ()
+		{
+			if (Widgets.Count < 1)
+				return;
+			if (Widgets.Count == 1 && Widgets[0] == ActiveMdiChild)
+				return;
+				
+			Form front = (Form) Widgets [0];
+			Form form = (Form) Widgets [1];
+
+			ActivateChild (form);
+			front.SendToBack ();
+		}
+
+		internal void ActivatePreviousChild ()
+		{
+			if (Widgets.Count <= 1)
+				return;
+			
+			Form back = (Form) Widgets [Widgets.Count - 1];
+			
+			ActivateChild (back);
+		}
+
+		internal void ActivateChild (Form form)
+		{
+			if (Widgets.Count < 1)
+				return;
+
+			if (ParentForm.is_changing_visible_state > 0)
+				return;
+			
+			Form current = (Form) Widgets [0];
+			bool raise_deactivate = ParentForm.ActiveWidget == current;
+
+			// We want to resize the new active form before it is 
+			// made active to avoid flickering. Can't do it in the
+			// normal way (form.WindowState = Maximized) since it's not
+			// active yet and everything would just return to before. 
+			// We also won't suspend layout, this way the layout will
+			// happen before the form is made active (and in many cases
+			// before it is visible, which avoids flickering as well).
+			MdiWindowManager wm = (MdiWindowManager)form.WindowManager;
+			
+			if (current.WindowState == FormWindowState.Maximized && form.WindowState != FormWindowState.Maximized && form.Visible) {
+				FormWindowState old_state = form.window_state;
+				SetWindowState (form, old_state, FormWindowState.Maximized, true);
+				wm.was_minimized = form.window_state == FormWindowState.Minimized;
+				form.window_state = FormWindowState.Maximized;
+				SetParentText (false);
+			}
+
+			form.BringToFront ();
+			form.SendWidgetFocus (form);
+			SetWindowStates (wm);
+			if (current != form) {
+				form.has_focus = false;
+				if (current.IsHandleCreated)
+					XplatUI.InvalidateNC (current.Handle);
+				if (form.IsHandleCreated)
+					XplatUI.InvalidateNC (form.Handle);
+				if (raise_deactivate) {
+					MdiWindowManager current_wm = (MdiWindowManager) current.window_manager;
+					current_wm.RaiseDeactivate ();
+					
+				}
+			}
+			active_child = (Form) Widgets [0];
+			
+			if (active_child.Visible) {
+				bool raise_activated = ParentForm.ActiveWidget != active_child;
+				ParentForm.ActiveWidget = active_child;
+				if (raise_activated) {
+					MdiWindowManager active_wm = (MdiWindowManager) active_child.window_manager;
+					active_wm.RaiseActivated ();
+				}
+			}
+		}
+
+		internal override IntPtr AfterTopMostWidget ()
+		{
+			// order of scrollbars:
+			// top = vertical
+			//       sizegrid
+			// bottom = horizontal
+			if (hbar != null && hbar.Visible)
+				return hbar.Handle;
+			// no need to check for sizegrip since it will only
+			// be visible if hbar is visible.
+			if (vbar != null && vbar.Visible)
+				return vbar.Handle;
+				
+			return base.AfterTopMostWidget ();
+		}
+		
+		internal bool SetWindowStates (MdiWindowManager wm)
+		{
+		/*
+			MDI WindowState behaviour:
+			- If the active window is maximized, all other maximized windows are normalized.
+			- If a normal window gets focus and the original active window was maximized, 
+			  the normal window gets maximized and the original window gets normalized.
+			- If a minimized window gets focus and the original window was maximized, 
+			  the minimzed window gets maximized and the original window gets normalized. 
+			  If the ex-minimized window gets deactivated, it will be normalized.
+		*/
+			Form form = wm.form;
+
+			if (setting_windowstates) {
+				return false;
+			}
+			
+			if (!form.Visible)
+				return false;
+			
+			bool is_active = wm.IsActive;
+			bool maximize_this = false;
+			
+			if (!is_active){
+				return false;
+			}
+			
+			ArrayList minimize_these = new ArrayList ();
+			ArrayList normalize_these = new ArrayList ();
+
+			setting_windowstates = true;
+			foreach (Form frm in mdi_child_list) {
+				if (frm == form) {
+					continue;
+				} else if (!frm.Visible){
+					continue;
+				}
+				if (frm.WindowState == FormWindowState.Maximized && is_active) {
+					maximize_this = true;	
+					if (((MdiWindowManager) frm.window_manager).was_minimized) {
+						minimize_these.Add (frm); 
+					} else {
+						normalize_these.Add (frm); 
+					}
+				}
+			}
+
+			if (maximize_this && form.WindowState != FormWindowState.Maximized) {
+				wm.was_minimized = form.window_state == FormWindowState.Minimized;
+				form.WindowState = FormWindowState.Maximized;
+			}
+			
+			foreach (Form frm in minimize_these)
+				frm.WindowState = FormWindowState.Minimized;
+
+			foreach (Form frm in normalize_these)
+				frm.WindowState = FormWindowState.Normal;
+
+
+			SetParentText (false);
+			
+			XplatUI.RequestNCRecalc (ParentForm.Handle);
+			XplatUI.RequestNCRecalc (Handle);
+
+			SizeScrollBars ();
+
+			setting_windowstates = false;
+
+			if (form.MdiParent.MainMenuStrip != null)
+				form.MdiParent.MainMenuStrip.RefreshMdiItems ();
+
+			// Implicit menu strip merging
+			// - When child is activated
+			// - Parent form must have a MainMenuStrip
+			// - Find the first menustrip on the child
+			// - Merge
+			MenuStrip parent_menu = form.MdiParent.MainMenuStrip;
+
+			if (parent_menu != null) {
+				if (parent_menu.IsCurrentlyMerged)
+					ToolStripManager.RevertMerge (parent_menu);
+					
+				MenuStrip child_menu = LookForChildMenu (form);
+
+				if (form.WindowState != FormWindowState.Maximized)
+					RemoveControlMenuItems (wm);
+				
+				if (form.WindowState == FormWindowState.Maximized) {
+					bool found = false;
+					
+					foreach (ToolStripItem tsi in parent_menu.Items) {
+						if (tsi is MdiWidgetStrip.SystemMenuItem) {
+							(tsi as MdiWidgetStrip.SystemMenuItem).MdiForm = form;
+							found = true;
+						} else if (tsi is MdiWidgetStrip.WidgetBoxMenuItem) {
+							(tsi as MdiWidgetStrip.WidgetBoxMenuItem).MdiForm = form;
+							found = true;
+						}
+					}	
+					
+					if (!found) {
+						parent_menu.SuspendLayout ();
+						parent_menu.Items.Insert (0, new MdiWidgetStrip.SystemMenuItem (form));
+						parent_menu.Items.Add (new MdiWidgetStrip.WidgetBoxMenuItem (form, MdiWidgetStrip.ControlBoxType.Close));
+						parent_menu.Items.Add (new MdiWidgetStrip.WidgetBoxMenuItem (form, MdiWidgetStrip.ControlBoxType.Max));
+						parent_menu.Items.Add (new MdiWidgetStrip.WidgetBoxMenuItem (form, MdiWidgetStrip.ControlBoxType.Min));
+						parent_menu.ResumeLayout ();
+					}
+				}
+				
+				if (child_menu != null)
+					ToolStripManager.Merge (child_menu, parent_menu);
+			}
+
+			return maximize_this;
+		}
+
+		private MenuStrip LookForChildMenu (Widget parent)
+		{
+			foreach (Widget c in parent.Widgets) {
+				if (c is MenuStrip)
+					return (MenuStrip)c;
+					
+				if (c is ToolStripContainer || c is ToolStripPanel) {
+					MenuStrip ms = LookForChildMenu (c);
+					
+					if (ms != null)
+						return ms;
+				}
+			}
+			
+			return null;
+		}
+		
+		internal void RemoveControlMenuItems (MdiWindowManager wm)
+		{
+			Form form = wm.form;
+			MenuStrip parent_menu = form.MdiParent.MainMenuStrip;
+
+			// Only remove the items if the form requesting still owns the menu items
+			if (parent_menu != null) {
+				parent_menu.SuspendLayout ();
+
+				for (int i = parent_menu.Items.Count - 1; i >= 0; i--) {
+					if (parent_menu.Items[i] is MdiWidgetStrip.SystemMenuItem) {
+						if ((parent_menu.Items[i] as MdiWidgetStrip.SystemMenuItem).MdiForm == form)
+							parent_menu.Items.RemoveAt (i);
+					} else if (parent_menu.Items[i] is MdiWidgetStrip.WidgetBoxMenuItem) {
+						if ((parent_menu.Items[i] as MdiWidgetStrip.WidgetBoxMenuItem).MdiForm == form)
+							parent_menu.Items.RemoveAt (i);
+					}
+				}
+				
+				parent_menu.ResumeLayout ();
+			}
+		}
+
+		internal void SetWindowState (Form form, FormWindowState old_window_state, FormWindowState new_window_state, bool is_activating_child)
+		{
+			bool mdiclient_layout;
+
+			MdiWindowManager wm = (MdiWindowManager) form.window_manager;
+
+			if (!is_activating_child && new_window_state == FormWindowState.Maximized && !wm.IsActive) {
+				ActivateChild (form);
+				return;
+			}
+				
+			if (old_window_state == FormWindowState.Normal)
+				wm.NormalBounds = form.Bounds;
+
+			if (SetWindowStates (wm))
+				return;
+
+			if (old_window_state == new_window_state)
+				return;
+
+			mdiclient_layout = old_window_state == FormWindowState.Maximized || new_window_state == FormWindowState.Maximized;
+
+			switch (new_window_state) {
+			case FormWindowState.Minimized:
+				ArrangeIconicWindows (false);
+				break;
+			case FormWindowState.Maximized:
+				form.Bounds = wm.MaximizedBounds;
+				break;
+			case FormWindowState.Normal:
+				form.Bounds = wm.NormalBounds;
+				break;
+			}
+
+			wm.UpdateWindowDecorations (new_window_state);
+
+			form.ResetCursor ();
+
+			if (mdiclient_layout)
+				Parent.PerformLayout ();
+
+			XplatUI.RequestNCRecalc (Parent.Handle);
+			XplatUI.RequestNCRecalc (form.Handle);
+			if (!setting_windowstates)
+				SizeScrollBars ();
+		}
+		internal int ChildrenCreated {
+			get { return mdi_created; }
+			set { mdi_created = value; }
+		}
+
+		internal Form ActiveMdiChild {
+			get {
+				if (ParentForm != null && !ParentForm.Visible)
+					return null;
+
+				if (Widgets.Count < 1)
+					return null;
+					
+				if (!ParentForm.IsHandleCreated)
+					return null;
+				
+				if (!ParentForm.has_been_visible)
+					return null;
+					
+				if (!ParentForm.Visible)
+					return active_child;
+				
+				active_child = null;
+				for (int i = 0; i < Widgets.Count; i++) {
+					if (Widgets [i].Visible) {
+						active_child = (Form) Widgets [i];
+						break;
+					}
+				}
+				return active_child;
+			}
+			set {
+				ActivateChild (value);
+			}
+		}
+		
+		internal void ActivateActiveMdiChild ()
+		{
+			if (ParentForm.is_changing_visible_state > 0)
+				return;
+				
+			for (int i = 0; i < Widgets.Count; i++) {
+				if (Widgets [i].Visible) {
+					ActivateChild ((Form) Widgets [i]);
+					return;
+				}
+			}
+		}
+	}
+}
+