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;
namespace System.Windows.Forms {
+ [DesignerCategory("Form")]
+ [DesignTimeVisible(false)]
+ [Designer("System.Windows.Forms.Design.FormDocumentDesigner, " + Consts.AssemblySystem_Design, typeof(IRootDesigner))]
+ [DefaultEvent("Load")]
+ [ToolboxItem(false)]
public class Form : ContainerControl {
#region Local Variables
internal static Form active_form;
private FormStartPosition start_position;
private Form owner;
private Form.ControlCollection owned_forms;
+ private MdiClient mdi_container;
+ private MdiChildContext mdi_child_context;
+ private Form mdi_parent;
private bool key_preview;
private MainMenu menu;
- internal FormParentWindow form_parent_window;
private Icon icon;
private Size maximum_size;
private Size minimum_size;
- #endregion // Local Variables
-
- #region Private Classes
-
- // This class will take over for the client area
- internal class FormParentWindow : Control {
- #region FormParentWindow Class Local Variables
- internal Form owner;
- #endregion // FormParentWindow Class Local Variables
-
- #region FormParentWindow Class Constructor
- internal FormParentWindow(Form owner) : base() {
- this.owner = owner;
-
- this.Width = 250;
- this.Height = 250;
-
- BackColor = owner.BackColor;
- Text = "FormParent";
- this.Location = new Point(0, 0);
- this.Dock = DockStyle.Fill;
- this.is_visible = false;
-
- MouseDown += new MouseEventHandler (OnMouseDownForm);
- MouseMove += new MouseEventHandler (OnMouseMoveForm);
- owner.TextChanged += new EventHandler(OnFormTextChanged);
- }
- #endregion // FormParentWindow Class Constructor
-
- #region FormParentWindow Class Protected Instance Methods
- protected override CreateParams CreateParams {
- get {
- CreateParams cp;
-
- cp = base.CreateParams;
-
- cp.Style = (int)(WindowStyles.WS_OVERLAPPEDWINDOW |
- WindowStyles.WS_CLIPSIBLINGS |
- WindowStyles.WS_CLIPCHILDREN);
-
- cp.Width = 250;
- cp.Height = 250;
-
- if (owner != null) {
- if (owner.ShowInTaskbar) {
- cp.ExStyle |= (int)WindowStyles.WS_EX_APPWINDOW;
- }
-
- if (owner.MaximizeBox) {
- cp.Style |= (int)WindowStyles.WS_MAXIMIZEBOX;
- }
-
- if (owner.MinimizeBox) {
- cp.Style |= (int)WindowStyles.WS_MINIMIZEBOX;
- }
-
- if (owner.ControlBox) {
- cp.Style |= (int)WindowStyles.WS_SYSMENU;
- }
-
- if (owner.HelpButton) {
- cp.ExStyle |= (int)WindowStyles.WS_EX_CONTEXTHELP;
- }
- } else {
- // Defaults
- cp.Style |= (int)(WindowStyles.WS_SYSMENU | WindowStyles.WS_MINIMIZEBOX | WindowStyles.WS_MAXIMIZEBOX);
- cp.ExStyle |= (int)WindowStyles.WS_EX_APPWINDOW;
- }
-
- return cp;
- }
- }
-
- protected override void OnResize(EventArgs e) {
- base.OnResize(e);
- //owner.SetBoundsCore(owner.Bounds.X, owner.Bounds.Y, ClientSize.Width, ClientSize.Height, BoundsSpecified.All);
- if (owner.menu == null) {
- owner.SetBoundsCore(0, 0, ClientSize.Width, ClientSize.Height, BoundsSpecified.All);
- } else {
- int menu_height;
-
- menu_height = MenuAPI.MenuBarCalcSize(DeviceContext, owner.Menu.menu_handle, ClientSize.Width);
- Invalidate (new Rectangle (0, 0, ClientSize.Width, menu_height));
- owner.SetBoundsCore(0, menu_height, ClientSize.Width, ClientSize.Height-menu_height, BoundsSpecified.All);
- }
- }
-
- protected override void OnPaint(PaintEventArgs pevent) {
- OnDrawMenu (pevent.Graphics);
- }
-
- protected override void WndProc(ref Message m) {
- switch((Msg)m.Msg) {
- case Msg.WM_CLOSE: {
- CancelEventArgs args = new CancelEventArgs();
-
- owner.OnClosing(args);
-
- if (!args.Cancel) {
- owner.OnClosed(EventArgs.Empty);
- owner.closing = true;
- base.WndProc(ref m);
- break;
- }
- break;
- }
- case Msg.WM_ACTIVATEAPP: {
- if (m.WParam == (IntPtr)1) {
-Console.WriteLine("App activated");
- owner.OnActivated(EventArgs.Empty);
-// } else {
-//Console.WriteLine("App de-activated");
-// owner.OnDeactivate(EventArgs.Empty);
- }
- break;
- }
-#if not
- case Msg.WM_ACTIVATE: {
- if (m.WParam == (IntPtr)WindowActiveFlags.WA_INACTIVE) {
- if (active_form == owner) {
- owner.OnDeactivate(EventArgs.Empty);
- active_form = null;
- }
- }
- break;
- }
-#endif
-
- case Msg.WM_SETFOCUS: {
- owner.OnActivated(EventArgs.Empty);
- base.WndProc(ref m);
- break;
- }
-
- case Msg.WM_KILLFOCUS: {
- owner.OnDeactivate(EventArgs.Empty);
- base.WndProc(ref m);
- break;
- }
-
-#if topmost_workaround
- case Msg.WM_ACTIVATE: {
- if (this.OwnedForms.Length>0) {
- XplatUI.SetZOrder(this.OwnedForms[0].window.Handle, this.window.Handle, false, false);
- }
- break;
- }
-#endif
-
- default: {
- base.WndProc (ref m);
- break;
- }
- }
- }
- #endregion // FormParentWindow Class Protected Instance Methods
+ private SizeGripStyle size_grip_style;
+ private Rectangle maximized_bounds;
+ private Rectangle default_maximized_bounds;
+ Color transparency_key;\r
- #region FormParentWindow Class Private Methods
- private void OnMouseDownForm (object sender, MouseEventArgs e) {
- if (owner.menu != null)
- owner.menu.OnMouseDown (owner, e);
- }
+ #endregion // Local Variables
- private void OnMouseMoveForm (object sender, MouseEventArgs e) {
- if (owner.menu != null)
- owner.menu.OnMouseMove (owner, e);
- }
-
-
- private void OnDrawMenu (Graphics dc) {
- if (owner.menu != null) {
- Rectangle rect = new Rectangle (0,0, Width, 0);
- MenuAPI.DrawMenuBar (dc, owner.menu.Handle, rect);
- }
- }
- private void OnFormTextChanged(object sender, EventArgs e) {
- this.Text = ((Control)sender).Text;
- }
- #endregion // FormParentWindow Class Private Methods
- }
- #endregion // Private Classes
+ #region Private & Internal Methods
+ #endregion // Private & Internal Methods
#region Public Classes
public new class ControlCollection : Control.ControlCollection {
}
}
#endregion // Public Classes
-
+
#region Public Constructor & Destructor
public Form() {
closing = false;
maximize_box = true;
help_button = false;
show_in_taskbar = true;
-
+ ime_mode = ImeMode.NoControl;
+ is_visible = false;
+ is_toplevel = true;
+ size_grip_style = SizeGripStyle.Auto;
+ maximized_bounds = Rectangle.Empty;
+ default_maximized_bounds = Rectangle.Empty;
owned_forms = new Form.ControlCollection(this);
+ transparency_key = Color.Empty;
}
#endregion // Public Constructor & Destructor
-
#region Public Static Properties
public static Form ActiveForm {
if (active != null) {
if ( !(active is Form)) {
- if (active is FormParentWindow) {
- return ((FormParentWindow)active).owner;
- } else {
- Control parent;
-
- parent = active.Parent;
- while (parent != null) {
- if (parent is Form) {
- return (Form)parent;
- }
- parent = parent.Parent;
+ Control parent;
+
+ parent = active.Parent;
+ while (parent != null) {
+ if (parent is Form) {
+ return (Form)parent;
}
+ parent = parent.Parent;
}
} else {
return (Form)active;
#endregion // Public Static Properties
#region Public Instance Properties
+ [DefaultValue(null)]
public IButtonControl AcceptButton {
get {
return accept_button;
accept_button = value;
}
}
+
+ [MonoTODO("Figure out a way for transparency support in windows")]
+ [Browsable(false)]
+ [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
+ public bool AllowTransparency {
+ get {
+ return false;
+ }
+
+ set {
+ }
+ }
+ [DefaultValue(true)]
public bool AutoScale {
get {
return autoscale;
}
}
+ [Localizable(true)]
+ [Browsable(false)]
+ [EditorBrowsable(EditorBrowsableState.Advanced)]
public virtual Size AutoScaleBaseSize {
get {
return autoscale_base_size;
}
}
+ [Localizable(true)]
+ public override bool AutoScroll {
+ get {
+ return base.AutoScroll;
+ }
+ set {
+ base.AutoScroll = value;
+ }
+ }
+
+ public override Color BackColor {
+ get {
+ return base.BackColor;
+ }
+ set {
+ base.BackColor = value;
+ }
+ }
+
+ [DefaultValue(null)]
public IButtonControl CancelButton {
get {
return cancel_button;
}
}
+ [DesignerSerializationVisibility(DesignerSerializationVisibility.Visible)]
+ [Localizable(true)]
+ public Size ClientSize {
+ get {
+ return base.ClientSize;
+ }
+
+ set {
+ base.ClientSize = value;
+ }
+ }
+
+ [DefaultValue(true)]
public bool ControlBox {
get {
return control_box;
set {
if (control_box != value) {
control_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;
}
}
+ [DefaultValue(FormBorderStyle.Sizable)]
+ [DispId(-504)]
public FormBorderStyle FormBorderStyle {
get {
return formBorderStyle;
}
set {
formBorderStyle = value;
- Invalidate ();
+ UpdateStyles();
}
}
+ [DefaultValue(false)]
public bool HelpButton {
get {
return help_button;
set {
if (help_button != value) {
help_button = value;
+ UpdateStyles();
}
}
}
+ [Localizable(true)]
+ [AmbientValue(null)]
public Icon Icon {
get {
return icon;
set {
if (icon != value) {
icon = value;
+
+ XplatUI.SetIcon(Handle, icon);
+ }
+ }
+ }
+
+ [Browsable(false)]
+ [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
+ public bool IsMdiChild {
+ get {
+ return mdi_parent != null;
+ }
+ }
+
+ [DefaultValue(false)]
+ public bool IsMdiContainer {
+ get {
+ return mdi_container != null;
+ }
+
+ set {
+ if (value && mdi_container == null) {
+ mdi_container = new MdiClient();
+ Controls.Add(mdi_container);
+ } else if (!value && mdi_container != null) {
+ Controls.Remove(mdi_container);
+ mdi_container.Dispose();
}
}
}
+ [Browsable(false)]
+ [EditorBrowsable(EditorBrowsableState.Advanced)]
+ public bool IsRestrictedWindow {
+ get {
+ return false;
+ }
+ }
+ [DefaultValue(false)]
public bool KeyPreview {
get {
return key_preview;
}
}
+ [DefaultValue(true)]
public bool MaximizeBox {
get {
return maximize_box;
set {
if (maximize_box != value) {
maximize_box = value;
+ UpdateStyles();
}
}
}
+ [DefaultValue("{Width=0, Height=0}")]
+ [Localizable(true)]
+ [RefreshProperties(RefreshProperties.Repaint)]
public Size MaximumSize {
get {
return maximum_size;
set {
if (maximum_size != value) {
maximum_size = value;
+ OnMaximumSizeChanged(EventArgs.Empty);
}
}
}
- public MainMenu Menu {
+ [Browsable(false)]
+ [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
+ public Form[] MdiChildren {
get {
- return menu;
+ if (mdi_container != null) {
+ Form[] form_list;
+
+ form_list = new Form[mdi_container.Controls.Count];
+ for (int i = 0; i < mdi_container.Controls.Count; i++) {
+ form_list[i] = (Form)mdi_container.Controls[i];
+ }
+ return form_list;
+ } else {
+ return new Form[0];
+ }
+ }
+ }
+
+ [MonoTODO("Finish setter")]
+ [Browsable(false)]
+ [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
+ public Form MdiParent {
+ get {
+ return mdi_parent;
}
set {
- if (menu != value) {
- if (value == null) {
- form_parent_window.Width = form_parent_window.Width; // Trigger a resize
- }
+ SuspendLayout ();
+
+ // TopLevel = true;
+
+ if (!value.IsMdiContainer)
+ throw new ArgumentException ();
+
+ if (mdi_parent != null) {
+ mdi_parent.MdiContainer.Controls.Remove (this);
+ }
+
+ mdi_parent = value;
+ if (mdi_parent != null) {
+ mdi_child_context = new MdiChildContext (this);
+ mdi_parent.MdiContainer.Controls.Add (this);
+ }
+
+ ResumeLayout ();
+ }
+ }
+
+ internal MdiClient MdiContainer {
+ get { return mdi_container; }
+ }
+
+ [DefaultValue(null)]
+ public MainMenu Menu {
+ get {
+ return menu;
+ }
+ set {
+ if (menu != value) {
menu = value;
- // To simulate the non-client are for menus we create a
- // new control as the 'client area' of our form. This
- // way, the origin stays 0,0 and we don't have to fiddle with
- // coordinates. The menu area is part of the original container
- if (menu != null) {
- form_parent_window.Width = form_parent_window.Width; // Trigger a resize
+ menu.SetForm (this);
+ MenuAPI.SetMenuBarWindow (menu.Handle, this);
+
+ if (IsHandleCreated && menu != null) {
+ XplatUI.SetMenu(window.Handle, menu.Handle);
}
- menu.SetForm (this);
- MenuAPI.SetMenuBarWindow (menu.Handle, form_parent_window);
+ // FIXME - Do we still need this?
+ this.SetBoundsCore(0, 0, 0, 0, BoundsSpecified.None);
+
+ ThemeEngine.Current.CalcMenuBarSize (DeviceContext, menu.Handle, ClientSize.Width);
}
}
}
+ [DefaultValue(true)]
public bool MinimizeBox {
get {
return minimize_box;
set {
if (minimize_box != value) {
minimize_box = value;
+ UpdateStyles();
}
}
}
+ [DefaultValue("{Width=0, Height=0}")]
+ [Localizable(true)]
+ [RefreshProperties(RefreshProperties.Repaint)]
public Size MinimumSize {
get {
return minimum_size;
set {
if (minimum_size != value) {
minimum_size = value;
+ OnMinimumSizeChanged(EventArgs.Empty);
}
}
}
+ [Browsable(false)]
+ [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
public bool Modal {
get {
return is_modal;
}
}
+ [Browsable(false)]
+ [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
public Form[] OwnedForms {
get {
Form[] form_list;
}
}
+ [Browsable(false)]
+ [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
public Form Owner {
get {
return owner;
}
}
+ [DefaultValue(true)]
public bool ShowInTaskbar {
get {
return show_in_taskbar;
set {
if (show_in_taskbar != value) {
show_in_taskbar = value;
+ UpdateStyles();
}
}
}
+ [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
+ [Localizable(false)]
+ public Size Size {
+ get {
+ return base.Size;
+ }
+
+ set {
+ base.Size = value;
+ }
+ }
+
+ [MonoTODO("Trigger something when GripStyle is set")]
+ [DefaultValue(SizeGripStyle.Auto)]
+ public SizeGripStyle SizeGripStyle {
+ get {
+ return size_grip_style;
+ }
+
+ set {
+ size_grip_style = value;
+ }
+ }
+
+ [DefaultValue(FormStartPosition.WindowsDefaultLocation)]
+ [Localizable(true)]
public FormStartPosition StartPosition {
get {
return start_position;
set {
if (start_position == FormStartPosition.WindowsDefaultLocation) { // Only do this if it's not set yet
start_position = value;
- if (form_parent_window.IsHandleCreated) {
+ if (IsHandleCreated) {
switch(start_position) {
case FormStartPosition.CenterParent: {
- if (Parent!=null && Width>0 && Height>0) {
- this.Location = new Point(Parent.Size.Width/2-Width/2, Parent.Size.Height/2-Height/2);
- }
+ CenterToParent();
break;
}
case FormStartPosition.CenterScreen: {
- if (Width>0 && Height>0) {
- Size DisplaySize;
-
- XplatUI.GetDisplaySize(out DisplaySize);
- this.Location = new Point(DisplaySize.Width/2-Width/2, DisplaySize.Height/2-Height/2);
- }
+ CenterToScreen();
break;
}
}
}
+ [Browsable(false)]
+ [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ public int TabIndex {
+ get {
+ return base.TabIndex;
+ }
+
+ set {
+ base.TabIndex = 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)]
public bool TopMost {
get {
return topmost;
}
+
set {
if (topmost != value) {
topmost = value;
}
}
+ public Color TransparencyKey {\r
+ get {\r
+ return transparency_key;\r
+ }\r
+\r
+ set {\r
+ AllowTransparency = true;\r
+ transparency_key = value;\r
+ // TODO: change window attributes; a new driver call\r
+ }\r
+ }\r
+
+ [DefaultValue(FormWindowState.Normal)]
+ public FormWindowState WindowState {
+ get {
+ return XplatUI.GetWindowState(window.Handle);
+ }
+
+ set {
+ XplatUI.SetWindowState(window.Handle, value);
+ }
+ }
+
#endregion // Public Instance Properties
#region Protected Instance Properties
[MonoTODO("Need to add MDI support")]
protected override CreateParams CreateParams {
get {
- CreateParams cp = new CreateParams();
+ CreateParams cp;
- if (this.form_parent_window == null) {
- form_parent_window = new FormParentWindow(this);
- }
+ cp = new CreateParams();
- cp.Caption = "ClientArea";
- cp.ClassName=XplatUI.DefaultClassName;
+ cp.Caption = "FormWindow";
+ cp.ClassName = XplatUI.DefaultClassName;
cp.ClassStyle = 0;
- cp.ExStyle=0;
- cp.Param=0;
- cp.Parent = this.form_parent_window.window.Handle;
- cp.X = Left;
- cp.Y = Top;
+ cp.ExStyle = 0;
+ cp.Param = 0;
+ cp.Parent = IntPtr.Zero;
+// if (start_position == FormStartPosition.WindowsDefaultLocation) {
+ cp.X = unchecked((int)0x80000000);
+ cp.Y = unchecked((int)0x80000000);
+// } else {
+// cp.X = Left;
+// cp.Y = Top;
+// }
cp.Width = Width;
cp.Height = Height;
- cp.Style = (int)WindowStyles.WS_CHILD;
- cp.Style |= (int)WindowStyles.WS_VISIBLE;
- cp.Style |= (int)WindowStyles.WS_CLIPSIBLINGS;
- cp.Style |= (int)WindowStyles.WS_CLIPCHILDREN;
+ cp.Style = (int)(WindowStyles.WS_CLIPSIBLINGS | WindowStyles.WS_CLIPCHILDREN);
+
+ switch (FormBorderStyle) {
+ case FormBorderStyle.Fixed3D: {
+ cp.Style |= (int)WindowStyles.WS_CAPTION;
+ cp.ExStyle |= (int)WindowStyles.WS_EX_OVERLAPPEDWINDOW;
+ break;
+ }
+
+ case FormBorderStyle.FixedDialog: {
+ cp.Style |= (int)WindowStyles.WS_CAPTION;
+ cp.ExStyle |= (int)(WindowStyles.WS_EX_DLGMODALFRAME | WindowStyles.WS_EX_WINDOWEDGE);
+ break;
+ }
+
+ case FormBorderStyle.FixedSingle: {
+ cp.Style |= (int)WindowStyles.WS_CAPTION;
+ cp.ExStyle |= (int)(WindowStyles.WS_EX_WINDOWEDGE);
+ break;
+ }
+
+ case FormBorderStyle.FixedToolWindow: {
+ cp.Style |= (int)WindowStyles.WS_CAPTION;
+ cp.ExStyle |= (int)(WindowStyles.WS_EX_WINDOWEDGE | WindowStyles.WS_EX_TOOLWINDOW);
+ break;
+ }
+
+ case FormBorderStyle.Sizable: {
+ cp.Style |= (int)WindowStyles.WS_OVERLAPPEDWINDOW;
+ cp.ExStyle |= (int)(WindowStyles.WS_EX_WINDOWEDGE);
+ break;
+ }
+
+ case FormBorderStyle.SizableToolWindow: {
+ cp.Style |= (int)WindowStyles.WS_OVERLAPPEDWINDOW;
+ cp.ExStyle |= (int)(WindowStyles.WS_EX_WINDOWEDGE | WindowStyles.WS_EX_TOOLWINDOW);
+ break;
+ }
+ }
+ if (ShowInTaskbar) {
+ cp.ExStyle |= (int)WindowStyles.WS_EX_APPWINDOW;
+ }
+
+ if (MaximizeBox) {
+ cp.Style |= (int)WindowStyles.WS_MAXIMIZEBOX;
+ }
+
+ if (MinimizeBox) {
+ cp.Style |= (int)WindowStyles.WS_MINIMIZEBOX;
+ }
+
+ if (ControlBox) {
+ cp.Style |= (int)WindowStyles.WS_SYSMENU;
+ }
+
+ if (HelpButton) {
+ cp.ExStyle |= (int)WindowStyles.WS_EX_CONTEXTHELP;
+ }
return cp;
}
}
+ protected override ImeMode DefaultImeMode {
+ get {
+ return ImeMode.NoControl;
+ }
+ }
+
protected override Size DefaultSize {
get {
return new Size (250, 250);
}
}
- protected override void OnPaint (PaintEventArgs pevent)
- {
- base.OnPaint (pevent);
- }
-
- #endregion // Protected Instance Properties
+ protected Rectangle MaximizedBounds {
+ get {
+ if (maximized_bounds != Rectangle.Empty) {
+ return maximized_bounds;
+ }
+ return default_maximized_bounds;
+ }
+ set {
+ maximized_bounds = value;
+ OnMaximizedBoundsChanged(EventArgs.Empty);
+ }
+ }
+ #endregion // Protected Instance Properties
#region Public Static Methods
+ [MonoTODO("Figure out the math")]
+ [EditorBrowsable(EditorBrowsableState.Advanced)]
+ public static SizeF GetAutoScaleSize(Font font) {
+ SizeF result;
+
+ result = new SizeF(250, 250);
+ result.Width *= font.SizeInPoints / 12;
+ result.Height *= font.SizeInPoints / 12;
+ return result;
+ }
#endregion // Public Static Methods
#region Public Instance Methods
+ public void Activate() {
+ Form active;
+
+ // The docs say activate only activates if our app is already active
+ active = ActiveForm;
+ if ((active != null) && (this != active)) {
+ XplatUI.Activate(window.Handle);
+ }
+ }
+
public void AddOwnedForm(Form ownedForm) {
owned_forms.Add(ownedForm);
}
- public void RemoveOwnedForm(Form ownedForm) {
- owned_forms.Remove(ownedForm);
- }
+ public void Close () {
+ CancelEventArgs args = new CancelEventArgs ();
+ OnClosing (args);
+ if (!args.Cancel) {
+ OnClosed (EventArgs.Empty);
+ closing = true;
+ return;
+ }
+ }
+
+ 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 DialogResult ShowDialog() {
return ShowDialog(null);
}
public DialogResult ShowDialog(IWin32Window ownerWin32) {
+ Form previous;
+
#if broken
Control owner = null;
form_parent_window.Parent = owner;
#endif
+ previous = Form.ActiveForm;
+
if (!IsHandleCreated) {
CreateControl();
}
- XplatUI.SetModal(form_parent_window.window.Handle, true);
+ XplatUI.SetModal(window.Handle, true);
Show();
+ PerformLayout();
is_modal = true;
Application.ModalRun(this);
is_modal = false;
Hide();
- XplatUI.SetModal(form_parent_window.window.Handle, false);
+ XplatUI.SetModal(window.Handle, false);
+
+ if (previous != null) {
+ // Cannot use Activate(), it has a check for the current active window...
+ XplatUI.Activate(previous.window.Handle);
+ }
return DialogResult;
}
- public void Close ()
- {
- CancelEventArgs args = new CancelEventArgs ();
- OnClosing (args);
- if (!args.Cancel) {
- OnClosed (EventArgs.Empty);
- closing = true;
- return;
- }
+ public override string ToString() {
+ return GetType().FullName.ToString() + ", Text: " + Text;
}
-
#endregion // Public Instance Methods
#region Protected Instance Methods
- protected override void CreateHandle() {
- base.CreateHandle ();
- }
-
- protected override void OnCreateControl() {
- base.OnCreateControl ();
- OnLoad(EventArgs.Empty);
+ [MonoTODO("Finish when MDI is more complete")]
+ protected void ActivateMdiChild(Form form) {
+ OnMdiChildActivate(EventArgs.Empty);
+ throw new NotImplementedException();
}
- protected override void OnHandleCreated(EventArgs e) {
- base.OnHandleCreated (e);
+ [EditorBrowsable(EditorBrowsableState.Advanced)]
+ protected override void AdjustFormScrollbars(bool displayScrollbars) {
+ base.AdjustFormScrollbars (displayScrollbars);
}
- protected override void OnHandleDestroyed(EventArgs e) {
- base.OnHandleDestroyed (e);
+ [EditorBrowsable(EditorBrowsableState.Advanced)]
+ protected void ApplyAutoScaling() {
+ // Hm, not sure what this does
}
+ protected void CenterToParent() {
+ Control ctl;
+ int w;
+ int h;
- protected override void OnResize(EventArgs e) {
- base.OnResize(e);
- }
-
- protected override bool ProcessCmdKey(ref Message msg, Keys keyData) {
- if (base.ProcessCmdKey (ref msg, keyData)) {
- return true;
+ if (Width > 0) {
+ w = Width;
+ } else {
+ w = DefaultSize.Width;
}
- // Give our menu a shot
- if (menu != null) {
- return menu.ProcessCmdKey(ref msg, keyData);
+ if (Height > 0) {
+ h = Height;
+ } else {
+ h = DefaultSize.Height;
}
- return false;
- }
-
- protected override bool ProcessDialogKey(Keys keyData) {
- if (keyData == Keys.Enter && accept_button != null) {
- accept_button.PerformClick();
- return true;
- } else if (keyData == Keys.Enter && cancel_button != null) {
- cancel_button.PerformClick();
- return true;
+ ctl = null;
+ if (parent != null) {
+ ctl = parent;
+ } else if (owner != null) {
+ ctl = owner;
}
- return base.ProcessDialogKey(keyData);
- }
- protected override bool ProcessKeyPreview(ref Message msg) {
- if (key_preview) {
- if (ProcessKeyEventArgs(ref msg)) {
- return true;
- }
+ if (owner != null) {
+ this.Location = new Point(ctl.Left + ctl.Width / 2 - w /2, ctl.Top + ctl.Height / 2 - h / 2);
}
- return base.ProcessKeyPreview (ref msg);
}
- 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;
+ protected void CenterToScreen() {
+ Size DisplaySize;
+ int w;
+ int h;
+
+ if (Width > 0) {
+ w = Width;
+ } else {
+ w = DefaultSize.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;
+ if (Height > 0) {
+ h = Height;
+ } else {
+ h = DefaultSize.Height;
}
- base.SetClientSizeCore (x, y);
+ XplatUI.GetDisplaySize(out DisplaySize);
+ this.Location = new Point(DisplaySize.Width / 2 - w / 2, DisplaySize.Height / 2 - h / 2);
}
+ [EditorBrowsable(EditorBrowsableState.Advanced)]
+ protected override Control.ControlCollection CreateControlsInstance() {
+ return base.CreateControlsInstance ();
+ }
- protected override void WndProc(ref Message m) {
- switch((Msg)m.Msg) {
- case Msg.WM_CLOSE: {
- CancelEventArgs args = new CancelEventArgs();
-
- OnClosing(args);
+ [EditorBrowsable(EditorBrowsableState.Advanced)]
+ protected override void CreateHandle() {
+ base.CreateHandle ();
+ }
- if (!args.Cancel) {
- OnClosed(EventArgs.Empty);
- closing = true;
- base.WndProc(ref m);
- break;
- }
- break;
- }
+ [EditorBrowsable(EditorBrowsableState.Advanced)]
+ protected override void DefWndProc(ref Message m) {
+ base.DefWndProc (ref m);
+ }
- default: {
- base.WndProc (ref m);
- break;
- }
- }
+ protected override void Dispose(bool disposing) {
+ base.Dispose (disposing);
}
- #endregion // Protected Instance Methods
- #region Events
+ [EditorBrowsable(EditorBrowsableState.Advanced)]
protected virtual void OnActivated(EventArgs e) {
if (Activated != null) {
Activated(this, e);
}
}
+ [EditorBrowsable(EditorBrowsableState.Advanced)]
protected virtual void OnClosed(EventArgs e) {
if (Closed != null) {
Closed(this, e);
}
}
+ [EditorBrowsable(EditorBrowsableState.Advanced)]
protected virtual void OnClosing(System.ComponentModel.CancelEventArgs e) {
if (Closing != null) {
Closing(this, e);
}
}
+ [EditorBrowsable(EditorBrowsableState.Advanced)]
+ protected override void OnCreateControl() {
+ base.OnCreateControl ();
+ if (this.ActiveControl == 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 (SelectNextControl(this, true, true, true, true) == false) {
+ Select(this);
+ }
+
+ this.is_visible = visible;
+ }
+
+ if (menu != null) {
+ XplatUI.SetMenu(window.Handle, menu.Handle);
+ }
+
+ OnLoad(EventArgs.Empty);
+
+ // Send initial location
+ OnLocationChanged(EventArgs.Empty);
+ }
+
+ [EditorBrowsable(EditorBrowsableState.Advanced)]
protected virtual void OnDeactivate(EventArgs e) {
if (Deactivate != null) {
Deactivate(this, e);
}
}
+ [EditorBrowsable(EditorBrowsableState.Advanced)]
+ protected override void OnFontChanged(EventArgs e) {
+ base.OnFontChanged (e);
+ }
+
+ [EditorBrowsable(EditorBrowsableState.Advanced)]
+ protected override void OnHandleCreated(EventArgs e) {
+ base.OnHandleCreated (e);
+ }
+
+ [EditorBrowsable(EditorBrowsableState.Advanced)]
+ protected override void OnHandleDestroyed(EventArgs e) {
+ base.OnHandleDestroyed (e);
+ }
+
+ [EditorBrowsable(EditorBrowsableState.Advanced)]
protected virtual void OnInputLanguageChanged(InputLanguageChangedEventArgs e) {
if (InputLanguageChanged!=null) {
InputLanguageChanged(this, e);
}
}
+ [EditorBrowsable(EditorBrowsableState.Advanced)]
protected virtual void OnInputLanguageChanging(InputLanguageChangingEventArgs e) {
if (InputLanguageChanging!=null) {
InputLanguageChanging(this, e);
}
}
+ [EditorBrowsable(EditorBrowsableState.Advanced)]
protected virtual void OnLoad(EventArgs e) {
if (Load != null) {
Load(this, e);
}
}
+ [EditorBrowsable(EditorBrowsableState.Advanced)]
protected virtual void OnMaximizedBoundsChanged(EventArgs e) {
if (MaximizedBoundsChanged != null) {
MaximizedBoundsChanged(this, e);
}
}
+ [EditorBrowsable(EditorBrowsableState.Advanced)]
protected virtual void OnMaximumSizeChanged(EventArgs e) {
if (MaximumSizeChanged != null) {
MaximumSizeChanged(this, e);
}
}
+ [EditorBrowsable(EditorBrowsableState.Advanced)]
protected virtual void OnMdiChildActivate(EventArgs e) {
if (MdiChildActivate != null) {
MdiChildActivate(this, e);
}
}
+ [EditorBrowsable(EditorBrowsableState.Advanced)]
protected virtual void OnMenuComplete(EventArgs e) {
if (MenuComplete != null) {
MenuComplete(this, e);
}
}
+ [EditorBrowsable(EditorBrowsableState.Advanced)]
protected virtual void OnMenuStart(EventArgs e) {
if (MenuStart != null) {
MenuStart(this, e);
}
}
+ [EditorBrowsable(EditorBrowsableState.Advanced)]
protected virtual void OnMinimumSizeChanged(EventArgs e) {
if (MinimumSizeChanged != null) {
MinimumSizeChanged(this, e);
}
}
+ [EditorBrowsable(EditorBrowsableState.Advanced)]
+ protected override void OnPaint (PaintEventArgs pevent) {
+ base.OnPaint (pevent);
+ }
+
+ [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);
+ }
+
+ [EditorBrowsable(EditorBrowsableState.Advanced)]
+ protected override void OnVisibleChanged(EventArgs e) {
+ base.OnVisibleChanged (e);
+ }
+
+ protected override bool ProcessCmdKey(ref Message msg, Keys keyData) {
+ if (base.ProcessCmdKey (ref msg, keyData)) {
+ return true;
+ }
+
+ // Give our menu a shot
+ if (menu != null) {
+ return menu.ProcessCmdKey(ref msg, keyData);
+ }
+
+ 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 && accept_button != null) {
+ 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 msg) {
+ if (key_preview) {
+ if (ProcessKeyEventArgs(ref msg)) {
+ return true;
+ }
+ }
+ return base.ProcessKeyPreview (ref msg);
+ }
+
+ protected override bool ProcessTabKey(bool forward) {
+ return SelectNextControl(ActiveControl, forward, true, true, true);
+ }
+
+ [EditorBrowsable(EditorBrowsableState.Advanced)]
+ protected override void ScaleCore(float dx, float dy) {
+ base.ScaleCore (dx, dy);
+ }
+
+ protected override void Select(bool directed, bool forward) {
+ Form parent;
+
+ if (directed) {
+ base.SelectNextControl(null, forward, true, true, true);
+ }
+
+ parent = this.ParentForm;
+ if (parent != null) {
+ parent.ActiveControl = this;
+ }
+
+ Activate();
+ }
+
+ [EditorBrowsable(EditorBrowsableState.Advanced)]
+ protected override void SetBoundsCore(int x, int y, int width, int height, BoundsSpecified specified) {
+ base.SetBoundsCore (x, y, width, height, specified);
+ }
+
+ [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;
+ }
+
+ base.SetClientSizeCore (x, y);
+ }
+
+ [EditorBrowsable(EditorBrowsableState.Advanced)]
+ protected override void SetVisibleCore(bool value) {
+ base.SetVisibleCore (value);
+ }
+
+ protected override void UpdateDefaultButton() {
+ base.UpdateDefaultButton ();
+ }
+
+ [EditorBrowsable(EditorBrowsableState.Advanced)]
+ protected override void WndProc(ref Message m) {
+
+ if (IsMdiChild && mdi_child_context.HandleMessage (ref m)) {
+ return;
+ }
+
+ switch((Msg)m.Msg) {
+ case Msg.WM_CLOSE: {
+ CancelEventArgs args = new CancelEventArgs();
+
+ OnClosing(args);
+
+ if (!args.Cancel) {
+ OnClosed(EventArgs.Empty);
+ closing = true;
+ base.WndProc(ref m);
+ break;
+ }
+ break;
+ }
+
+ case Msg.WM_ACTIVATE: {
+ if (m.WParam != (IntPtr)WindowActiveFlags.WA_INACTIVE) {
+ OnActivated(EventArgs.Empty);
+ } else {
+ OnDeactivate(EventArgs.Empty);
+ }
+ return;
+ }
+
+ case Msg.WM_KILLFOCUS: {
+ base.WndProc(ref m);
+ return;
+ }
+
+ case Msg.WM_SETFOCUS: {
+#if not
+ if (this.ActiveControl != null) {
+ ActiveControl.Focus();
+ }
+#endif
+ base.WndProc(ref m);
+ return;
+ }
+
+ // Menu drawing
+ case Msg.WM_NCLBUTTONDOWN: {
+ if (this.menu != null) {
+ int x = LowOrder ((int) m.LParam.ToInt32 ()) ;
+ int y = HighOrder ((int) m.LParam.ToInt32 ());
+ menu.OnMouseDown(this, new MouseEventArgs (FromParamToMouseButtons ((int) m.WParam.ToInt32()), mouse_clicks, x, y, 0));
+ }
+ base.WndProc(ref m);
+ return;
+ }
+
+ case Msg.WM_NCMOUSEMOVE: {
+ if (this.menu != null) {
+ menu.OnMouseMove(this, new MouseEventArgs (FromParamToMouseButtons ((int) m.WParam.ToInt32()),
+ mouse_clicks, LowOrder ((int) m.LParam.ToInt32 ()), HighOrder ((int) m.LParam.ToInt32 ()), 0));
+ }
+ base.WndProc(ref m);
+ return;
+ }
+
+ case Msg.WM_NCPAINT: {
+ if (this.menu != null) {
+ Point pnt = XplatUI.GetMenuOrigin(window.Handle);
+ MenuAPI.DrawMenuBar (menu.Handle, new Rectangle (pnt.X, pnt.Y, ClientSize.Width, 0));
+ }
+
+ base.WndProc(ref m);
+ return;
+ }
+
+ // This message is only received under Win32
+ case Msg.WM_NCCALCSIZE: {
+ XplatUIWin32.NCCALCSIZE_PARAMS ncp;
+
+ if ((menu != 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, menu.menu_handle, ClientSize.Width);
+ Marshal.StructureToPtr(ncp, m.LParam, true);
+ }
+ DefWndProc(ref m);
+ break;
+ }
+
+ case Msg.WM_GETMINMAXINFO: {
+ XplatUIWin32.MINMAXINFO mmi;
+
+ if (m.LParam != IntPtr.Zero) {
+ mmi = (XplatUIWin32.MINMAXINFO)Marshal.PtrToStructure(m.LParam, typeof(XplatUIWin32.MINMAXINFO));
+ default_maximized_bounds = new Rectangle(mmi.ptMaxPosition.x, mmi.ptMaxPosition.y, mmi.ptMaxSize.x, mmi.ptMaxSize.y);
+ if (maximized_bounds != Rectangle.Empty) {
+ mmi.ptMaxSize.x = maximized_bounds.Width;
+ mmi.ptMaxSize.y = maximized_bounds.Height;
+ }
+
+ Marshal.StructureToPtr(mmi, m.LParam, false);
+ }
+ break;
+ }
+
+ default: {
+ base.WndProc (ref m);
+ break;
+ }
+ }
+ }
+ #endregion // Protected Instance Methods
+
+ #region Events
public event EventHandler Activated;
public event EventHandler Closed;
public event CancelEventHandler Closing;
public event EventHandler MenuComplete;
public event EventHandler MenuStart;
public event EventHandler MinimumSizeChanged;
+
+ [Browsable(false)]
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ public new event EventHandler TabIndexChanged;
#endregion // Events
}
}
projects / mono.git / blobdiff