aboutsummaryrefslogtreecommitdiff
path: root/source/ShiftUI/Form
diff options
context:
space:
mode:
Diffstat (limited to 'source/ShiftUI/Form')
-rw-r--r--source/ShiftUI/Form/Form.cs3491
-rw-r--r--source/ShiftUI/Form/FormClosedEventArgs.cs49
-rw-r--r--source/ShiftUI/Form/FormClosedEventHandler.cs32
-rw-r--r--source/ShiftUI/Form/FormClosingEventArgs.cs51
-rw-r--r--source/ShiftUI/Form/FormClosingEventHandler.cs32
-rw-r--r--source/ShiftUI/Form/FormCollection.cs73
-rw-r--r--source/ShiftUI/Form/FormStartPosition.cs39
-rw-r--r--source/ShiftUI/Form/FormWindowManager.cs87
-rw-r--r--source/ShiftUI/Form/FormWindowState.cs38
-rw-r--r--source/ShiftUI/Form/MessageBox.cs66
10 files changed, 3958 insertions, 0 deletions
diff --git a/source/ShiftUI/Form/Form.cs b/source/ShiftUI/Form/Form.cs
new file mode 100644
index 0000000..6cda945
--- /dev/null
+++ b/source/ShiftUI/Form/Form.cs
@@ -0,0 +1,3491 @@
+// 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-2006 Novell, Inc.
+//
+// Authors:
+// Peter Bartok [email protected]
+//
+
+// NOT COMPLETE
+
+using System;
+using System.Drawing;
+using System.ComponentModel;
+using System.ComponentModel.Design;
+using System.ComponentModel.Design.Serialization;
+using System.Collections;
+using System.Runtime.InteropServices;
+using System.Threading;
+using System.Collections.Generic;
+
+namespace ShiftUI {
+ [DesignerCategory("Form")]
+ [DesignTimeVisible(false)]
+ [Designer("ShiftUI.Design.FormDocumentDesigner, " + Consts.AssemblySystem_Design, typeof(IRootDesigner))]
+ [DefaultEvent("Load")]
+ [ClassInterface (ClassInterfaceType.AutoDispatch)]
+ [InitializationEvent ("Load")]
+ [ComVisible (true)]
+ [ToolboxItemFilter ("Widget.TopLevel")]
+ [ToolboxItem(false)]
+ public class Form : ContainerWidget {
+
+ public static readonly int BodyTag = 0x0AA40CE; //"Jonathan Ladouceur in hexadecimal + leetspeak because I can't think of another tag people won't use to muck up my designer.
+
+ private void drag_start(object s, MouseEventArgs a)
+ {
+ loc_last_x = a.Location.X;
+ loc_last_y = a.Location.Y;
+ }
+
+ private void drag_and_drop(object s, MouseEventArgs a)
+ {
+ if (a.Button == MouseButtons.Left && this.WindowState == FormWindowState.Normal)
+ {
+ this.Left += a.Location.X - loc_last_x;
+ this.Top += a.Location.Y - loc_last_y;
+
+ }
+ }
+
+ #region Local Variables
+ internal List<Widget> border_widgets;
+ internal int loc_last_x;
+ internal int loc_last_y;
+ internal bool closing;
+ private bool closed;
+ FormBorderStyle form_border_style;
+ private bool is_active;
+ private bool autoscale;
+ private Size clientsize_set;
+ private Size autoscale_base_size;
+ private bool allow_transparency;
+ private static Icon default_icon;
+ internal bool is_modal;
+ internal FormWindowState window_state;
+ private bool Widget_box;
+ private bool minimize_box;
+ private bool maximize_box;
+ private bool help_button;
+ private bool show_in_taskbar;
+ private bool topmost;
+ private IButtonWidget accept_button;
+ private IButtonWidget cancel_button;
+ private DialogResult dialog_result;
+ private FormStartPosition start_position;
+ private Form owner;
+ private Form.WidgetCollection owned_forms;
+ private MdiClient mdi_container;
+ internal InternalWindowManager window_manager;
+ private Form mdi_parent;
+ private bool key_preview;
+ private MainMenu menu;
+ private Icon icon;
+ private Size maximum_size;
+ private Size minimum_size;
+ private SizeGripStyle size_grip_style;
+ private SizeGrip size_grip;
+ private Rectangle maximized_bounds;
+ private Rectangle default_maximized_bounds;
+ private double opacity;
+ internal ApplicationContext context;
+ Color transparency_key;
+ private bool is_loaded;
+ internal int is_changing_visible_state;
+ internal bool has_been_visible;
+ private bool shown_raised;
+ private bool close_raised;
+ private bool is_clientsize_set;
+ internal bool suppress_closing_events;
+ internal bool waiting_showwindow; // for XplatUIX11
+ private bool is_minimizing;
+ private bool show_icon = true;
+ private MenuStrip main_menu_strip;
+ private bool right_to_left_layout;
+ private Rectangle restore_bounds;
+ private bool autoscale_base_size_set;
+ internal ArrayList disabled_by_showdialog = new ArrayList();
+ internal static ArrayList modal_dialogs = new ArrayList();
+ private Panel close_button;
+ private Panel minimize_button;
+ private Panel maximize_button;
+ private Panel titlebar;
+ private Panel titlebar_left;
+ private Panel titlebar_right;
+ private Panel border_left;
+ private Panel border_right;
+ private Panel border_bottom;
+ private Panel border_bottom_left;
+ private Panel border_bottom_right;
+ private Label title_text;
+ private PictureBox title_icon;
+ private Panel body;
+ private readonly string border_guid = Guid.NewGuid().ToString(); //distinguish border widgets from others
+
+ #endregion // Local Variables
+
+ #region Private & Internal Methods
+ static Form ()
+ {
+ default_icon = null;
+ }
+
+ internal bool IsLoaded {
+ get { return is_loaded; }
+ }
+
+ internal bool IsActive {
+ get {
+ return is_active;
+ }
+ set {
+ if (is_active == value || IsRecreating) {
+ return;
+ }
+
+ is_active = value;
+ if (is_active) {
+ Application.AddForm (this);
+ OnActivated (EventArgs.Empty);
+ } else {
+ OnDeactivate (EventArgs.Empty);
+ }
+ }
+ }
+
+ // warning: this is only hooked up when an mdi container is created.
+ private void WidgetAddedHandler (object sender, WidgetEventArgs e)
+ {
+ if (mdi_container != null) {
+ mdi_container.SendToBack ();
+ }
+ }
+
+ // Convenience method for fire BOTH OnClosing and OnFormClosing events
+ // Returns the value of Cancel, so true means the Close was cancelled,
+ // and you shouldn't close the form.
+ internal bool FireClosingEvents (CloseReason reason, bool cancel)
+ {
+ CancelEventArgs cea = new CancelEventArgs (cancel);
+ this.OnClosing (cea);
+
+ FormClosingEventArgs fcea = new FormClosingEventArgs (reason, cea.Cancel);
+ this.OnFormClosing (fcea);
+ return fcea.Cancel;
+ }
+
+ // Convenience method for fire BOTH OnClosed and OnFormClosed events
+ private void FireClosedEvents (CloseReason reason)
+ {
+ this.OnClosed (EventArgs.Empty);
+ this.OnFormClosed (new FormClosedEventArgs (reason));
+ }
+
+ internal override Size GetPreferredSizeCore (Size proposedSize)
+ {
+ Size retsize = Size.Empty;
+
+ foreach (Widget child in Widgets) {
+ Size child_preferred_size;
+ if (child.AutoSize)
+ child_preferred_size = child.PreferredSize;
+ else
+ child_preferred_size = child.ExplicitBounds.Size;
+ int child_right = child.Bounds.X + child_preferred_size.Width;
+ int child_bottom = child.Bounds.Y + child_preferred_size.Height;
+
+ if (child.Dock == DockStyle.Fill) {
+ if (child_right > retsize.Width)
+ retsize.Width = child_right;
+ }
+ else if (child.Dock != DockStyle.Top && child.Dock != DockStyle.Bottom && child_right > retsize.Width)
+ retsize.Width = child_right + child.Margin.Right;
+
+ if (child.Dock == DockStyle.Fill) {
+ if (child_bottom > retsize.Height)
+ retsize.Height = child_bottom;
+ }
+ else if (child.Dock != DockStyle.Left && child.Dock != DockStyle.Right && child_bottom > retsize.Height)
+ retsize.Height = child_bottom + child.Margin.Bottom;
+ }
+
+ if (retsize == Size.Empty) { // no child Widgets
+ retsize.Height += this.Padding.Top;
+ retsize.Width += this.Padding.Left;
+ }
+ retsize.Height += this.Padding.Bottom;
+ retsize.Width += this.Padding.Right;
+
+ return SizeFromClientSize (retsize);
+ }
+
+ //[EditorBrowsable (EditorBrowsableState.Advanced)]
+ protected override Rectangle GetScaledBounds (Rectangle bounds, SizeF factor, BoundsSpecified specified)
+ {
+ if ((specified & BoundsSpecified.Width) == BoundsSpecified.Width) {
+ int border = Size.Width - ClientSize.Width;
+ bounds.Width = (int)Math.Round ((bounds.Width - border) * factor.Width) + border;
+ }
+ if ((specified & BoundsSpecified.Height) == BoundsSpecified.Height) {
+ int border = Size.Height - ClientSize.Height;
+ bounds.Height = (int)Math.Round ((bounds.Height - border) * factor.Height) + border;
+ }
+
+ return bounds;
+ }
+
+ protected override bool ProcessMnemonic (char charCode)
+ {
+ return base.ProcessMnemonic (charCode);
+ }
+
+ //[EditorBrowsable (EditorBrowsableState.Advanced)]
+ protected override void ScaleWidget (SizeF factor, BoundsSpecified specified)
+ {
+ base.ScaleWidget (factor, specified);
+ }
+
+ internal void OnActivatedInternal ()
+ {
+ OnActivated (EventArgs.Empty);
+ }
+
+ internal void OnDeactivateInternal ()
+ {
+ OnDeactivate (EventArgs.Empty);
+ }
+
+ internal override void UpdateWindowText ()
+ {
+ if (!IsHandleCreated) {
+ return;
+ }
+
+ if (shown_raised) {
+ /* we need to call .SetWindowStyle here instead of just .Text
+ because the presence/absence of Text (== "" or not) can cause
+ other window style things to appear/disappear */
+ XplatUI.SetWindowStyle (window.Handle, CreateParams);
+ }
+
+ XplatUI.Text (Handle, Text.Replace (Environment.NewLine, string.Empty));
+ }
+
+ internal void SelectActiveWidget ()
+ {
+ if (this.IsMdiContainer) {
+ mdi_container.SendFocusToActiveChild ();
+ return;
+ }
+
+ if (this.ActiveWidget == null) {
+ bool visible;
+
+ // This visible hack is to work around CanSelect always being false if one of the parents
+ // is not visible; and we by default create Form invisible...
+ visible = this.is_visible;
+ this.is_visible = true;
+
+ if (SelectNextWidget (this, true, true, true, true) == false) {
+ Select (this);
+ }
+
+ this.is_visible = visible;
+ } else {
+ Select (ActiveWidget);
+ }
+ }
+
+ private new void UpdateSizeGripVisible ()
+ {
+ // Following link explains when to show size grip:
+ // http://forums.microsoft.com/MSDN/ShowPost.aspx?PostID=138687&SiteID=1
+ // if SizeGripStyle.Auto, only shown if form is shown using ShowDialog and is sizable
+ // if SizeGripStyle.Show, only shown if form is sizable
+
+ bool show = false;
+
+ switch (size_grip_style) {
+ case SizeGripStyle.Auto:
+ show = is_modal && (form_border_style == FormBorderStyle.Sizable || form_border_style == FormBorderStyle.SizableToolWindow);
+ break;
+ case SizeGripStyle.Hide:
+ show = false;
+ break;
+ case SizeGripStyle.Show:
+ show = (form_border_style == FormBorderStyle.Sizable || form_border_style == FormBorderStyle.SizableToolWindow);
+ break;
+ }
+
+ if (!show) {
+ if (size_grip != null && size_grip.Visible)
+ size_grip.Visible = false;
+ } else {
+ if (size_grip == null) {
+ size_grip = new SizeGrip (this);
+ size_grip.Virtual = true;
+ size_grip.FillBackground = false;
+ }
+ size_grip.Visible = true;
+ }
+ }
+
+ internal void ChangingParent (Widget new_parent)
+ {
+ if (IsMdiChild) {
+ return;
+ }
+
+ bool recreate_necessary = false;
+
+ if (new_parent == null) {
+ window_manager = null;
+ } else if (new_parent is MdiClient) {
+ window_manager = new MdiWindowManager (this, (MdiClient) new_parent);
+ } else {
+ window_manager = new FormWindowManager (this);
+ recreate_necessary = true;
+ }
+
+ if (recreate_necessary) {
+ if (IsHandleCreated) {
+ if (new_parent != null && new_parent.IsHandleCreated) {
+ RecreateHandle ();
+ } else {
+ DestroyHandle ();
+ }
+ }
+ } else {
+ if (IsHandleCreated) {
+ IntPtr new_handle = IntPtr.Zero;
+ if (new_parent != null && new_parent.IsHandleCreated) {
+ new_handle = new_parent.Handle;
+ }
+ XplatUI.SetParent (Handle, new_handle);
+ }
+ }
+
+ if (window_manager != null) {
+ window_manager.UpdateWindowState (window_state, window_state, true);
+ }
+ }
+
+ internal override bool FocusInternal (bool skip_check)
+ {
+ if (IsMdiChild) {
+ // MS always creates handles when Focus () is called for mdi clients.
+ if (!IsHandleCreated)
+ CreateHandle ();
+ }
+ return base.FocusInternal (skip_check);
+ }
+ #endregion // Private & Internal Methods
+
+ #region Public Classes
+ [ComVisible (false)]
+ public new class WidgetCollection : Widget.WidgetCollection {
+ Form form_owner;
+
+ public WidgetCollection(Form owner) : base(owner) {
+ this.form_owner = owner;
+ }
+
+ public override void Add(Widget value) {
+ if (Contains (value))
+ return;
+ AddToList (value);
+ ((Form)value).owner=form_owner;
+ }
+
+ public override void Remove(Widget value) {
+ ((Form)value).owner = null;
+ base.Remove (value);
+ }
+ }
+ #endregion // Public Classes
+
+ public Widget[] BorderWidgets
+ {
+ get
+ {
+ return border_widgets.ToArray();
+ }
+ }
+
+ /// <summary>
+ /// Gets the body panel of the form.
+ /// </summary>
+ public Panel Body
+ {
+ get { return body; }
+ }
+
+ #region Public Constructor & Destructor
+ public Form ()
+ {
+ SizeF current_scale = GetAutoScaleSize (Font);
+
+ autoscale = true;
+ autoscale_base_size = new Size ((int)Math.Round (current_scale.Width), (int)Math.Round(current_scale.Height));
+ allow_transparency = false;
+ closing = false;
+ is_modal = false;
+ dialog_result = DialogResult.None;
+ start_position = FormStartPosition.WindowsDefaultLocation;
+ form_border_style = FormBorderStyle.Sizable;
+ window_state = FormWindowState.Normal;
+ key_preview = false;
+ opacity = 1D;
+ menu = null;
+ icon = default_icon;
+ minimum_size = Size.Empty;
+ maximum_size = Size.Empty;
+ clientsize_set = Size.Empty;
+ Widget_box = true;
+ minimize_box = true;
+ maximize_box = true;
+ help_button = false;
+ show_in_taskbar = true;
+ is_visible = false;
+ is_toplevel = true;
+ size_grip_style = SizeGripStyle.Auto;
+ maximized_bounds = Rectangle.Empty;
+ default_maximized_bounds = Rectangle.Empty;
+ owned_forms = new Form.WidgetCollection(this);
+ transparency_key = Color.Empty;
+ CreateDockPadding ();
+ InternalClientSize = new Size (this.Width - (SystemInformation.FrameBorderSize.Width * 2), this.Height - (SystemInformation.FrameBorderSize.Height * 2) - SystemInformation.CaptionHeight);
+ restore_bounds = Bounds;
+ BorderStyle = FormBorderStyle.None;
+ titlebar = new Panel();
+ this.Widgets.Add(titlebar);
+ titlebar.Dock = DockStyle.Top;
+ titlebar.Height = 24;
+ titlebar.BackColor = Color.Gray;
+ titlebar.Tag = border_guid;
+ border_widgets = new List<Widget>();
+ border_widgets.Add(titlebar);
+
+ titlebar_left = new Panel();
+ titlebar_left.Dock = DockStyle.Left;
+ titlebar.Widgets.Add(titlebar_left);
+ titlebar_left.Show();
+ titlebar_right = new Panel();
+ titlebar_right.Dock = DockStyle.Right;
+ titlebar.Widgets.Add(titlebar_right);
+ titlebar_right.Show();
+
+ title_text = new Label();
+ titlebar.Widgets.Add(title_text);
+ title_text.Show();
+
+ border_left = new Panel();
+ border_left.Dock = DockStyle.Left;
+ border_left.Tag = border_guid;
+ border_widgets.Add(border_left);
+ this.Widgets.Add(border_left);
+ border_left.Show();
+
+ border_right = new Panel();
+ border_right.Dock = DockStyle.Right;
+ border_right.Tag = border_guid;
+ this.Widgets.Add(border_right);
+ border_right.Show();
+ border_widgets.Add(border_right);
+
+ border_bottom = new Panel();
+ border_bottom.Dock = DockStyle.Bottom;
+ border_bottom.Tag = border_guid;
+ this.Widgets.Add(border_bottom);
+ border_bottom.Show();
+ border_widgets.Add(border_bottom);
+
+ body = new Panel();
+ body.Dock = DockStyle.Fill;
+ body.Tag = border_guid;
+ body.Tag = Form.BodyTag;
+ body.Show();
+ body.BringToFront();
+ body.BringToFront();
+ close_button = new Panel();
+ close_button.MouseDown += (o, a) =>
+ {
+ if (a.Button == MouseButtons.Left)
+ {
+ this.Close();
+ }
+ };
+ body.Name = "Body";
+ minimize_button = new Panel();
+ minimize_button.Click += (o, a) =>
+ {
+ this.WindowState = FormWindowState.Minimized;
+ };
+ titlebar.Widgets.Add(minimize_button);
+ minimize_button.Show();
+
+ maximize_button = new Panel();
+ maximize_button.Click += (o, a) =>
+ {
+ if (this.WindowState == FormWindowState.Maximized)
+ this.WindowState = FormWindowState.Normal;
+ else
+ this.WindowState = FormWindowState.Maximized;
+ };
+ titlebar.Widgets.Add(maximize_button);
+ maximize_button.Show();
+
+ titlebar.Widgets.Add(close_button);
+ close_button.Show();
+
+ this.Widgets.Add(body);
+ body.BringToFront();
+ this.WidgetAdded += (o, a) =>
+ {
+ if ((string)a.Widget.Tag != border_guid && a.Widget != body)
+ {
+ this.Widgets.Remove(a.Widget);
+ body.Widgets.Add(a.Widget);
+ a.Widget.Show();
+ }
+
+ };
+ titlebar.MouseMove += new MouseEventHandler(this.drag_and_drop);
+ title_text.MouseMove += new MouseEventHandler(this.drag_and_drop);
+ titlebar.MouseDown += new MouseEventHandler(this.drag_start);
+ title_text.MouseDown += new MouseEventHandler(this.drag_start);
+
+ ResetSkin();
+ }
+ #endregion // Public Constructor & Destructor
+
+ #region Public Static Properties
+
+ public static Form ActiveForm {
+ get {
+ Widget active;
+
+ active = FromHandle(XplatUI.GetActive());
+
+ if (active != null) {
+ if ( !(active is Form)) {
+ Widget parent;
+
+ parent = active.Parent;
+ while (parent != null) {
+ if (parent is Form) {
+ return (Form)parent;
+ }
+ parent = parent.Parent;
+ }
+ } else {
+ return (Form)active;
+ }
+ }
+ return null;
+ }
+ }
+
+ #endregion // Public Static Properties
+
+ #region Public Instance Properties
+ [DefaultValue(null)]
+ public IButtonWidget AcceptButton {
+ get {
+ return accept_button;
+ }
+
+ set {
+ if (accept_button != null)
+ accept_button.NotifyDefault (false);
+
+ accept_button = value;
+ if (accept_button != null)
+ accept_button.NotifyDefault (true);
+
+ CheckAcceptButton ();
+ }
+ }
+
+ [Browsable(false)]
+ //[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
+ public bool AllowTransparency {
+ get {
+ return allow_transparency;
+ }
+
+ set {
+ if (value == allow_transparency) {
+ return;
+ }
+
+ allow_transparency = value;
+
+ if (value) {
+ if (IsHandleCreated) {
+ if ((XplatUI.SupportsTransparency() & TransparencySupport.Set) != 0) {
+ XplatUI.SetWindowTransparency(Handle, Opacity, TransparencyKey);
+ }
+ } else {
+ UpdateStyles(); // Remove the WS_EX_LAYERED style
+ }
+ }
+ }
+ }
+
+ [Browsable (false)]
+ //[EditorBrowsable (EditorBrowsableState.Never)]
+ //[DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
+ [Obsolete ("This property has been deprecated in favor of AutoScaleMode.")]
+ [MWFCategory("Layout")]
+ public bool AutoScale {
+ get {
+ return autoscale;
+ }
+
+ set {
+ if (value)
+ AutoScaleMode = AutoScaleMode.None;
+
+ autoscale = value;
+ }
+ }
+
+ //[DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
+ //[EditorBrowsable(EditorBrowsableState.Never)]
+ [Localizable(true)]
+ [Browsable(false)]
+ public virtual Size AutoScaleBaseSize {
+ get {
+ return autoscale_base_size;
+ }
+ [MonoTODO ("Setting this is probably unintentional and can cause Forms to be improperly sized. See http://www.mono-project.com/FAQ:_Winforms#My_forms_are_sized_improperly for details.")]
+ set {
+ autoscale_base_size = value;
+ autoscale_base_size_set = true;
+ }
+ }
+
+ [Localizable(true)]
+ public override bool AutoScroll {
+ get {
+ return base.AutoScroll;
+ }
+ set {
+ base.AutoScroll = value;
+ }
+ }
+
+ internal bool ShouldSerializeAutoScroll ()
+ {
+ return this.AutoScroll != false;
+ }
+
+ [Browsable (true)]
+ //[EditorBrowsable (EditorBrowsableState.Always)]
+ //[DesignerSerializationVisibility (DesignerSerializationVisibility.Visible)]
+ public override bool AutoSize {
+ get { return base.AutoSize; }
+ set {
+ if (base.AutoSize != value) {
+ base.AutoSize = value;
+ PerformLayout (this, "AutoSize");
+ }
+ }
+ }
+
+ internal bool ShouldSerializeAutoSize ()
+ {
+ return this.AutoSize != false;
+ }
+
+ [Browsable (true)]
+ [Localizable (true)]
+ [DefaultValue (AutoSizeMode.GrowOnly)]
+ public AutoSizeMode AutoSizeMode {
+ get { return base.GetAutoSizeMode (); }
+ set {
+ if (base.GetAutoSizeMode () != value) {
+ if (!Enum.IsDefined (typeof (AutoSizeMode), value))
+ throw new InvalidEnumArgumentException (string.Format ("Enum argument value '{0}' is not valid for AutoSizeMode", value));
+
+ base.SetAutoSizeMode (value);
+ PerformLayout (this, "AutoSizeMode");
+ }
+ }
+ }
+
+ [Browsable (true)]
+ //[EditorBrowsable (EditorBrowsableState.Always)]
+ public override AutoValidate AutoValidate {
+ get { return base.AutoValidate; }
+ set { base.AutoValidate = value; }
+ }
+
+ public override Color BackColor {
+ get {
+ /* we don't let parents override our
+ default background color for forms.
+ this fixes the default color for mdi
+ children. */
+ if (background_color.IsEmpty)
+ return DefaultBackColor;
+ else
+ return background_color;
+ }
+ set {
+ base.BackColor = value;
+ }
+ }
+
+ [DefaultValue(null)]
+ public IButtonWidget CancelButton {
+ get {
+ return cancel_button;
+ }
+
+ set {
+ cancel_button = value;
+ if (cancel_button != null && cancel_button.DialogResult == DialogResult.None)
+ cancel_button.DialogResult = DialogResult.Cancel;
+ }
+ }
+
+ // new property so we can change the DesignerSerializationVisibility
+ //[DesignerSerializationVisibility(DesignerSerializationVisibility.Visible)]
+ [Localizable(true)]
+ public new Size ClientSize {
+ get { return base.ClientSize; }
+ set {
+ is_clientsize_set = true;
+ base.ClientSize = value;
+ }
+ }
+
+ [DefaultValue(true)]
+ [MWFCategory("Window Style")]
+ public bool WidgetBox {
+ get {
+ return Widget_box;
+ }
+
+ set {
+ if (Widget_box != value) {
+ Widget_box = value;
+ UpdateStyles();
+ }
+ }
+ }
+
+ [Browsable(false)]
+ //[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
+ public Rectangle DesktopBounds {
+ get {
+ return new Rectangle(Location, Size);
+ }
+
+ set {
+ Bounds = value;
+ }
+ }
+
+ [Browsable(false)]
+ //[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
+ public Point DesktopLocation {
+ get {
+ return Location;
+ }
+
+ set {
+ Location = value;
+ }
+ }
+
+ [Browsable(false)]
+ //[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
+ public DialogResult DialogResult {
+ get {
+ return dialog_result;
+ }
+
+ set {
+ if (value < DialogResult.None || value > DialogResult.No)
+ throw new InvalidEnumArgumentException ("value", (int) value,
+ typeof (DialogResult));
+
+ dialog_result = value;
+ if (dialog_result != DialogResult.None && is_modal)
+ RaiseCloseEvents (false, false); // .Net doesn't send WM_CLOSE here.
+ }
+ }
+
+ private FormBorderStyle custom_border_style = FormBorderStyle.Sizable;
+
+ public FormBorderStyle FormBorderStyle
+ {
+ get { return custom_border_style; }
+ set { custom_border_style = value; ResetSkin(); }
+ }
+
+ private FormBorderStyle BorderStyle {
+ get {
+ return form_border_style;
+ }
+ set {
+ form_border_style = value;
+
+ if (window_manager == null) {
+ if (IsHandleCreated) {
+ XplatUI.SetBorderStyle(window.Handle, form_border_style);
+ }
+ } else {
+ window_manager.UpdateBorderStyle (value);
+ }
+
+ Size current_client_size = ClientSize;
+ UpdateStyles();
+
+ if (this.IsHandleCreated) {
+ this.Size = InternalSizeFromClientSize (current_client_size);
+ XplatUI.InvalidateNC (this.Handle);
+ } else if (is_clientsize_set) {
+ this.Size = InternalSizeFromClientSize (current_client_size);
+ }
+ }
+ }
+
+ [DefaultValue(false)]
+ [MWFCategory("Window Style")]
+ public bool HelpButton {
+ get {
+ return help_button;
+ }
+
+ set {
+ if (help_button != value) {
+ help_button = value;
+ UpdateStyles();
+ }
+ }
+ }
+
+ [Localizable(true)]
+ [AmbientValue(null)]
+ [MWFCategory("Window Style")]
+ public Icon Icon {
+ get {
+ return icon;
+ }
+
+ set {
+ if (value == null)
+ value = default_icon;
+ if (icon == value)
+ return;
+ icon = value;
+ if (IsHandleCreated)
+ XplatUI.SetIcon (Handle, icon);
+ }
+ }
+
+ internal bool ShouldSerializeIcon ()
+ {
+ return this.Icon != default_icon;
+ }
+
+ [Browsable(false)]
+ //[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
+ public bool IsMdiChild {
+ get {
+ return mdi_parent != null;
+ }
+ }
+
+ [DefaultValue(false)]
+ [MWFCategory("Window Style")]
+ public bool IsMdiContainer {
+ get {
+ return mdi_container != null;
+ }
+
+ set {
+ if (value && mdi_container == null) {
+ mdi_container = new MdiClient ();
+ Widgets.Add(mdi_container);
+ WidgetAdded += new WidgetEventHandler (WidgetAddedHandler);
+ mdi_container.SendToBack ();
+ mdi_container.SetParentText (true);
+ } else if (!value && mdi_container != null) {
+ Widgets.Remove(mdi_container);
+ mdi_container = null;
+ }
+ }
+ }
+
+ [Browsable(false)]
+ //[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
+ public Form ActiveMdiChild {
+ get {
+ if (!IsMdiContainer)
+ return null;
+ return (Form) mdi_container.ActiveMdiChild;
+ }
+ }
+
+ [Browsable(false)]
+ //[EditorBrowsable(EditorBrowsableState.Advanced)]
+ public bool IsRestrictedWindow {
+ get {
+ return false;
+ }
+ }
+
+ [DefaultValue(false)]
+ public bool KeyPreview {
+ get {
+ return key_preview;
+ }
+
+ set {
+ key_preview = value;
+ }
+ }
+
+ [DefaultValue (null)]
+ [TypeConverter (typeof (ReferenceConverter))]
+ public MenuStrip MainMenuStrip {
+ get { return this.main_menu_strip; }
+ set {
+ if (this.main_menu_strip != value) {
+ this.main_menu_strip = value;
+ this.main_menu_strip.RefreshMdiItems ();
+ }
+ }
+ }
+
+ //[EditorBrowsable (EditorBrowsableState.Never)]
+ [Browsable (false)]
+ public new Padding Margin {
+ get { return base.Margin; }
+ set { base.Margin = value; }
+ }
+
+ [Obsolete("Minimize, Maximize and Close buttons are dealt with by the skin system.")]
+ [DefaultValue(true)]
+ [MWFCategory("Obsolete")]
+ public bool MaximizeBox {
+ get {
+ return maximize_box;
+ }
+ set {
+ if (maximize_box != value) {
+ maximize_box = value;
+ UpdateStyles();
+ }
+ }
+ }
+
+ [DefaultValue(typeof (Size),"0, 0")]
+ [Localizable(true)]
+ [RefreshProperties(RefreshProperties.Repaint)]
+ [MWFCategory("Layout")]
+ public override Size MaximumSize {
+ get {
+ return maximum_size;
+ }
+
+ set {
+ if (maximum_size != value) {
+ maximum_size = value;
+
+ // If this is smaller than the min, adjust the min
+ if (!minimum_size.IsEmpty) {
+ if (maximum_size.Width <= minimum_size.Width)
+ minimum_size.Width = maximum_size.Width;
+ if (maximum_size.Height <= minimum_size.Height)
+ minimum_size.Height = maximum_size.Height;
+ }
+
+ OnMaximumSizeChanged(EventArgs.Empty);
+ if (IsHandleCreated) {
+ XplatUI.SetWindowMinMax(Handle, maximized_bounds, minimum_size, maximum_size);
+ }
+ }
+ }
+ }
+
+ [Browsable(false)]
+ //[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
+ public Form[] MdiChildren {
+ get {
+ if (mdi_container != null)
+ return mdi_container.MdiChildren;
+ else
+ return new Form[0];
+ }
+ }
+
+ [Browsable(false)]
+ //[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
+ public Form MdiParent {
+ get {
+ return mdi_parent;
+ }
+
+ set {
+ if (value == mdi_parent)
+ return;
+
+ if (value != null && !value.IsMdiContainer)
+ throw new ArgumentException ("Form that was specified to be "
+ + "the MdiParent for this form is not an MdiContainer.");
+
+ if (mdi_parent != null) {
+ mdi_parent.MdiContainer.Widgets.Remove (this);
+ }
+
+ if (value != null) {
+ mdi_parent = value;
+ if (window_manager == null) {
+ window_manager = new MdiWindowManager (this, mdi_parent.MdiContainer);
+ }
+
+ mdi_parent.MdiContainer.Widgets.Add (this);
+ mdi_parent.MdiContainer.Widgets.SetChildIndex (this, 0);
+
+ if (IsHandleCreated)
+ RecreateHandle ();
+ } else if (mdi_parent != null) {
+ mdi_parent = null;
+
+ // Create a new window manager
+ window_manager = null;
+ FormBorderStyle = form_border_style;
+
+ if (IsHandleCreated)
+ RecreateHandle ();
+ }
+ is_toplevel = mdi_parent == null;
+ }
+ }
+
+ internal MdiClient MdiContainer {
+ get { return mdi_container; }
+ }
+
+ internal InternalWindowManager WindowManager {
+ get { return window_manager; }
+ }
+
+ [Browsable (false)]
+ [TypeConverter (typeof (ReferenceConverter))]
+ [DefaultValue(null)]
+ [MWFCategory("Window Style")]
+ public MainMenu Menu {
+ get {
+ return menu;
+ }
+
+ set {
+ if (menu != value) {
+ menu = value;
+
+ if (menu != null && !IsMdiChild) {
+ menu.SetForm (this);
+
+ if (IsHandleCreated) {
+ XplatUI.SetMenu (window.Handle, menu);
+ }
+
+ if (clientsize_set != Size.Empty) {
+ SetClientSizeCore(clientsize_set.Width, clientsize_set.Height);
+ } else {
+ UpdateBounds (bounds.X, bounds.Y, bounds.Width, bounds.Height, ClientSize.Width, ClientSize.Height -
+ ThemeEngine.Current.CalcMenuBarSize (DeviceContext, menu, ClientSize.Width));
+ }
+ } else
+ UpdateBounds ();
+
+ // UIA Framework Event: Menu Changed
+ OnUIAMenuChanged (EventArgs.Empty);
+ }
+ }
+ }
+
+ [Browsable(false)]
+ //[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
+ //[EditorBrowsable(EditorBrowsableState.Advanced)]
+ public MainMenu MergedMenu {
+ get {
+ if (!IsMdiChild || window_manager == null)
+ return null;
+ return ((MdiWindowManager) window_manager).MergedMenu;
+ }
+ }
+
+ // This is the menu in display and being used because of merging this can
+ // be different then the menu that is actually assosciated with the form
+ internal MainMenu ActiveMenu {
+ get {
+ if (IsMdiChild)
+ return null;
+
+ if (IsMdiContainer && mdi_container.Widgets.Count > 0 &&
+ ((Form) mdi_container.Widgets [0]).WindowState == FormWindowState.Maximized) {
+ MdiWindowManager wm = (MdiWindowManager) ((Form) mdi_container.Widgets [0]).WindowManager;
+ return wm.MaximizedMenu;
+ }
+
+ Form amc = ActiveMdiChild;
+ if (amc == null || amc.Menu == null)
+ return menu;
+ return amc.MergedMenu;
+ }
+ }
+
+ internal MdiWindowManager ActiveMaximizedMdiChild {
+ get {
+ Form child = ActiveMdiChild;
+ if (child == null)
+ return null;
+ if (child.WindowManager == null || child.window_state != FormWindowState.Maximized)
+ return null;
+ return (MdiWindowManager) child.WindowManager;
+ }
+ }
+
+ [DefaultValue(true)]
+ [MWFCategory("Window Style")]
+ public bool MinimizeBox {
+ get {
+ return minimize_box;
+ }
+ set {
+ if (minimize_box != value) {
+ minimize_box = value;
+ UpdateStyles();
+ }
+ }
+ }
+
+ [Localizable(true)]
+ [RefreshProperties(RefreshProperties.Repaint)]
+ [MWFCategory("Layout")]
+ public override Size MinimumSize {
+ get {
+ return minimum_size;
+ }
+
+ set {
+ if (minimum_size != value) {
+ minimum_size = value;
+
+ // If this is bigger than the max, adjust the max
+ if (!maximum_size.IsEmpty) {
+ if (minimum_size.Width >= maximum_size.Width)
+ maximum_size.Width = minimum_size.Width;
+ if (minimum_size.Height >= maximum_size.Height)
+ maximum_size.Height = minimum_size.Height;
+ }
+
+ if ((Size.Width < value.Width) || (Size.Height < value.Height)) {
+ Size = new Size(Math.Max(Size.Width, value.Width), Math.Max(Size.Height, value.Height));
+ }
+
+
+ OnMinimumSizeChanged(EventArgs.Empty);
+ if (IsHandleCreated) {
+ XplatUI.SetWindowMinMax(Handle, maximized_bounds, minimum_size, maximum_size);
+ }
+ }
+ }
+ }
+
+ [Browsable(false)]
+ //[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
+ public bool Modal {
+ get {
+ return is_modal;
+ }
+ }
+
+ [DefaultValue(1D)]
+ [TypeConverter(typeof(OpacityConverter))]
+ [MWFCategory("Window Style")]
+ public double Opacity {
+ get {
+ if (IsHandleCreated) {
+ if ((XplatUI.SupportsTransparency () & TransparencySupport.Get) != 0)
+ return XplatUI.GetWindowTransparency (Handle);
+ }
+
+ return opacity;
+ }
+
+ set {
+ opacity = value;
+
+ if (opacity < 0)
+ opacity = 0;
+
+ if (opacity > 1)
+ opacity = 1;
+
+ AllowTransparency = true;
+
+ if (IsHandleCreated) {
+ UpdateStyles();
+ if ((XplatUI.SupportsTransparency () & TransparencySupport.Set) != 0)
+ XplatUI.SetWindowTransparency(Handle, opacity, TransparencyKey);
+ }
+ }
+ }
+
+
+ [Browsable(false)]
+ //[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
+ public Form[] OwnedForms {
+ get {
+ Form[] form_list;
+
+ form_list = new Form[owned_forms.Count];
+
+ for (int i=0; i<owned_forms.Count; i++) {
+ form_list[i] = (Form)owned_forms[i];
+ }
+
+ return form_list;
+ }
+ }
+
+ [Browsable(false)]
+ //[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
+ public Form Owner {
+ get {
+ return owner;
+ }
+
+ set {
+ if (owner != value) {
+ if (owner != null) {
+ owner.RemoveOwnedForm(this);
+ }
+ owner = value;
+ if (owner != null)
+ owner.AddOwnedForm(this);
+ if (IsHandleCreated) {
+ if (owner != null && owner.IsHandleCreated) {
+ XplatUI.SetOwner(this.window.Handle, owner.window.Handle);
+ } else {
+ XplatUI.SetOwner(this.window.Handle, IntPtr.Zero);
+ }
+ }
+ }
+ }
+ }
+
+ [Browsable (false)]
+ //[DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
+ public Rectangle RestoreBounds {
+ get { return restore_bounds; }
+ }
+
+ [Localizable (true)]
+ [DefaultValue (false)]
+ public virtual bool RightToLeftLayout {
+ get { return this.right_to_left_layout; }
+ set { this.right_to_left_layout = value; }
+ }
+
+ [DefaultValue (true)]
+ public bool ShowIcon {
+ get { return this.show_icon; }
+ set {
+ if (this.show_icon != value ) {
+ this.show_icon = value;
+ UpdateStyles ();
+ ResetSkin();
+ if (IsHandleCreated) {
+ XplatUI.SetIcon (this.Handle, value == true ? this.Icon : null);
+ XplatUI.InvalidateNC (this.Handle);
+ }
+ }
+ }
+ }
+
+ [DefaultValue(true)]
+ [MWFCategory("Window Style")]
+ public bool ShowInTaskbar {
+ get {
+ return show_in_taskbar;
+ }
+ set {
+ if (show_in_taskbar != value) {
+ show_in_taskbar = value;
+ if (IsHandleCreated) {
+ RecreateHandle();
+ }
+ UpdateStyles();
+ }
+ }
+ }
+
+ // new property so we can set the DesignerSerializationVisibility
+ //[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
+ [Localizable(false)]
+ public new Size Size {
+ get { return base.Size; }
+ set { base.Size = value; ResetSkin(); }
+ }
+
+ [DefaultValue(SizeGripStyle.Auto)]
+ [MWFCategory("Window Style")]
+ public SizeGripStyle SizeGripStyle {
+ get {
+ return size_grip_style;
+ }
+
+ set {
+ size_grip_style = value;
+ UpdateSizeGripVisible ();
+ }
+ }
+
+ [DefaultValue(FormStartPosition.WindowsDefaultLocation)]
+ [Localizable(true)]
+ [MWFCategory("Layout")]
+ public FormStartPosition StartPosition {
+ get {
+ return start_position;
+ }
+
+ set {
+ start_position = value;
+ }
+ }
+
+ // new property so we can set EditorBrowsable to never
+ [Browsable(false)]
+ //[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
+ //[EditorBrowsable(EditorBrowsableState.Never)]
+ public new int TabIndex {
+ get { return base.TabIndex; }
+ set { base.TabIndex = value; }
+ }
+
+ [Browsable(false)]
+ [DefaultValue (true)]
+ [DispIdAttribute (-516)]
+ //[EditorBrowsable(EditorBrowsableState.Never)]
+ public new bool TabStop {
+ get { return base.TabStop; }
+ set { base.TabStop = value; }
+ }
+
+ [Browsable(false)]
+ //[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
+ //[EditorBrowsable(EditorBrowsableState.Advanced)]
+ public bool TopLevel {
+ get {
+ return GetTopLevel();
+ }
+
+ set {
+ if (!value && IsMdiContainer)
+ throw new ArgumentException ("MDI Container forms must be top level.");
+ SetTopLevel(value);
+ }
+ }
+
+ [DefaultValue(false)]
+ [MWFCategory("Window Style")]
+ public bool TopMost {
+ get {
+ return topmost;
+ }
+
+ set {
+ if (topmost != value) {
+ topmost = value;
+ if (IsHandleCreated)
+ XplatUI.SetTopmost(window.Handle, value);
+
+ // UIA Framework: Raises internal event
+ OnUIATopMostChanged ();
+ }
+ }
+ }
+
+ [MWFCategory("Window Style")]
+ public Color TransparencyKey {
+ get {
+ return transparency_key;
+ }
+
+ set {
+ transparency_key = value;
+
+ AllowTransparency = true;
+ UpdateStyles();
+ if (IsHandleCreated && (XplatUI.SupportsTransparency () & TransparencySupport.Set) != 0)
+ XplatUI.SetWindowTransparency(Handle, Opacity, transparency_key);
+ }
+ }
+
+ internal bool ShouldSerializeTransparencyKey ()
+ {
+ return this.TransparencyKey != Color.Empty;
+ }
+
+ [DefaultValue(FormWindowState.Normal)]
+ [MWFCategory("Layout")]
+ public FormWindowState WindowState {
+ get {
+ // Don't actually rely on the WM until we've been shown
+ if (IsHandleCreated && shown_raised) {
+
+ if (window_manager != null)
+ return window_manager.GetWindowState ();
+
+ FormWindowState new_state = XplatUI.GetWindowState(Handle);
+ if (new_state != (FormWindowState)(-1))
+ window_state = new_state;
+ }
+
+ return window_state;
+ }
+
+ set {
+ FormWindowState old_state = window_state;
+ window_state = value;
+ if (IsHandleCreated && shown_raised) {
+
+ if (window_manager != null) {
+ window_manager.SetWindowState (old_state, value);
+ return;
+ }
+
+ XplatUI.SetWindowState(Handle, value);
+ }
+
+ // UIA Framework: Raises internal event
+ if (old_state != window_state)
+ OnUIAWindowStateChanged ();
+
+ ResetSkin();
+ }
+ }
+
+ #endregion // Public Instance Properties
+
+ #region Protected Instance Properties
+ protected override CreateParams CreateParams {
+ get {
+ CreateParams cp = new CreateParams ();
+
+ if (Text != null)
+ cp.Caption = Text.Replace (Environment.NewLine, string.Empty);
+
+ cp.ClassName = XplatUI.GetDefaultClassName (GetType ());
+ cp.ClassStyle = 0;
+ cp.Style = 0;
+ cp.ExStyle = 0;
+ cp.Param = 0;
+ cp.Parent = IntPtr.Zero;
+ cp.menu = ActiveMenu;
+ cp.control = this;
+
+ if (((Parent != null || !TopLevel) && !IsMdiChild)) {
+ // Parented forms and non-toplevel forms always gets the specified location, no matter what
+ cp.X = Left;
+ cp.Y = Top;
+ } else {
+ switch (start_position) {
+ case FormStartPosition.Manual:
+ cp.X = Left;
+ cp.Y = Top;
+ break;
+ case FormStartPosition.CenterScreen:
+ if (IsMdiChild) {
+ cp.X = Math.Max ((MdiParent.mdi_container.ClientSize.Width - Width) / 2, 0);
+ cp.Y = Math.Max ((MdiParent.mdi_container.ClientSize.Height - Height) / 2, 0);
+ } else {
+ cp.X = Math.Max ((Screen.PrimaryScreen.WorkingArea.Width - Width) / 2, 0);
+ cp.Y = Math.Max ((Screen.PrimaryScreen.WorkingArea.Height - Height) / 2, 0);
+ }
+ break;
+ case FormStartPosition.CenterParent:
+ case FormStartPosition.WindowsDefaultBounds:
+ case FormStartPosition.WindowsDefaultLocation:
+ cp.X = int.MinValue;
+ cp.Y = int.MinValue;
+ break;
+ }
+ }
+ cp.Width = Width;
+ cp.Height = Height;
+
+ cp.Style = (int)(WindowStyles.WS_CLIPCHILDREN);
+ if (!Modal) {
+ cp.WindowStyle |= WindowStyles.WS_CLIPSIBLINGS;
+ }
+
+ if (Parent != null && Parent.IsHandleCreated) {
+ cp.Parent = Parent.Handle;
+ cp.Style |= (int) WindowStyles.WS_CHILD;
+ }
+
+ if (IsMdiChild) {
+ cp.Style |= (int)(WindowStyles.WS_CHILD | WindowStyles.WS_CAPTION);
+ if (Parent != null) {
+ cp.Parent = Parent.Handle;
+ }
+
+ cp.ExStyle |= (int) (WindowExStyles.WS_EX_WINDOWEDGE | WindowExStyles.WS_EX_MDICHILD);
+
+ switch (FormBorderStyle) {
+ case FormBorderStyle.None:
+ break;
+ case FormBorderStyle.FixedToolWindow:
+ case FormBorderStyle.SizableToolWindow:
+ cp.ExStyle |= (int) WindowExStyles.WS_EX_TOOLWINDOW;
+ goto default;
+ default:
+ cp.Style |= (int) WindowStyles.WS_OVERLAPPEDWINDOW;
+ break;
+ }
+
+ } else {
+ switch (BorderStyle) {
+ case FormBorderStyle.Fixed3D: {
+ cp.Style |= (int)(WindowStyles.WS_CAPTION | WindowStyles.WS_BORDER);
+ cp.ExStyle |= (int)WindowExStyles.WS_EX_CLIENTEDGE;
+ break;
+ }
+
+ case FormBorderStyle.FixedDialog: {
+ cp.Style |= (int)(WindowStyles.WS_CAPTION | WindowStyles.WS_BORDER);
+ cp.ExStyle |= (int)(WindowExStyles.WS_EX_DLGMODALFRAME | WindowExStyles.WS_EX_WidgetPARENT);
+ break;
+ }
+
+ case FormBorderStyle.FixedSingle: {
+ cp.Style |= (int)(WindowStyles.WS_CAPTION | WindowStyles.WS_BORDER);
+ break;
+ }
+
+ case FormBorderStyle.FixedToolWindow: {
+ cp.Style |= (int)(WindowStyles.WS_CAPTION | WindowStyles.WS_BORDER);
+ cp.ExStyle |= (int)(WindowExStyles.WS_EX_TOOLWINDOW);
+ break;
+ }
+
+ case FormBorderStyle.Sizable: {
+ cp.Style |= (int)(WindowStyles.WS_BORDER | WindowStyles.WS_THICKFRAME | WindowStyles.WS_CAPTION);
+ break;
+ }
+
+ case FormBorderStyle.SizableToolWindow: {
+ cp.Style |= (int)(WindowStyles.WS_BORDER | WindowStyles.WS_THICKFRAME | WindowStyles.WS_CAPTION);
+ cp.ExStyle |= (int)(WindowExStyles.WS_EX_TOOLWINDOW);
+ break;
+ }
+
+ case FormBorderStyle.None: {
+ break;
+ }
+ }
+ }
+
+ switch(window_state) {
+ case FormWindowState.Maximized: {
+ cp.Style |= (int)WindowStyles.WS_MAXIMIZE;
+ break;
+ }
+
+ case FormWindowState.Minimized: {
+ cp.Style |= (int)WindowStyles.WS_MINIMIZE;
+ break;
+ }
+ }
+
+ if (TopMost) {
+ cp.ExStyle |= (int) WindowExStyles.WS_EX_TOPMOST;
+ }
+
+ if (ShowInTaskbar) {
+ cp.ExStyle |= (int)WindowExStyles.WS_EX_APPWINDOW;
+ }
+
+ if (MaximizeBox) {
+ cp.Style |= (int)WindowStyles.WS_MAXIMIZEBOX;
+ }
+
+ if (MinimizeBox) {
+ cp.Style |= (int)WindowStyles.WS_MINIMIZEBOX;
+ }
+
+ if (WidgetBox) {
+ cp.Style |= (int)WindowStyles.WS_SYSMENU;
+ }
+
+ if (!this.show_icon) {
+ cp.ExStyle |= (int)WindowExStyles.WS_EX_DLGMODALFRAME;
+ }
+
+ cp.ExStyle |= (int)WindowExStyles.WS_EX_WidgetPARENT;
+
+ if (HelpButton && !MaximizeBox && !MinimizeBox) {
+ cp.ExStyle |= (int)WindowExStyles.WS_EX_CONTEXTHELP;
+ }
+
+ // bug 80775:
+ //don't set WS_VISIBLE if we're changing visibility. We can't create forms visible,
+ //since we have to set the owner before making the form visible
+ //(otherwise Win32 will do strange things with task bar icons).
+ //The problem is that we set the internal is_visible to true before creating the Widget,
+ //so is_changing_visible_state is the only way of determining if we're
+ //in the process of creating the form due to setting Visible=true.
+ //This works because SetVisibleCore explicitly makes the form visibile afterwards anyways.
+ // bug 81957:
+ //only do this when on Windows, since X behaves weirdly otherwise
+ //modal windows appear below their parent/owner/ancestor.
+ //(confirmed on several window managers, so it's not a wm bug).
+ int p = (int) Environment.OSVersion.Platform;
+ bool is_unix = (p == 128) || (p == 4) || (p == 6);
+ if ((VisibleInternal && (is_changing_visible_state == 0 || is_unix)) || this.IsRecreating)
+ cp.Style |= (int)WindowStyles.WS_VISIBLE;
+
+ if (opacity < 1.0 || TransparencyKey != Color.Empty) {
+ cp.ExStyle |= (int)WindowExStyles.WS_EX_LAYERED;
+ }
+
+ if (!is_enabled && context == null) {
+ cp.Style |= (int)(WindowStyles.WS_DISABLED);
+ }
+
+ if (!WidgetBox && Text == string.Empty) {
+ cp.WindowStyle &= ~WindowStyles.WS_DLGFRAME;
+ }
+
+ return cp;
+ }
+ }
+
+ protected override ImeMode DefaultImeMode {
+ get {
+ return ImeMode.NoControl;
+ }
+ }
+
+ protected override Size DefaultSize {
+ get {
+ return new Size (300, 300);
+ }
+ }
+
+ protected Rectangle MaximizedBounds {
+ get {
+ if (maximized_bounds != Rectangle.Empty) {
+ return maximized_bounds;
+ }
+ return default_maximized_bounds;
+ }
+
+ set {
+ maximized_bounds = value;
+ OnMaximizedBoundsChanged(EventArgs.Empty);
+ if (IsHandleCreated) {
+ XplatUI.SetWindowMinMax(Handle, maximized_bounds, minimum_size, maximum_size);
+ }
+ }
+ }
+
+ [Browsable (false)]
+ [MonoTODO ("Implemented for Win32, needs X11 implementation")]
+ protected virtual bool ShowWithoutActivation {
+ get { return false; }
+ }
+ #endregion // Protected Instance Properties
+
+ #region Public Static Methods
+ //[EditorBrowsable(EditorBrowsableState.Never)]
+ [Obsolete ("This method has been deprecated. Use AutoScaleDimensions instead")]
+ public static SizeF GetAutoScaleSize (Font font)
+ {
+ return XplatUI.GetAutoScaleSize(font);
+ }
+
+ #endregion // Public Static Methods
+
+ #region Public Instance Methods
+
+ public void ResetSkin()
+ {
+ if (Application.CurrentSkin == null)
+ Application.LoadSkin(new ShiftOS.DefaultSkin());
+ bool show_borders = (FormBorderStyle == FormBorderStyle.Fixed3D) || (FormBorderStyle == FormBorderStyle.FixedSingle) || (FormBorderStyle == FormBorderStyle.Sizable);
+ bool body_3d = (FormBorderStyle == FormBorderStyle.Fixed3D);
+ bool show_titlebar = (FormBorderStyle != FormBorderStyle.None);
+
+ border_left.Width = Application.CurrentSkin.borderwidth;
+ border_right.Width = Application.CurrentSkin.borderwidth;
+ border_bottom.Height = Application.CurrentSkin.borderwidth;
+ border_left.BackColor = Application.CurrentSkin.borderleftcolour;
+ border_right.BackColor = Application.CurrentSkin.borderrightcolour;
+ border_bottom.BackColor = Application.CurrentSkin.borderbottomcolour;
+ border_left.Visible = show_borders;
+ border_bottom.Visible = show_borders;
+ border_right.Visible = show_borders;
+ titlebar.Visible = show_titlebar;
+ if(body_3d == true)
+ {
+ body.BorderStyle = ShiftUI.BorderStyle.Fixed3D;
+ }
+else
+ {
+ body.BorderStyle = ShiftUI.BorderStyle.FixedSingle;
+ }
+
+ title_text.AutoSize = true;
+ title_text.Text = this.Text;
+ title_text.ForeColor = Application.CurrentSkin.titletextcolour;
+ title_text.Font = new Font(Application.CurrentSkin.titletextfontfamily,
+ Application.CurrentSkin.titletextfontsize,
+ Application.CurrentSkin.titletextfontstyle);
+ if (Application.CurrentSkin.titletextpos == "Left")
+ title_text.Left = Application.CurrentSkin.titletextfromside;
+ else
+ title_text.Left = (titlebar.Width - title_text.Width) / 2;
+ title_text.Top = Application.CurrentSkin.titletextfromtop;
+
+ titlebar.BackColor = Application.CurrentSkin.titlebarcolour;
+
+ titlebar_left.Width = Application.CurrentSkin.titlebarcornerwidth;
+ titlebar_right.Width = Application.CurrentSkin.titlebarcornerwidth;
+ titlebar_left.BackColor = Application.CurrentSkin.leftcornercolour;
+ titlebar_right.BackColor = Application.CurrentSkin.rightcornercolour;
+
+ close_button.Size = Application.CurrentSkin.closebtnsize;
+ close_button.Location = new Point(titlebar.Width - close_button.Width - Application.CurrentSkin.closebtnfromside,
+ titlebar.Height - close_button.Height - Application.CurrentSkin.closebtnfromtop);
+ close_button.BackColor = Application.CurrentSkin.closebtncolour;
+ titlebar.Height = Application.CurrentSkin.titlebarheight;
+ close_button.BringToFront();
+
+ minimize_button.Size = Application.CurrentSkin.minbtnsize;
+ minimize_button.Location = new Point(titlebar.Width - minimize_button.Width - Application.CurrentSkin.minbtnfromside,
+ titlebar.Height - minimize_button.Height - Application.CurrentSkin.minbtnfromtop);
+ minimize_button.BackColor = Application.CurrentSkin.minbtncolour;
+ minimize_button.BringToFront();
+
+ maximize_button.Size = Application.CurrentSkin.rollbtnsize;
+ maximize_button.Location = new Point(titlebar.Width - maximize_button.Width - Application.CurrentSkin.rollbtnfromside,
+ titlebar.Height - maximize_button.Height - Application.CurrentSkin.rollbtnfromtop);
+ maximize_button.BackColor = Application.CurrentSkin.rollbtncolour;
+ maximize_button.BringToFront();
+
+ }
+
+ public void Activate ()
+ {
+ if (IsHandleCreated) {
+ if (IsMdiChild) {
+ MdiParent.ActivateMdiChild (this);
+ } else if (IsMdiContainer) {
+ mdi_container.SendFocusToActiveChild ();
+ } else {
+ XplatUI.Activate(window.Handle);
+ }
+ }
+ }
+
+ public void AddOwnedForm(Form ownedForm) {
+ if (!owned_forms.Contains(ownedForm)) {
+ owned_forms.Add(ownedForm);
+ }
+ ownedForm.Owner = this;
+ }
+
+ public void Close () {
+ if (IsDisposed)
+ return;
+
+ if (!IsHandleCreated) {
+ base.Dispose ();
+ return;
+ }
+
+ if (Menu != null)
+ XplatUI.SetMenu (window.Handle, null);
+
+ XplatUI.SendMessage(this.Handle, Msg.WM_CLOSE, IntPtr.Zero, IntPtr.Zero);
+
+ closed = true;
+ }
+
+ public void LayoutMdi(MdiLayout value) {
+ if (mdi_container != null) {
+ mdi_container.LayoutMdi(value);
+ }
+ }
+
+ public void RemoveOwnedForm(Form ownedForm) {
+ owned_forms.Remove(ownedForm);
+ }
+
+ public void SetDesktopBounds(int x, int y, int width, int height) {
+ DesktopBounds = new Rectangle(x, y, width, height);
+ }
+
+ public void SetDesktopLocation(int x, int y) {
+ DesktopLocation = new Point(x, y);
+ }
+
+ public void Show (IWin32Window owner)
+ {
+ if (owner == null)
+ this.Owner = null;
+ else
+ this.Owner = Widget.FromHandle (owner.Handle).TopLevelWidget as Form;
+
+ if (owner == this)
+ throw new InvalidOperationException ("The 'owner' cannot be the form being shown.");
+
+ if (TopLevelWidget != this) {
+ throw new InvalidOperationException ("Forms that are not top level"
+ + " forms cannot be displayed as a modal dialog. Remove the"
+ + " form from any parent form before calling Show.");
+ }
+
+ base.Show ();
+ }
+
+ public DialogResult ShowDialog() {
+ return ShowDialog (null);
+ }
+
+ public DialogResult ShowDialog(IWin32Window owner) {
+ Rectangle area;
+ bool confined;
+ IntPtr capture_window;
+
+ IWin32Window original_owner = owner;
+ Form owner_to_be = null;
+
+ if ((owner == null) && (Application.MWFThread.Current.Context != null)) {
+ IntPtr active = XplatUI.GetActive ();
+ if (active != IntPtr.Zero) {
+ owner = Widget.FromHandle (active) as Form;
+ }
+ }
+
+ if (owner != null) {
+ Widget c = Widget.FromHandle (owner.Handle);
+ if (c != null)
+ owner_to_be = c.TopLevelWidget as Form;
+ }
+
+ if (owner_to_be == this) {
+ // Don't let a null owner become self-referential. This has been observed,
+ // but the circumstances are unclear.
+ if (original_owner == null) {
+ owner = null;
+ owner_to_be = null;
+ }
+ else {
+ throw new ArgumentException ("Forms cannot own themselves or their owners.", "owner");
+ }
+ }
+
+ if (is_modal) {
+ throw new InvalidOperationException ("The form is already displayed as a modal dialog.");
+ }
+
+ if (Visible) {
+ throw new InvalidOperationException ("Forms that are already "
+ + " visible cannot be displayed as a modal dialog. Set the"
+ + " form's visible property to false before calling"
+ + " ShowDialog.");
+ }
+
+ if (!Enabled) {
+ throw new InvalidOperationException ("Forms that are not enabled"
+ + " cannot be displayed as a modal dialog. Set the form's"
+ + " enabled property to true before calling ShowDialog.");
+ }
+
+ if (TopLevelWidget != this) {
+ throw new InvalidOperationException ("Forms that are not top level"
+ + " forms cannot be displayed as a modal dialog. Remove the"
+ + " form from any parent form before calling ShowDialog.");
+ }
+
+ if (owner_to_be != null)
+ this.owner = owner_to_be;
+
+ // If our owner is topmost, we better be too, or else we'll show up under our owner
+ if (this.owner != null && this.owner.TopMost)
+ this.TopMost = true;
+
+ #if broken
+ // Can't do this, will screw us in the modal loop
+ form_parent_window.Parent = this.owner;
+ #endif
+
+ // Release any captures
+ XplatUI.GrabInfo(out capture_window, out confined, out area);
+ if (capture_window != IntPtr.Zero) {
+ XplatUI.UngrabWindow(capture_window);
+ }
+
+ var disable = new List<Form> ();
+ foreach (Form form in Application.OpenForms)
+ if (form.Enabled)
+ disable.Add (form);
+ foreach (Form form in disable){
+ disabled_by_showdialog.Add (form);
+ form.Enabled = false;
+ }
+ modal_dialogs.Add(this);
+
+#if not
+ // Commented out; we instead let the Visible=true inside the runloop create the Widget
+ // otherwise setting DialogResult inside any of the events that are triggered by the
+ // create will not actually cause the form to not be displayed.
+ // Leaving this comment here in case there was an actual purpose to creating the Widget
+ // in here.
+ if (!IsHandleCreated) {
+ CreateWidget();
+ }
+#endif
+
+ Application.RunLoop(true, new ApplicationContext(this));
+
+ if (this.owner != null) {
+ // Cannot use Activate(), it has a check for the current active window...
+ XplatUI.Activate(this.owner.window.Handle);
+ }
+
+ if (IsHandleCreated) {
+ DestroyHandle ();
+ }
+
+ if (DialogResult == DialogResult.None) {
+ DialogResult = DialogResult.Cancel;
+ }
+
+ return DialogResult;
+ }
+
+ public override string ToString() {
+ return GetType().FullName + ", Text: " + Text;
+ }
+
+ [Browsable (true)]
+ //[EditorBrowsable (EditorBrowsableState.Always)]
+ public override bool ValidateChildren ()
+ {
+ return base.ValidateChildren ();
+ }
+
+ [Browsable (true)]
+ //[EditorBrowsable (EditorBrowsableState.Always)]
+ public override bool ValidateChildren (ValidationConstraints validationConstraints)
+ {
+ return base.ValidateChildren (validationConstraints);
+ }
+ #endregion // Public Instance Methods
+
+ #region Protected Instance Methods
+ protected void ActivateMdiChild(Form form) {
+ if (!IsMdiContainer)
+ return;
+ mdi_container.ActivateChild (form);
+ OnMdiChildActivate(EventArgs.Empty);
+ }
+
+ //[EditorBrowsable(EditorBrowsableState.Advanced)]
+ protected override void AdjustFormScrollbars(bool displayScrollbars) {
+ base.AdjustFormScrollbars (displayScrollbars);
+ }
+
+ //[EditorBrowsable(EditorBrowsableState.Never)]
+ [Obsolete ("This method has been deprecated")] // XXX what to use instead?
+ protected void ApplyAutoScaling()
+ {
+ SizeF current_size_f = GetAutoScaleSize (Font);
+ Size current_size = new Size ((int)Math.Round (current_size_f.Width), (int)Math.Round (current_size_f.Height));
+ float dx;
+ float dy;
+
+ if (current_size == autoscale_base_size)
+ return;
+
+ if (Environment.GetEnvironmentVariable ("MONO_MWF_SCALING") == "disable"){
+ return;
+ }
+
+ //
+ // I tried applying the Fudge height factor from:
+ // http://blogs.msdn.com/mharsh/archive/2004/01/25/62621.aspx
+ // but it makes things larger without looking better.
+ //
+ if (current_size.Width != AutoScaleBaseSize.Width) {
+ dx = (float)current_size.Width / AutoScaleBaseSize.Width + 0.08f;
+ } else {
+ dx = 1;
+ }
+
+ if (current_size.Height != AutoScaleBaseSize.Height) {
+ dy = (float)current_size.Height / AutoScaleBaseSize.Height + 0.08f;
+ } else {
+ dy = 1;
+ }
+
+ Scale (dx, dy);
+
+ AutoScaleBaseSize = current_size;
+ }
+
+ protected void CenterToParent() {
+ Widget ctl;
+ int w;
+ int h;
+
+ // MS creates the handle here.
+ if (TopLevel) {
+ if (!IsHandleCreated)
+ CreateHandle ();
+ }
+
+ if (Width > 0) {
+ w = Width;
+ } else {
+ w = DefaultSize.Width;
+ }
+
+ if (Height > 0) {
+ h = Height;
+ } else {
+ h = DefaultSize.Height;
+ }
+
+ ctl = null;
+ if (Parent != null) {
+ ctl = Parent;
+ } else if (owner != null) {
+ ctl = owner;
+ }
+
+ if (owner != null) {
+ this.Location = new Point(ctl.Left + ctl.Width / 2 - w /2, ctl.Top + ctl.Height / 2 - h / 2);
+ }
+ }
+
+ protected void CenterToScreen() {
+ int w;
+ int h;
+
+ // MS creates the handle here.
+ if (TopLevel) {
+ if (!IsHandleCreated)
+ CreateHandle ();
+ }
+
+ if (Width > 0) {
+ w = Width;
+ } else {
+ w = DefaultSize.Width;
+ }
+
+ if (Height > 0) {
+ h = Height;
+ } else {
+ h = DefaultSize.Height;
+ }
+
+ Rectangle workingArea;
+ if (Owner == null) {
+ workingArea = Screen.FromPoint (MousePosition).WorkingArea;
+ } else {
+ workingArea = Screen.FromControl (Owner).WorkingArea;
+ }
+ this.Location = new Point (workingArea.Left + workingArea.Width / 2 - w / 2,
+ workingArea.Top + workingArea.Height / 2 - h / 2);
+ }
+
+ //[EditorBrowsable(EditorBrowsableState.Advanced)]
+ protected override Widget.WidgetCollection CreateWidgetsInstance() {
+ return base.CreateWidgetsInstance ();
+ }
+
+ //[EditorBrowsable(EditorBrowsableState.Advanced)]
+ protected override void CreateHandle() {
+ base.CreateHandle ();
+
+ if (!IsHandleCreated) {
+ return;
+ }
+
+ UpdateBounds();
+
+ if ((XplatUI.SupportsTransparency() & TransparencySupport.Set) != 0) {
+ if (allow_transparency) {
+ XplatUI.SetWindowTransparency(Handle, opacity, TransparencyKey);
+ }
+ }
+
+ XplatUI.SetWindowMinMax(window.Handle, maximized_bounds, minimum_size, maximum_size);
+
+ if (show_icon && (FormBorderStyle != FormBorderStyle.FixedDialog) && (icon != null)) {
+ XplatUI.SetIcon(window.Handle, icon);
+ }
+
+ if ((owner != null) && (owner.IsHandleCreated)) {
+ XplatUI.SetOwner(window.Handle, owner.window.Handle);
+ }
+
+ if (topmost) {
+ XplatUI.SetTopmost(window.Handle, topmost);
+ }
+
+ for (int i = 0; i < owned_forms.Count; i++) {
+ if (owned_forms[i].IsHandleCreated)
+ XplatUI.SetOwner(owned_forms[i].window.Handle, window.Handle);
+ }
+
+ if (window_manager != null) {
+ if (IsMdiChild && VisibleInternal) {
+ MdiWindowManager wm;
+ // Loop through all the other mdi siblings and raise Deactivate events.
+ if (MdiParent != null) {
+ foreach (Form form in MdiParent.MdiChildren) {
+ wm = form.window_manager as MdiWindowManager;
+ if (wm != null && form != this) {
+ // This will only raise deactivate once, and only if activate has
+ // already been raised.
+ wm.RaiseDeactivate ();
+ }
+ }
+ }
+
+ wm = window_manager as MdiWindowManager;
+ wm.RaiseActivated ();
+
+ // We need to tell everyone who may have just been deactivated to redraw their titlebar
+ if (MdiParent != null)
+ foreach (Form form in MdiParent.MdiChildren)
+ if (form != this && form.IsHandleCreated)
+ XplatUI.InvalidateNC (form.Handle);
+ }
+
+ if (window_state != FormWindowState.Normal) {
+ window_manager.SetWindowState ((FormWindowState) int.MaxValue, window_state);
+ }
+ XplatUI.RequestNCRecalc (window.Handle);
+ }
+
+ }
+
+ //[EditorBrowsable(EditorBrowsableState.Advanced)]
+ protected override void DefWndProc(ref Message m) {
+ base.DefWndProc (ref m);
+ }
+
+ protected override void Dispose(bool disposing)
+ {
+ if (owned_forms != null) {
+ for (int i = 0; i < owned_forms.Count; i++)
+ ((Form)owned_forms[i]).Owner = null;
+
+ owned_forms.Clear ();
+ }
+ Owner = null;
+ base.Dispose (disposing);
+
+ Application.RemoveForm (this);
+ }
+
+ //[EditorBrowsable(EditorBrowsableState.Advanced)]
+ protected virtual void OnActivated(EventArgs e)
+ {
+ EventHandler eh = (EventHandler)(Events [ActivatedEvent]);
+ if (eh != null)
+ eh (this, e);
+ }
+
+ //[EditorBrowsable(EditorBrowsableState.Advanced)]
+ protected virtual void OnClosed(EventArgs e) {
+ EventHandler eh = (EventHandler)(Events [ClosedEvent]);
+ if (eh != null)
+ eh (this, e);
+ }
+
+ // Consider calling FireClosingEvents instead of calling this directly.
+ //[EditorBrowsable (EditorBrowsableState.Advanced)]
+ protected virtual void OnClosing(System.ComponentModel.CancelEventArgs e) {
+ CancelEventHandler eh = (CancelEventHandler)(Events [ClosingEvent]);
+ if (eh != null)
+ eh (this, e);
+ }
+
+ //[EditorBrowsable(EditorBrowsableState.Advanced)]
+ protected override void OnCreateWidget() {
+ base.OnCreateWidget ();
+
+ if (menu != null) {
+ XplatUI.SetMenu(window.Handle, menu);
+ }
+
+ OnLoadInternal (EventArgs.Empty);
+
+ // Send initial location
+ OnLocationChanged(EventArgs.Empty);
+ }
+
+ //[EditorBrowsable(EditorBrowsableState.Advanced)]
+ protected virtual void OnDeactivate(EventArgs e) {
+ EventHandler eh = (EventHandler)(Events [DeactivateEvent]);
+ if (eh != null)
+ eh (this, e);
+ }
+
+ //[EditorBrowsable(EditorBrowsableState.Advanced)]
+ protected override void OnFontChanged(EventArgs e) {
+ base.OnFontChanged (e);
+
+ if (!autoscale_base_size_set) {
+ SizeF sizef = Form.GetAutoScaleSize (Font);
+ autoscale_base_size = new Size ((int)Math.Round (sizef.Width), (int)Math.Round (sizef.Height));
+ }
+ }
+
+ //[EditorBrowsable(EditorBrowsableState.Advanced)]
+ protected override void OnHandleCreated(EventArgs e) {
+ XplatUI.SetBorderStyle(window.Handle, form_border_style);
+ base.OnHandleCreated (e);
+ }
+
+ //[EditorBrowsable(EditorBrowsableState.Advanced)]
+ protected override void OnHandleDestroyed(EventArgs e) {
+ Application.RemoveForm (this);
+ base.OnHandleDestroyed (e);
+ }
+
+ //[EditorBrowsable(EditorBrowsableState.Advanced)]
+ protected virtual void OnInputLanguageChanged(InputLanguageChangedEventArgs e) {
+ InputLanguageChangedEventHandler eh = (InputLanguageChangedEventHandler)(Events [InputLanguageChangedEvent]);
+ if (eh != null)
+ eh (this, e);
+ }
+
+ //[EditorBrowsable(EditorBrowsableState.Advanced)]
+ protected virtual void OnInputLanguageChanging(InputLanguageChangingEventArgs e) {
+ InputLanguageChangingEventHandler eh = (InputLanguageChangingEventHandler)(Events [InputLanguageChangingEvent]);
+ if (eh != null)
+ eh (this, e);
+ }
+
+ //[EditorBrowsable(EditorBrowsableState.Advanced)]
+ protected virtual void OnLoad (EventArgs e){
+ Application.AddForm (this);
+
+ EventHandler eh = (EventHandler)(Events[LoadEvent]);
+ if (eh != null)
+ eh (this, e);
+ }
+
+ //[EditorBrowsable(EditorBrowsableState.Advanced)]
+ protected virtual void OnMaximizedBoundsChanged(EventArgs e) {
+ EventHandler eh = (EventHandler)(Events [MaximizedBoundsChangedEvent]);
+ if (eh != null)
+ eh (this, e);
+ }
+
+ //[EditorBrowsable(EditorBrowsableState.Advanced)]
+ protected virtual void OnMaximumSizeChanged(EventArgs e) {
+ EventHandler eh = (EventHandler)(Events [MaximumSizeChangedEvent]);
+ if (eh != null)
+ eh (this, e);
+ }
+
+ //[EditorBrowsable(EditorBrowsableState.Advanced)]
+ protected virtual void OnMdiChildActivate(EventArgs e) {
+ EventHandler eh = (EventHandler)(Events [MdiChildActivateEvent]);
+ if (eh != null)
+ eh (this, e);
+ }
+
+ //[EditorBrowsable(EditorBrowsableState.Advanced)]
+ protected internal virtual void OnMenuComplete(EventArgs e) {
+ EventHandler eh = (EventHandler)(Events [MenuCompleteEvent]);
+ if (eh != null)
+ eh (this, e);
+ }
+
+ //[EditorBrowsable(EditorBrowsableState.Advanced)]
+ protected virtual void OnMenuStart(EventArgs e) {
+ EventHandler eh = (EventHandler)(Events [MenuStartEvent]);
+ if (eh != null)
+ eh (this, e);
+ }
+
+ //[EditorBrowsable(EditorBrowsableState.Advanced)]
+ protected virtual void OnMinimumSizeChanged(EventArgs e) {
+ EventHandler eh = (EventHandler)(Events [MinimumSizeChangedEvent]);
+ if (eh != null)
+ eh (this, e);
+ }
+
+ //[EditorBrowsable(EditorBrowsableState.Advanced)]
+ protected override void OnPaint (PaintEventArgs e) {
+ base.OnPaint (e);
+
+ if (size_grip != null) {
+ size_grip.HandlePaint (this, e);
+ }
+ }
+
+ //[EditorBrowsable(EditorBrowsableState.Advanced)]
+ protected override void OnResize(EventArgs e) {
+ base.OnResize(e);
+
+ }
+
+ //[EditorBrowsable(EditorBrowsableState.Advanced)]
+ protected override void OnStyleChanged(EventArgs e) {
+ base.OnStyleChanged (e);
+ }
+
+ //[EditorBrowsable(EditorBrowsableState.Advanced)]
+ protected override void OnTextChanged(EventArgs e) {
+ base.OnTextChanged (e);
+
+ if (mdi_container != null)
+ mdi_container.SetParentText(true);
+ }
+
+ //[EditorBrowsable(EditorBrowsableState.Advanced)]
+ protected override void OnVisibleChanged(EventArgs e) {
+ base.OnVisibleChanged (e);
+
+ if (Visible) {
+ if (window_manager != null)
+ if (WindowState == FormWindowState.Normal)
+ window_manager.SetWindowState (WindowState, WindowState);
+ else
+ // We don't really have an old_state, and if we pass the same thing,
+ // it may not really change the state for us
+ window_manager.SetWindowState ((FormWindowState)(-1), WindowState);
+ }
+ }
+
+ protected override bool ProcessCmdKey(ref Message msg, Keys keyData) {
+ if (base.ProcessCmdKey (ref msg, keyData)) {
+ return true;
+ }
+
+ // Handle keyboard cues state.
+ if ((keyData & Keys.Alt) != 0) {
+ Widget toplevel = TopLevelWidget;
+ if (toplevel != null) {
+ IntPtr param = MakeParam ((int) MsgUIState.UIS_CLEAR, (int) MsgUIState.UISF_HIDEACCEL);
+ XplatUI.SendMessage (toplevel.Handle, Msg.WM_CHANGEUISTATE, param, IntPtr.Zero);
+ }
+ }
+
+ // Give our menu a shot
+ if (ActiveMenu != null) {
+ if (ActiveMenu.ProcessCmdKey (ref msg, keyData))
+ return true;
+ }
+
+
+ if (IsMdiChild) {
+ switch (keyData)
+ {
+ case Keys.Widget | Keys.F4:
+ case Keys.Widget | Keys.Shift | Keys.F4:
+ Close ();
+ return true;
+ case Keys.Widget | Keys.Tab:
+ case Keys.Widget | Keys.F6:
+ MdiParent.MdiContainer.ActivateNextChild ();
+ return true;
+ case Keys.Widget | Keys.Shift | Keys.Tab:
+ case Keys.Widget | Keys.Shift | Keys.F6:
+ MdiParent.MdiContainer.ActivatePreviousChild ();
+ return true;
+ case Keys.Alt | Keys.OemMinus:
+ case Keys.Alt | Keys.Subtract:
+ (this.WindowManager as MdiWindowManager).ShowPopup (Point.Empty);
+ return true;
+ }
+ }
+
+ return false;
+ }
+
+ // LAMESPEC - Not documented that Form overrides ProcessDialogChar; class-status showed
+ //[EditorBrowsable (EditorBrowsableState.Advanced)]
+ protected override bool ProcessDialogChar(char charCode) {
+ return base.ProcessDialogChar (charCode);
+ }
+
+ protected override bool ProcessDialogKey(Keys keyData) {
+ if ((keyData & Keys.Modifiers) == 0) {
+ if (keyData == Keys.Enter) {
+ IntPtr window = XplatUI.GetFocus ();
+ Widget c = Widget.FromHandle (window);
+ if (c is Button && c.FindForm () == this) {
+ ((Button)c).PerformClick ();
+ return true;
+ }
+ else if (accept_button != null) {
+ // Set ActiveWidget to force any Validation to take place.
+ ActiveWidget = (accept_button as Widget);
+ if (ActiveWidget == accept_button) // else Validation failed
+ accept_button.PerformClick();
+ return true;
+ }
+ } else if (keyData == Keys.Escape && cancel_button != null) {
+ cancel_button.PerformClick();
+ return true;
+ }
+ }
+ return base.ProcessDialogKey(keyData);
+ }
+
+ protected override bool ProcessKeyPreview(ref Message m) {
+ if (key_preview) {
+ if (ProcessKeyEventArgs(ref m)) {
+ return true;
+ }
+ }
+ return base.ProcessKeyPreview (ref m);
+ }
+
+ protected override bool ProcessTabKey(bool forward) {
+ bool need_refresh = !show_focus_cues;
+ show_focus_cues = true;
+
+ bool Widget_activated = SelectNextWidget(ActiveWidget, forward, true, true, true);
+
+ if (need_refresh && ActiveWidget != null)
+ ActiveWidget.Invalidate ();
+
+ return Widget_activated;
+ }
+
+ //[EditorBrowsable (EditorBrowsableState.Never)]
+ protected override void ScaleCore (float x, float y)
+ {
+ base.ScaleCore (x, y);
+ }
+
+ protected override void Select(bool directed, bool forward) {
+ Form parent;
+
+
+ // MS causes the handle to be created here.
+ if (!IsHandleCreated)
+ if (!IsHandleCreated)
+ CreateHandle ();
+
+ if (directed) {
+ base.SelectNextWidget(null, forward, true, true, true);
+ }
+
+ parent = this.ParentForm;
+ if (parent != null) {
+ parent.ActiveWidget = this;
+ }
+
+ Activate();
+ }
+
+ //[EditorBrowsable(EditorBrowsableState.Advanced)]
+ protected override void SetBoundsCore(int x, int y, int width, int height, BoundsSpecified specified) {
+ Size min_size;
+
+ if (WindowState == FormWindowState.Minimized)
+ min_size = SystemInformation.MinimizedWindowSize;
+ else
+ switch (FormBorderStyle) {
+ case FormBorderStyle.None:
+ min_size = XplatUI.MinimumNoBorderWindowSize;
+ break;
+ case FormBorderStyle.FixedToolWindow:
+ min_size = XplatUI.MinimumFixedToolWindowSize;
+ break;
+ case FormBorderStyle.SizableToolWindow:
+ min_size = XplatUI.MinimumSizeableToolWindowSize;
+ break;
+ default:
+ min_size = SystemInformation.MinimumWindowSize;
+ break;
+ }
+
+ if ((specified & BoundsSpecified.Width) == BoundsSpecified.Width)
+ width = Math.Max (width, min_size.Width);
+ if ((specified & BoundsSpecified.Height) == BoundsSpecified.Height)
+ height = Math.Max (height, min_size.Height);
+
+ base.SetBoundsCore (x, y, width, height, specified);
+
+ int restore_x = (specified & BoundsSpecified.X) == BoundsSpecified.X ? x : restore_bounds.X;
+ int restore_y = (specified & BoundsSpecified.Y) == BoundsSpecified.Y ? y : restore_bounds.Y;
+ int restore_w = (specified & BoundsSpecified.Width) == BoundsSpecified.Width ? width : restore_bounds.Width;
+ int restore_h = (specified & BoundsSpecified.Height) == BoundsSpecified.Height ? height : restore_bounds.Height;
+ restore_bounds = new Rectangle (restore_x, restore_y, restore_w, restore_h);
+ }
+
+ //[EditorBrowsable(EditorBrowsableState.Advanced)]
+ protected override void SetClientSizeCore(int x, int y) {
+ if ((minimum_size.Width != 0) && (x < minimum_size.Width)) {
+ x = minimum_size.Width;
+ } else if ((maximum_size.Width != 0) && (x > maximum_size.Width)) {
+ x = maximum_size.Width;
+ }
+
+ if ((minimum_size.Height != 0) && (y < minimum_size.Height)) {
+ y = minimum_size.Height;
+ } else if ((maximum_size.Height != 0) && (y > maximum_size.Height)) {
+ y = maximum_size.Height;
+ }
+
+ Rectangle ClientRect = new Rectangle(0, 0, x, y);
+ Rectangle WindowRect;
+ CreateParams cp = this.CreateParams;
+
+ clientsize_set = new Size(x, y);
+
+ if (XplatUI.CalculateWindowRect(ref ClientRect, cp, cp.menu, out WindowRect)) {
+ SetBounds(bounds.X, bounds.Y, WindowRect.Width, WindowRect.Height, BoundsSpecified.Size);
+ }
+ }
+
+ //[EditorBrowsable(EditorBrowsableState.Advanced)]
+ protected override void SetVisibleCore(bool value)
+ {
+ if (value)
+ close_raised = false;
+
+ if (IsMdiChild && !MdiParent.Visible) {
+ if (value != Visible) {
+ MdiWindowManager wm = (MdiWindowManager) window_manager;
+ wm.IsVisiblePending = value;
+ OnVisibleChanged (EventArgs.Empty);
+ return;
+ }
+ } else {
+ is_changing_visible_state++;
+ has_been_visible = value || has_been_visible;
+ base.SetVisibleCore (value);
+ if (value) {
+ Application.AddForm (this);
+ }
+
+ if (value && WindowState != FormWindowState.Normal)
+ XplatUI.SendMessage (Handle, Msg.WM_SHOWWINDOW, (IntPtr)1, IntPtr.Zero);
+
+ is_changing_visible_state--;
+ }
+
+ if (value && IsMdiContainer) {
+ Form [] children = MdiChildren;
+ for (int i = 0; i < children.Length; i++) {
+ Form child = children [i];
+ MdiWindowManager wm = (MdiWindowManager) child.window_manager;
+ if (!child.IsHandleCreated && wm.IsVisiblePending) {
+ wm.IsVisiblePending = false;
+ child.Visible = true;
+ }
+ }
+ }
+
+ if (value && IsMdiChild){
+ PerformLayout ();
+ ThemeEngine.Current.ManagedWindowSetButtonLocations (window_manager);
+ }
+
+ // Shown event is only called once, the first time the form is made visible
+ if (value && !shown_raised) {
+ this.OnShown (EventArgs.Empty);
+ shown_raised = true;
+ }
+
+ if (value && !IsMdiChild) {
+ if (ActiveWidget == null)
+ SelectNextWidget (null, true, true, true, false);
+ if (ActiveWidget != null)
+ SendWidgetFocus (ActiveWidget);
+ else
+ this.Focus ();
+ }
+ }
+
+ protected override void UpdateDefaultButton() {
+ base.UpdateDefaultButton ();
+ }
+
+ //[EditorBrowsable(EditorBrowsableState.Advanced)]
+ protected override void WndProc(ref Message m) {
+#if debug
+ Console.WriteLine(DateTime.Now.ToLongTimeString () + " Form {0} ({2}) received message {1}", window.Handle == IntPtr.Zero ? this.Text : XplatUI.Window(window.Handle), m.ToString (), Text);
+#endif
+
+ if (window_manager != null && window_manager.WndProc (ref m)) {
+ return;
+ }
+
+ switch ((Msg)m.Msg) {
+ case Msg.WM_DESTROY: {
+ WmDestroy (ref m);
+ return;
+ }
+
+ case Msg.WM_CLOSE: {
+ WmClose (ref m);
+ return;
+ }
+
+ case Msg.WM_WINDOWPOSCHANGED: {
+ WmWindowPosChanged (ref m);
+ return;
+ }
+
+ case Msg.WM_SYSCOMMAND: {
+ WmSysCommand (ref m);
+ break;
+ }
+
+ case Msg.WM_ACTIVATE: {
+ WmActivate (ref m);
+ return;
+ }
+
+ case Msg.WM_KILLFOCUS: {
+ WmKillFocus (ref m);
+ return;
+ }
+
+ case Msg.WM_SETFOCUS: {
+ WmSetFocus (ref m);
+ return;
+ }
+
+ // Menu drawing
+ case Msg.WM_NCHITTEST: {
+ WmNcHitTest (ref m);
+ return;
+ }
+
+ case Msg.WM_NCLBUTTONDOWN: {
+ WmNcLButtonDown (ref m);
+ return;
+ }
+
+ case Msg.WM_NCLBUTTONUP: {
+ WmNcLButtonUp (ref m);
+ return;
+ }
+
+ case Msg.WM_NCMOUSELEAVE: {
+ WmNcMouseLeave (ref m);
+ return;
+ }
+
+ case Msg.WM_NCMOUSEMOVE: {
+ WmNcMouseMove (ref m);
+ return;
+ }
+
+ case Msg.WM_NCPAINT: {
+ WmNcPaint (ref m);
+ return;
+ }
+
+ case Msg.WM_NCCALCSIZE: {
+ WmNcCalcSize (ref m);
+ break;
+ }
+
+ case Msg.WM_GETMINMAXINFO: {
+ WmGetMinMaxInfo (ref m);
+ break;
+ }
+
+ case Msg.WM_ENTERSIZEMOVE: {
+ OnResizeBegin (EventArgs.Empty);
+ break;
+ }
+
+ case Msg.WM_EXITSIZEMOVE: {
+ OnResizeEnd (EventArgs.Empty);
+ break;
+ }
+
+ default: {
+ base.WndProc (ref m);
+ break;
+ }
+ }
+ }
+ #endregion // Protected Instance Methods
+
+#region WM methods
+
+ private void WmDestroy (ref Message m)
+ {
+ if (!RecreatingHandle)
+ this.closing = true;
+
+ base.WndProc (ref m);
+ }
+
+ internal bool RaiseCloseEvents (bool last_check, bool cancel)
+ {
+ if (last_check && Visible) {
+ Hide ();
+ }
+
+ if (close_raised || (last_check && closed)) {
+ return false;
+ }
+
+ close_raised = true;
+ bool cancelled = FireClosingEvents (CloseReason.UserClosing, cancel);
+ if (!cancelled) {
+ if (!last_check || DialogResult != DialogResult.None) {
+ if (mdi_container != null)
+ foreach (Form mdi_child in mdi_container.MdiChildren)
+ mdi_child.FireClosedEvents (CloseReason.UserClosing);
+
+ FireClosedEvents (CloseReason.UserClosing);
+ }
+ closing = true;
+ shown_raised = false;
+ } else {
+ DialogResult = DialogResult.None;
+ closing = false;
+ close_raised = false;
+ }
+
+ return cancelled;
+ }
+
+ private void WmClose (ref Message m)
+ {
+ if (this.Enabled == false)
+ return; // prevent closing a disabled form.
+
+ Form act = Form.ActiveForm;
+ // Don't close this form if there's another modal form visible.
+ if (act != null && act != this && act.Modal == true) {
+ // Check if any of the parents up the tree is the modal form,
+ // in which case we can still close this form.
+ Widget current = this;
+ while (current != null && current.Parent != act) {
+ current = current.Parent;
+ }
+ if (current == null || current.Parent != act) {
+ return;
+ }
+ }
+
+ bool mdi_cancel = false;
+
+ // Give any MDI children the opportunity to cancel the close
+ if (mdi_container != null)
+ foreach (Form mdi_child in mdi_container.MdiChildren)
+ mdi_cancel = mdi_child.FireClosingEvents (CloseReason.MdiFormClosing, mdi_cancel);
+
+ bool validate_cancel = false;
+ if (!suppress_closing_events)
+ validate_cancel = !ValidateChildren ();
+
+ if (suppress_closing_events ||
+ !RaiseCloseEvents (false, validate_cancel || mdi_cancel)) {
+ if (is_modal) {
+ Hide ();
+ } else {
+ Dispose ();
+ if (act != null && act != this)
+ act.SelectActiveWidget ();
+ }
+ mdi_parent = null;
+ } else {
+ if (is_modal) {
+ DialogResult = DialogResult.None;
+ }
+ closing = false;
+ }
+ }
+
+ private void WmWindowPosChanged (ref Message m)
+ {
+ // When a form is minimized/restored:
+ // * Win32: X and Y are set to negative values/restored,
+ // size remains the same.
+ // * X11: Location and Size remain the same.
+ //
+ // In both cases we have to fire Resize explicitly here,
+ // because of the unmodified Size due to which Widget
+ // doesn't fire it.
+ //
+ if (window_state != FormWindowState.Minimized && WindowState != FormWindowState.Minimized)
+ base.WndProc (ref m);
+ else { // minimized or restored
+ if (!is_minimizing) {
+ // Avoid recursive calls here as code in OnSizeChanged might
+ // cause a WM_WINDOWPOSCHANGED to be sent.
+ is_minimizing = true;
+ OnSizeChanged (EventArgs.Empty);
+ is_minimizing = false;
+ }
+ }
+
+ if (WindowState == FormWindowState.Normal)
+ restore_bounds = Bounds;
+ }
+
+ private void WmSysCommand (ref Message m)
+ {
+ // Let *Strips know the app's title bar was clicked
+ if (XplatUI.IsEnabled (Handle))
+ ToolStripManager.FireAppClicked ();
+
+ base.WndProc (ref m);
+ }
+
+ private void WmActivate (ref Message m)
+ {
+ if (!this.Enabled && modal_dialogs.Count > 0)
+ {
+ (modal_dialogs[modal_dialogs.Count -1] as Form).Activate ();
+ return; // prevent Activating of disabled form.
+ }
+
+ if (m.WParam != (IntPtr)WindowActiveFlags.WA_INACTIVE) {
+ if (is_loaded) {
+ SelectActiveWidget ();
+
+ if (ActiveWidget != null && !ActiveWidget.Focused)
+ SendWidgetFocus (ActiveWidget);
+ }
+
+ IsActive = true;
+ } else {
+ if (XplatUI.IsEnabled (Handle) && XplatUI.GetParent (m.LParam) != Handle)
+ ToolStripManager.FireAppFocusChanged (this);
+ IsActive = false;
+ }
+ }
+
+ private void WmKillFocus (ref Message m)
+ {
+ base.WndProc (ref m);
+ }
+
+ private void WmSetFocus (ref Message m)
+ {
+ if (ActiveWidget != null && ActiveWidget != this) {
+ ActiveWidget.Focus ();
+ return; // FIXME - do we need to run base.WndProc, even though we just changed focus?
+ }
+ if (IsMdiContainer) {
+ mdi_container.SendFocusToActiveChild ();
+ return;
+ }
+ base.WndProc (ref m);
+ }
+
+ private void WmNcHitTest (ref Message m)
+ {
+ if (XplatUI.IsEnabled (Handle) && ActiveMenu != null) {
+ int x = LowOrder ((int)m.LParam.ToInt32 ());
+ int y = HighOrder ((int)m.LParam.ToInt32 ());
+
+ XplatUI.ScreenToMenu (ActiveMenu.Wnd.window.Handle, ref x, ref y);
+
+ // If point is under menu return HTMENU, it prevents Win32 to return HTMOVE.
+ if ((x > 0) && (y > 0) && (x < ActiveMenu.Rect.Width) && (y < ActiveMenu.Rect.Height)) {
+ m.Result = new IntPtr ((int)HitTest.HTMENU);
+ return;
+ }
+ }
+
+ base.WndProc (ref m);
+ }
+
+ private void WmNcLButtonDown (ref Message m)
+ {
+ if (XplatUI.IsEnabled (Handle) && ActiveMenu != null) {
+ ActiveMenu.OnMouseDown (this, new MouseEventArgs (FromParamToMouseButtons ((int)m.WParam.ToInt32 ()), mouse_clicks, Widget.MousePosition.X, Widget.MousePosition.Y, 0));
+ }
+
+ if (ActiveMaximizedMdiChild != null && ActiveMenu != null) {
+ if (ActiveMaximizedMdiChild.HandleMenuMouseDown (ActiveMenu,
+ LowOrder ((int)m.LParam.ToInt32 ()),
+ HighOrder ((int)m.LParam.ToInt32 ()))) {
+ // Don't let base process this message, otherwise we won't
+ // get a WM_NCLBUTTONUP.
+ return;
+ }
+ }
+ base.WndProc (ref m);
+ }
+
+ private void WmNcLButtonUp (ref Message m)
+ {
+ if (ActiveMaximizedMdiChild != null && ActiveMenu != null) {
+ ActiveMaximizedMdiChild.HandleMenuMouseUp (ActiveMenu,
+ LowOrder ((int)m.LParam.ToInt32 ()),
+ HighOrder ((int)m.LParam.ToInt32 ()));
+ }
+ base.WndProc (ref m);
+ }
+
+ private void WmNcMouseLeave (ref Message m)
+ {
+ if (ActiveMaximizedMdiChild != null && ActiveMenu != null) {
+ ActiveMaximizedMdiChild.HandleMenuMouseLeave (ActiveMenu,
+ LowOrder ((int)m.LParam.ToInt32 ()),
+ HighOrder ((int)m.LParam.ToInt32 ()));
+ }
+ base.WndProc (ref m);
+ }
+
+ private void WmNcMouseMove (ref Message m)
+ {
+ if (XplatUI.IsEnabled (Handle) && ActiveMenu != null) {
+ ActiveMenu.OnMouseMove (this, new MouseEventArgs (FromParamToMouseButtons ((int)m.WParam.ToInt32 ()), mouse_clicks, LowOrder ((int)m.LParam.ToInt32 ()), HighOrder ((int)m.LParam.ToInt32 ()), 0));
+ }
+
+ if (ActiveMaximizedMdiChild != null && ActiveMenu != null) {
+ XplatUI.RequestAdditionalWM_NCMessages (Handle, false, true);
+ ActiveMaximizedMdiChild.HandleMenuMouseMove (ActiveMenu,
+ LowOrder ((int)m.LParam.ToInt32 ()),
+ HighOrder ((int)m.LParam.ToInt32 ()));
+ }
+ base.WndProc (ref m);
+ }
+
+ private void WmNcPaint (ref Message m)
+ {
+ if (ActiveMenu != null) {
+ PaintEventArgs pe = XplatUI.PaintEventStart (ref m, Handle, false);
+ Point pnt = XplatUI.GetMenuOrigin (window.Handle);
+
+ // The entire menu has to be in the clip rectangle because the
+ // Widget buttons are right-aligned and otherwise they would
+ // stay painted when the window gets resized.
+ Rectangle clip = new Rectangle (pnt.X, pnt.Y, ClientSize.Width, 0);
+ clip = Rectangle.Union (clip, pe.ClipRectangle);
+ pe.SetClip (clip);
+ pe.Graphics.SetClip (clip);
+
+ ActiveMenu.Draw (pe, new Rectangle (pnt.X, pnt.Y, ClientSize.Width, 0));
+
+ if (ActiveMaximizedMdiChild != null)
+ ActiveMaximizedMdiChild.DrawMaximizedButtons (ActiveMenu, pe);
+
+ XplatUI.PaintEventEnd (ref m, Handle, false);
+ }
+
+ base.WndProc (ref m);
+ }
+
+ private void WmNcCalcSize (ref Message m)
+ {
+ XplatUIWin32.NCCALCSIZE_PARAMS ncp;
+
+ if ((ActiveMenu != null) && (m.WParam == (IntPtr)1)) {
+ ncp = (XplatUIWin32.NCCALCSIZE_PARAMS)Marshal.PtrToStructure (m.LParam, typeof (XplatUIWin32.NCCALCSIZE_PARAMS));
+
+ // Adjust for menu
+ ncp.rgrc1.top += ThemeEngine.Current.CalcMenuBarSize (DeviceContext, ActiveMenu, ClientSize.Width);
+ Marshal.StructureToPtr (ncp, m.LParam, true);
+ }
+ DefWndProc (ref m);
+ }
+
+ private void WmGetMinMaxInfo (ref Message m)
+ {
+ MINMAXINFO mmi;
+
+ if (m.LParam != IntPtr.Zero) {
+ mmi = (MINMAXINFO)Marshal.PtrToStructure (m.LParam, typeof (MINMAXINFO));
+
+ default_maximized_bounds = new Rectangle (mmi.ptMaxPosition.x, mmi.ptMaxPosition.y, mmi.ptMaxSize.x, mmi.ptMaxSize.y);
+ if (maximized_bounds != Rectangle.Empty) {
+ mmi.ptMaxPosition.x = maximized_bounds.Left;
+ mmi.ptMaxPosition.y = maximized_bounds.Top;
+ mmi.ptMaxSize.x = maximized_bounds.Width;
+ mmi.ptMaxSize.y = maximized_bounds.Height;
+ }
+
+ if (minimum_size != Size.Empty) {
+ mmi.ptMinTrackSize.x = minimum_size.Width;
+ mmi.ptMinTrackSize.y = minimum_size.Height;
+ }
+
+ if (maximum_size != Size.Empty) {
+ mmi.ptMaxTrackSize.x = maximum_size.Width;
+ mmi.ptMaxTrackSize.y = maximum_size.Height;
+ }
+ Marshal.StructureToPtr (mmi, m.LParam, false);
+ }
+ }
+#endregion
+
+ #region Internal / Private Methods
+ internal void ActivateFocusCues ()
+ {
+ bool need_refresh = !show_focus_cues;
+ show_focus_cues = true;
+
+ if (need_refresh)
+ ActiveWidget.Invalidate ();
+ }
+
+ internal override void FireEnter ()
+ {
+ // do nothing - forms don't generate OnEnter
+ }
+
+ internal override void FireLeave ()
+ {
+ // do nothing - forms don't generate OnLeave
+ }
+
+ internal void RemoveWindowManager ()
+ {
+ window_manager = null;
+ }
+
+ internal override void CheckAcceptButton ()
+ {
+ if (accept_button != null) {
+ Button a_button = accept_button as Button;
+
+ if (ActiveWidget == a_button)
+ return;
+
+ // If the accept_button isn't a Button, we don't need to do
+ // the rest of this.
+ if (a_button == null)
+ return;
+
+ if (ActiveWidget is Button)
+ a_button.paint_as_acceptbutton = false;
+ else
+ a_button.paint_as_acceptbutton = true;
+
+ a_button.Invalidate ();
+ }
+ }
+
+ internal override bool ActivateOnShow { get { return !this.ShowWithoutActivation; } }
+
+ private void OnLoadInternal (EventArgs e)
+ {
+ if (AutoScale) {
+ ApplyAutoScaling ();
+ AutoScale = false;
+ }
+
+ if (!IsDisposed) {
+ OnSizeInitializedOrChanged ();
+
+ // We do this here because when we load the MainForm,
+ // it happens before the exception catcher in NativeWindow,
+ // so the user can error in handling Load and we wouldn't catch it.
+ try {
+ OnLoad (e);
+ }
+ catch (Exception ex) {
+ Application.OnThreadException (ex);
+ }
+
+ if (!IsDisposed)
+ is_visible = true;
+ }
+
+ if (!IsMdiChild && !IsDisposed) {
+ switch (StartPosition) {
+ case FormStartPosition.CenterScreen:
+ this.CenterToScreen ();
+ break;
+ case FormStartPosition.CenterParent:
+ this.CenterToParent ();
+ break;
+ case FormStartPosition.Manual:
+ Left = CreateParams.X;
+ Top = CreateParams.Y;
+ break;
+ }
+ }
+
+ is_loaded = true;
+ }
+ #endregion
+
+ #region Events
+ static object ActivatedEvent = new object ();
+ static object ClosedEvent = new object ();
+ static object ClosingEvent = new object ();
+ static object DeactivateEvent = new object ();
+ static object InputLanguageChangedEvent = new object ();
+ static object InputLanguageChangingEvent = new object ();
+ static object LoadEvent = new object ();
+ static object MaximizedBoundsChangedEvent = new object ();
+ static object MaximumSizeChangedEvent = new object ();
+ static object MdiChildActivateEvent = new object ();
+ static object MenuCompleteEvent = new object ();
+ static object MenuStartEvent = new object ();
+ static object MinimumSizeChangedEvent = new object ();
+
+ public event EventHandler Activated {
+ add { Events.AddHandler (ActivatedEvent, value); }
+ remove { Events.RemoveHandler (ActivatedEvent, value); }
+ }
+
+ [Browsable (false)]
+ //[EditorBrowsable (EditorBrowsableState.Never)]
+ public event EventHandler Closed {
+ add { Events.AddHandler (ClosedEvent, value); }
+ remove { Events.RemoveHandler (ClosedEvent, value); }
+ }
+
+ [Browsable (false)]
+ //[EditorBrowsable (EditorBrowsableState.Never)]
+ public event CancelEventHandler Closing {
+ add { Events.AddHandler (ClosingEvent, value); }
+ remove { Events.RemoveHandler (ClosingEvent, value); }
+ }
+
+ public event EventHandler Deactivate {
+ add { Events.AddHandler (DeactivateEvent, value); }
+ remove { Events.RemoveHandler (DeactivateEvent, value); }
+ }
+
+ public event InputLanguageChangedEventHandler InputLanguageChanged {
+ add { Events.AddHandler (InputLanguageChangedEvent, value); }
+ remove { Events.RemoveHandler (InputLanguageChangedEvent, value); }
+ }
+
+ public event InputLanguageChangingEventHandler InputLanguageChanging {
+ add { Events.AddHandler (InputLanguageChangingEvent, value); }
+ remove { Events.RemoveHandler (InputLanguageChangingEvent, value); }
+ }
+
+ public event EventHandler Load {
+ add { Events.AddHandler (LoadEvent, value); }
+ remove { Events.RemoveHandler (LoadEvent, value); }
+ }
+
+ public event EventHandler MaximizedBoundsChanged {
+ add { Events.AddHandler (MaximizedBoundsChangedEvent, value); }
+ remove { Events.RemoveHandler (MaximizedBoundsChangedEvent, value); }
+ }
+
+ public event EventHandler MaximumSizeChanged {
+ add { Events.AddHandler (MaximumSizeChangedEvent, value); }
+ remove { Events.RemoveHandler (MaximumSizeChangedEvent, value); }
+ }
+
+ public event EventHandler MdiChildActivate {
+ add { Events.AddHandler (MdiChildActivateEvent, value); }
+ remove { Events.RemoveHandler (MdiChildActivateEvent, value); }
+ }
+
+ [Browsable (false)]
+ public event EventHandler MenuComplete {
+ add { Events.AddHandler (MenuCompleteEvent, value); }
+ remove { Events.RemoveHandler (MenuCompleteEvent, value); }
+ }
+
+ [Browsable (false)]
+ public event EventHandler MenuStart {
+ add { Events.AddHandler (MenuStartEvent, value); }
+ remove { Events.RemoveHandler (MenuStartEvent, value); }
+ }
+
+ public event EventHandler MinimumSizeChanged {
+ add { Events.AddHandler (MinimumSizeChangedEvent, value); }
+ remove { Events.RemoveHandler (MinimumSizeChangedEvent, value); }
+ }
+
+
+ [Browsable(false)]
+ //[EditorBrowsable(EditorBrowsableState.Never)]
+ public new event EventHandler TabIndexChanged {
+ add { base.TabIndexChanged += value; }
+ remove { base.TabIndexChanged -= value; }
+ }
+
+ [SettingsBindable (true)]
+ public override string Text {
+ get {
+ return base.Text;
+ }
+
+ set {
+ base.Text = value;
+ ResetSkin();
+ }
+ }
+
+ [SettingsBindable (true)]
+ public new Point Location {
+ get {
+ return base.Location;
+ }
+
+ set {
+ base.Location = value;
+ }
+ }
+
+ static object FormClosingEvent = new object ();
+ static object FormClosedEvent = new object ();
+ static object HelpButtonClickedEvent = new object ();
+ static object ResizeEndEvent = new object ();
+ static object ResizeBeginEvent = new object ();
+ static object RightToLeftLayoutChangedEvent = new object ();
+ static object ShownEvent = new object ();
+
+ [Browsable (true)]
+ //[EditorBrowsable (EditorBrowsableState.Always)]
+ public new event EventHandler AutoSizeChanged {
+ add { base.AutoSizeChanged += value; }
+ remove { base.AutoSizeChanged -= value; }
+ }
+
+ [Browsable (true)]
+ //[EditorBrowsable (EditorBrowsableState.Always)]
+ public new event EventHandler AutoValidateChanged {
+ add { base.AutoValidateChanged += value; }
+ remove { base.AutoValidateChanged -= value; }
+ }
+
+ public event FormClosingEventHandler FormClosing {
+ add { Events.AddHandler (FormClosingEvent, value); }
+ remove { Events.RemoveHandler (FormClosingEvent, value); }
+ }
+
+ public event FormClosedEventHandler FormClosed {
+ add { Events.AddHandler (FormClosedEvent, value); }
+ remove { Events.RemoveHandler (FormClosedEvent, value); }
+ }
+
+ [Browsable (true)]
+ //[EditorBrowsable (EditorBrowsableState.Always)]
+ public event CancelEventHandler HelpButtonClicked {
+ add { Events.AddHandler (HelpButtonClickedEvent, value); }
+ remove { Events.RemoveHandler (HelpButtonClickedEvent, value); }
+ }
+
+ [Browsable (false)]
+ //[EditorBrowsable (EditorBrowsableState.Never)]
+ public new event EventHandler MarginChanged {
+ add { base.MarginChanged += value; }
+ remove { base.MarginChanged -= value; }
+ }
+
+ public event EventHandler RightToLeftLayoutChanged {
+ add { Events.AddHandler (RightToLeftLayoutChangedEvent, value); }
+ remove { Events.RemoveHandler (RightToLeftLayoutChangedEvent, value); }
+ }
+
+ public event EventHandler ResizeBegin {
+ add { Events.AddHandler (ResizeBeginEvent, value); }
+ remove { Events.RemoveHandler (ResizeBeginEvent, value); }
+ }
+
+ public event EventHandler ResizeEnd {
+ add { Events.AddHandler (ResizeEndEvent, value); }
+ remove { Events.RemoveHandler (ResizeEndEvent, value); }
+ }
+
+ public event EventHandler Shown {
+ add { Events.AddHandler (ShownEvent, value); }
+ remove { Events.RemoveHandler (ShownEvent, value); }
+ }
+
+ [Browsable (false)]
+ //[EditorBrowsable (EditorBrowsableState.Never)]
+ public new event EventHandler TabStopChanged {
+ add { base.TabStopChanged += value; }
+ remove { base.TabStopChanged -= value; }
+ }
+
+ protected override void OnBackgroundImageChanged (EventArgs e)
+ {
+ base.OnBackgroundImageChanged (e);
+ }
+
+ protected override void OnBackgroundImageLayoutChanged (EventArgs e)
+ {
+ base.OnBackgroundImageLayoutChanged (e);
+ }
+
+ //[EditorBrowsable (EditorBrowsableState.Advanced)]
+ protected override void OnEnabledChanged (EventArgs e)
+ {
+ base.OnEnabledChanged (e);
+ }
+
+ //[EditorBrowsable (EditorBrowsableState.Advanced)]
+ protected override void OnEnter (EventArgs e)
+ {
+ base.OnEnter (e);
+ }
+
+ //[EditorBrowsable (EditorBrowsableState.Advanced)]
+ protected virtual void OnFormClosed (FormClosedEventArgs e) {
+ Application.RemoveForm (this);
+ FormClosedEventHandler eh = (FormClosedEventHandler)(Events[FormClosedEvent]);
+ if (eh != null)
+ eh (this, e);
+
+ foreach (Form form in disabled_by_showdialog)
+ {
+ form.Enabled = true;
+ }
+ disabled_by_showdialog.Clear();
+ if (modal_dialogs.Contains(this))
+ modal_dialogs.Remove(this);
+ }
+
+ // Consider calling FireClosingEvents instead of calling this directly.
+ //[EditorBrowsable (EditorBrowsableState.Advanced)]
+ protected virtual void OnFormClosing (FormClosingEventArgs e)
+ {
+ FormClosingEventHandler eh = (FormClosingEventHandler)(Events [FormClosingEvent]);
+ if (eh != null)
+ eh (this, e);
+ }
+
+ [MonoTODO ("Will never be called")]
+ //[EditorBrowsable (EditorBrowsableState.Advanced)]
+ protected virtual void OnHelpButtonClicked (CancelEventArgs e)
+ {
+ CancelEventHandler eh = (CancelEventHandler)(Events[HelpButtonClickedEvent]);
+ if (eh != null)
+ eh (this, e);
+ }
+
+ protected override void OnLayout (LayoutEventArgs levent)
+ {
+ base.OnLayout (levent);
+
+ if (AutoSize) {
+ Size new_size = GetPreferredSizeCore (Size.Empty);
+ if (AutoSizeMode == AutoSizeMode.GrowOnly) {
+ new_size.Width = Math.Max (new_size.Width, Width);
+ new_size.Height = Math.Max (new_size.Height, Height);
+ }
+ if (new_size == Size)
+ return;
+
+ SetBoundsInternal (bounds.X, bounds.Y, new_size.Width, new_size.Height, BoundsSpecified.None);
+ }
+ }
+
+ //[EditorBrowsable (EditorBrowsableState.Advanced)]
+ protected virtual void OnResizeBegin (EventArgs e)
+ {
+ EventHandler eh = (EventHandler) (Events [ResizeBeginEvent]);
+ if (eh != null)
+ eh (this, e);
+ }
+
+ //[EditorBrowsable (EditorBrowsableState.Advanced)]
+ protected virtual void OnResizeEnd (EventArgs e)
+ {
+ EventHandler eh = (EventHandler) (Events [ResizeEndEvent]);
+ if (eh != null)
+ eh (this, e);
+ }
+
+ //[EditorBrowsable (EditorBrowsableState.Advanced)]
+ protected virtual void OnRightToLeftLayoutChanged (EventArgs e)
+ {
+ EventHandler eh = (EventHandler)(Events[RightToLeftLayoutChangedEvent]);
+ if (eh != null)
+ eh (this, e);
+ }
+
+ //[EditorBrowsable (EditorBrowsableState.Advanced)]
+ protected virtual void OnShown (EventArgs e)
+ {
+ EventHandler eh = (EventHandler) (Events [ShownEvent]);
+ if (eh != null)
+ eh (this, e);
+ }
+
+ #region UIA Framework Events
+ static object UIAMenuChangedEvent = new object ();
+ static object UIATopMostChangedEvent = new object ();
+ static object UIAWindowStateChangedEvent = new object ();
+
+ internal event EventHandler UIAMenuChanged {
+ add { Events.AddHandler (UIAMenuChangedEvent, value); }
+ remove { Events.RemoveHandler (UIAMenuChangedEvent, value); }
+ }
+
+ internal event EventHandler UIATopMostChanged {
+ add { Events.AddHandler (UIATopMostChangedEvent, value); }
+ remove { Events.RemoveHandler (UIATopMostChangedEvent, value); }
+ }
+
+ internal event EventHandler UIAWindowStateChanged {
+ add { Events.AddHandler (UIAWindowStateChangedEvent, value); }
+ remove { Events.RemoveHandler (UIAWindowStateChangedEvent, value); }
+ }
+
+ internal void OnUIAMenuChanged (EventArgs e)
+ {
+ EventHandler eh = (EventHandler) Events [UIAMenuChangedEvent];
+ if (eh != null)
+ eh (this, e);
+ }
+
+ internal void OnUIATopMostChanged ()
+ {
+ EventHandler eh = (EventHandler) Events [UIATopMostChangedEvent];
+ if (eh != null)
+ eh (this, EventArgs.Empty);
+ }
+
+ internal void OnUIAWindowStateChanged ()
+ {
+ EventHandler eh = (EventHandler) Events [UIAWindowStateChangedEvent];
+ if (eh != null)
+ eh (this, EventArgs.Empty);
+ }
+ #endregion // UIA Framework Events
+ #endregion // Events
+ }
+}
diff --git a/source/ShiftUI/Form/FormClosedEventArgs.cs b/source/ShiftUI/Form/FormClosedEventArgs.cs
new file mode 100644
index 0000000..376ab8c
--- /dev/null
+++ b/source/ShiftUI/Form/FormClosedEventArgs.cs
@@ -0,0 +1,49 @@
+//
+// FormClosedEventArgs.cs
+//
+// 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) 2006 Novell, Inc.
+//
+// Authors:
+// Jonathan Pobst ([email protected])
+//
+using System;
+
+namespace ShiftUI
+{
+ public class FormClosedEventArgs : EventArgs
+ {
+ private CloseReason close_reason;
+
+ #region Public Constructors
+ public FormClosedEventArgs (CloseReason closeReason)
+ {
+ this.close_reason = closeReason;
+ }
+ #endregion // Public Constructors
+
+ #region Public Instance Properties
+ public CloseReason CloseReason {
+ get { return this.close_reason; }
+ }
+ #endregion // Public Instance Properties
+ }
+}
diff --git a/source/ShiftUI/Form/FormClosedEventHandler.cs b/source/ShiftUI/Form/FormClosedEventHandler.cs
new file mode 100644
index 0000000..3f8585c
--- /dev/null
+++ b/source/ShiftUI/Form/FormClosedEventHandler.cs
@@ -0,0 +1,32 @@
+//
+// FormClosedEventHandler.cs
+//
+// 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) 2006 Novell, Inc.
+//
+// Authors:
+// Jonathan Pobst ([email protected])
+//
+
+namespace ShiftUI
+{
+ public delegate void FormClosedEventHandler (object sender, FormClosedEventArgs e);
+} \ No newline at end of file
diff --git a/source/ShiftUI/Form/FormClosingEventArgs.cs b/source/ShiftUI/Form/FormClosingEventArgs.cs
new file mode 100644
index 0000000..b221ec1
--- /dev/null
+++ b/source/ShiftUI/Form/FormClosingEventArgs.cs
@@ -0,0 +1,51 @@
+//
+// FormClosingEventArgs.cs
+//
+// 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) 2006 Novell, Inc.
+//
+// Authors:
+// Jonathan Pobst ([email protected])
+//
+
+
+using System.ComponentModel;
+
+namespace ShiftUI
+{
+ public class FormClosingEventArgs : CancelEventArgs
+ {
+ private CloseReason close_reason;
+
+ #region Public Constructors
+ public FormClosingEventArgs (CloseReason closeReason, bool cancel) : base (cancel)
+ {
+ this.close_reason = closeReason;
+ }
+ #endregion // Public Constructors
+
+ #region Public Instance Properties
+ public CloseReason CloseReason {
+ get { return this.close_reason; }
+ }
+ #endregion // Public Instance Properties
+ }
+}
diff --git a/source/ShiftUI/Form/FormClosingEventHandler.cs b/source/ShiftUI/Form/FormClosingEventHandler.cs
new file mode 100644
index 0000000..f4fffca
--- /dev/null
+++ b/source/ShiftUI/Form/FormClosingEventHandler.cs
@@ -0,0 +1,32 @@
+//
+// FormClosingEventHandler.cs
+//
+// 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) 2006 Novell, Inc.
+//
+// Authors:
+// Jonathan Pobst ([email protected])
+//
+
+namespace ShiftUI
+{
+ public delegate void FormClosingEventHandler (object sender, FormClosingEventArgs e);
+}
diff --git a/source/ShiftUI/Form/FormCollection.cs b/source/ShiftUI/Form/FormCollection.cs
new file mode 100644
index 0000000..a8314a5
--- /dev/null
+++ b/source/ShiftUI/Form/FormCollection.cs
@@ -0,0 +1,73 @@
+//
+// FormCollection.cs
+//
+// 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) 2006 Jonathan Pobst
+//
+// Authors:
+// Jonathan Pobst ([email protected])
+//
+using System;
+using System.Collections;
+using System.Text;
+
+namespace ShiftUI
+{
+ public class FormCollection : ReadOnlyCollectionBase
+ {
+ public FormCollection () : base ()
+ {
+ }
+
+ #region Public Properties
+ public virtual Form this[int index] {
+ get {
+ return (Form)base.InnerList[index];
+ }
+ }
+
+ public virtual Form this[string name] {
+ get {
+ foreach (Form f in base.InnerList)
+ if (f.Name == name)
+ return f;
+
+ return null;
+ }
+ }
+ #endregion
+
+ #region Internal Add/Remove Methods
+ internal void Add (Form form)
+ {
+ if (base.InnerList.Contains (form))
+ return;
+
+ base.InnerList.Add (form);
+ }
+
+ internal void Remove (Form form)
+ {
+ base.InnerList.Remove (form);
+ }
+ #endregion
+ }
+}
diff --git a/source/ShiftUI/Form/FormStartPosition.cs b/source/ShiftUI/Form/FormStartPosition.cs
new file mode 100644
index 0000000..9c0cc79
--- /dev/null
+++ b/source/ShiftUI/Form/FormStartPosition.cs
@@ -0,0 +1,39 @@
+// 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 Novell, Inc.
+//
+// Authors:
+// Ravindra ([email protected])
+//
+
+using System.Runtime.InteropServices;
+
+namespace ShiftUI
+{
+ [ComVisible (true)]
+ public enum FormStartPosition
+ {
+ Manual = 0,
+ CenterScreen = 1,
+ WindowsDefaultLocation = 2,
+ WindowsDefaultBounds = 3,
+ CenterParent = 4
+ }
+}
diff --git a/source/ShiftUI/Form/FormWindowManager.cs b/source/ShiftUI/Form/FormWindowManager.cs
new file mode 100644
index 0000000..c8222fe
--- /dev/null
+++ b/source/ShiftUI/Form/FormWindowManager.cs
@@ -0,0 +1,87 @@
+// 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) 2007 Novell, Inc. (http://www.novell.com)
+//
+// Authors:
+// Rolf Bjarne Kvinge ([email protected])
+//
+//
+
+
+using System;
+using System.Drawing;
+using System.Runtime.InteropServices;
+
+namespace ShiftUI
+{
+ internal class FormWindowManager : InternalWindowManager
+ {
+ private bool pending_activation;
+ public FormWindowManager (Form form) : base (form)
+ {
+
+ form.MouseCaptureChanged += new EventHandler (HandleCaptureChanged);
+ }
+
+ void HandleCaptureChanged (object sender, EventArgs e)
+ {
+ if (pending_activation && !form.Capture) {
+ form.BringToFront ();
+ pending_activation = false;
+ }
+ }
+
+ public override void PointToClient (ref int x, ref int y)
+ {
+ XplatUI.ScreenToClient (Form.Parent.Handle, ref x, ref y);
+ }
+
+
+ protected override bool HandleNCLButtonDown (ref Message m)
+ {
+ // MS seems to be doing this on mouse up, but we don't get WM_NCLBUTTONUP when anything is captured
+ // so work around this using MouseCaptureChanged.
+ pending_activation = true;
+
+ return base.HandleNCLButtonDown (ref m);
+ }
+
+ protected override void HandleTitleBarDoubleClick (int x, int y)
+ {
+ if (IconRectangleContains (x, y)) {
+ form.Close ();
+ } else if (form.WindowState == FormWindowState.Maximized) {
+ form.WindowState = FormWindowState.Normal;
+ } else {
+ form.WindowState = FormWindowState.Maximized;
+ }
+ base.HandleTitleBarDoubleClick (x, y);
+ }
+
+ internal override Rectangle MaximizedBounds {
+ get {
+ Rectangle result = base.MaximizedBounds;
+ int bw = ThemeEngine.Current.ManagedWindowBorderWidth (this);
+ result.Inflate (bw, bw);
+ return result;
+ }
+ }
+ }
+}
diff --git a/source/ShiftUI/Form/FormWindowState.cs b/source/ShiftUI/Form/FormWindowState.cs
new file mode 100644
index 0000000..40a970f
--- /dev/null
+++ b/source/ShiftUI/Form/FormWindowState.cs
@@ -0,0 +1,38 @@
+// 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 Novell, Inc.
+//
+// Authors:
+// Ravindra ([email protected])
+//
+
+
+using System.Runtime.InteropServices;
+
+namespace ShiftUI
+{
+ [ComVisible (true)]
+ public enum FormWindowState
+ {
+ Normal = 0,
+ Minimized = 1,
+ Maximized = 2
+ }
+}
diff --git a/source/ShiftUI/Form/MessageBox.cs b/source/ShiftUI/Form/MessageBox.cs
new file mode 100644
index 0000000..aab960a
--- /dev/null
+++ b/source/ShiftUI/Form/MessageBox.cs
@@ -0,0 +1,66 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace ShiftUI
+{
+ public class MessageBox : Form
+ {
+
+ public static void Show(string message, string title)
+ {
+ var m = new MessageBox(title, message);
+
+ m.TopMost = true;
+ m.ShowDialog();
+ }
+
+ public MessageBox(string title, string message)
+ {
+ var pnlbottom = new FlowLayoutPanel();
+ pnlbottom.Height = 30;
+ pnlbottom.BackColor = Application.CurrentSkin.MessageBox_BottomPanel;
+ var pnltop = new Panel();
+ pnlbottom.Dock = DockStyle.Bottom;
+ pnltop.Dock = DockStyle.Fill;
+ this.Widgets.Add(pnlbottom);
+ pnlbottom.Show();
+ this.Widgets.Add(pnltop);
+ pnltop.Show();
+ var btnok = new Button();
+ btnok.Text = "OK";
+ btnok.AutoSize = true;
+ btnok.AutoSizeMode = AutoSizeMode.GrowAndShrink;
+ pnlbottom.Widgets.Add(btnok);
+ btnok.Show();
+ btnok.Click += (s, a) =>
+ {
+ this.Close();
+ };
+ var lblmessage = new Label();
+ lblmessage.Padding = new Padding(25);
+ lblmessage.Text = message;
+ lblmessage.Dock = DockStyle.Fill;
+ pnltop.Widgets.Add(lblmessage);
+ lblmessage.Show();
+ //autosize the form
+ int newheight = 10;
+ for(int i = 0; i < lblmessage.Text.Length; i++)
+ {
+ if ((i % 2) == 0)
+ newheight += 10;
+ }
+ this.MaximumSize = new System.Drawing.Size(500, 200);
+ this.Height = newheight + pnlbottom.Height;
+ this.Load += (o, a) =>
+ {
+ this.Left = (Screen.PrimaryScreen.Bounds.Width - this.Width) / 2;
+ this.Top = (Screen.PrimaryScreen.Bounds.Height - this.Height) / 2;
+
+ };
+ this.Text = title;
+ }
+ }
+}
generated by cgit v1.2.3 (git 2.46.0) at 2026-06-04 09:26:23 +0000