[DesignTimeVisible(false)]
[Designer("System.Windows.Forms.Design.FormDocumentDesigner, " + Consts.AssemblySystem_Design, typeof(IRootDesigner))]
[DefaultEvent("Load")]
+#if NET_2_0
+ [ClassInterface (ClassInterfaceType.AutoDispatch)]
+ [InitializationEvent ("Load")]
+ [ComVisible (true)]
+#endif
[ToolboxItem(false)]
public class Form : ContainerControl {
#region Local Variables
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 bool is_changing_visible_state;
internal bool has_been_visible;
+#if NET_2_0
+ private MenuStrip main_menu_strip;
+ private bool show_icon = true;
+ private bool shown_raised; // The shown event is only raised once
+#endif
#endregion // Local Variables
#region Private & Internal Methods
}
}
+ // 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)
+ {
+ CancelEventArgs cea = new CancelEventArgs ();
+ this.OnClosing (cea);
+
+#if NET_2_0
+ FormClosingEventArgs fcea = new FormClosingEventArgs (reason, cea.Cancel);
+ this.OnFormClosing (fcea);
+ return fcea.Cancel;
+#else
+ return cea.Cancel;
+#endif
+ }
+
private void SelectActiveControl ()
{
- if (this.IsMdiContainer)
+ if (this.IsMdiContainer) {
+ mdi_container.SendFocusToActiveChild ();
return;
+ }
if (this.ActiveControl == null) {
bool visible;
Select (ActiveControl);
}
}
+
+ 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;
+ }
+ }
+
#endregion // Private & Internal Methods
#region Public Classes
+#if NET_2_0
+ [ComVisible (false)]
+#endif
public new class ControlCollection : Control.ControlCollection {
Form form_owner;
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;
}
}
+#if NET_2_0
+ [Browsable (false)]
+ [EditorBrowsable (EditorBrowsableState.Never)]
+ [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
+ [Obsolete ("This property has been deprecated in favor of AutoScaleMode.")]
+#else
[DefaultValue(true)]
+#endif
[MWFCategory("Layout")]
public bool AutoScale {
get {
}
}
+#if NET_2_0
+ [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
+ [EditorBrowsable(EditorBrowsableState.Never)]
+#else
+ [EditorBrowsable(EditorBrowsableState.Advanced)]
+#endif
[Localizable(true)]
[Browsable(false)]
- [EditorBrowsable(EditorBrowsableState.Advanced)]
public virtual Size AutoScaleBaseSize {
get {
return autoscale_base_size;
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 Size ClientSize {
- get {
- return base.ClientSize;
- }
-
- set {
- base.ClientSize = value;
- }
+ public new Size ClientSize {
+ get { return base.ClientSize; }
+ set { base.ClientSize = value; }
}
[DefaultValue(true)]
}
UpdateStyles();
+
+ if (this.Visible)
+ this.Size = SizeFromClientSize (this.ClientSize);
+ else
+ XplatUI.InvalidateNC (this.Handle);
}
}
}
}
+#if NET_2_0
+ [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; }
+ }
+#endif
+
[DefaultValue(true)]
[MWFCategory("Window Style")]
public bool MaximizeBox {
[Localizable(true)]
[RefreshProperties(RefreshProperties.Repaint)]
[MWFCategory("Layout")]
- public Size MaximumSize {
+ public
+#if NET_2_0
+ override
+#endif
+ Size MaximumSize {
get {
return maximum_size;
}
set {
if (value != null && !value.IsMdiContainer)
- throw new ArgumentException ();
+ 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.original_order.Remove (this);
mdi_parent.MdiContainer.Controls.Remove (this);
}
mdi_parent = value;
window_manager = new MdiWindowManager (this,
mdi_parent.MdiContainer);
- mdi_parent.MdiContainer.original_order.Add (this);
mdi_parent.MdiContainer.Controls.Add (this);
+ mdi_parent.MdiContainer.Controls.SetChildIndex (this, 0);
RecreateHandle ();
get { return window_manager; }
}
+#if NET_2_0
+ [Browsable (false)]
+ [TypeConverter (typeof (ReferenceConverter))]
+#endif
[DefaultValue(null)]
[MWFCategory("Window Style")]
public MainMenu Menu {
}
}
+#if !NET_2_0
[DefaultValue("{Width=0, Height=0}")]
+#endif
[Localizable(true)]
[RefreshProperties(RefreshProperties.Repaint)]
[MWFCategory("Layout")]
- public Size MinimumSize {
+ public
+#if NET_2_0
+ override
+#endif
+ Size MinimumSize {
get {
return minimum_size;
}
}
}
+#if NET_2_0
+ [DefaultValue (true)]
+ public bool ShowIcon {
+ get { return this.show_icon; }
+ set {
+ if (this.show_icon != value ) {
+ this.show_icon = value;
+ UpdateStyles ();
+
+ XplatUI.SetIcon (this.Handle, value == true ? this.Icon : null);
+ XplatUI.InvalidateNC (this.Handle);
+ }
+ }
+ }
+#endif
+
[DefaultValue(true)]
[MWFCategory("Window Style")]
public bool ShowInTaskbar {
}
}
+ // new property so we can set the DesignerSerializationVisibility
[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
[Localizable(false)]
- public Size Size {
- get {
- return base.Size;
- }
-
- set {
- base.Size = value;
- }
+ public new Size Size {
+ get { return base.Size; }
+ set { base.Size = value; }
}
- [MonoTODO("Trigger something when GripStyle is set")]
[DefaultValue(SizeGripStyle.Auto)]
[MWFCategory("Window Style")]
public SizeGripStyle SizeGripStyle {
set {
size_grip_style = value;
+ UpdateSizeGripVisible ();
}
}
}
}
+ // new property so we can set EditorBrowsable to never
[Browsable(false)]
[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
[EditorBrowsable(EditorBrowsableState.Never)]
- public int TabIndex {
- get {
- return base.TabIndex;
- }
+ public new int TabIndex {
+ get { return base.TabIndex; }
+ set { base.TabIndex = value; }
+ }
- set {
- base.TabIndex = value;
- }
+#if NET_2_0
+ [Browsable(false)]
+ [DefaultValue (true)]
+ [DispIdAttribute (-516)]
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ public new bool TabStop {
+ get { return base.TabStop; }
+ set { base.TabStop = value; }
}
+#endif
[Browsable(false)]
[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
cp.Style = (int)(WindowStyles.WS_CLIPCHILDREN | WindowStyles.WS_CLIPSIBLINGS);
+ if (Parent != null) {
+ 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.Style |= (int)WindowStyles.WS_SYSMENU;
}
+#if NET_2_0
+ if (!this.show_icon) {
+ cp.ExStyle |= (int)WindowExStyles.WS_EX_DLGMODALFRAME;
+ }
+#endif
+
if (HelpButton && !MaximizeBox && !MinimizeBox) {
cp.ExStyle |= (int)WindowExStyles.WS_EX_CONTEXTHELP;
}
if (Visible)
cp.Style |= (int)WindowStyles.WS_VISIBLE;
- if (Opacity < 1.0 || TransparencyKey != Color.Empty) {
+ if (opacity < 1.0 || TransparencyKey != Color.Empty) {
cp.ExStyle |= (int)WindowExStyles.WS_EX_LAYERED;
}
}
}
}
+#if NET_2_0
+ [MonoTODO ("Implemented for Win32, needs X11 implementation")]
+ protected virtual bool ShowWithoutActivation {
+ get { return false; }
+ }
+#endif
#endregion // Protected Instance Properties
#region Public Static Methods
+#if NET_2_0
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ [Obsolete ("This method has been deprecated. Use AutoScaleDimensions instead")]
+#else
[EditorBrowsable(EditorBrowsableState.Advanced)]
+#endif
public static SizeF GetAutoScaleSize (Font font)
{
return XplatUI.GetAutoScaleSize(font);
return new SizeF (width, font.Height);
}
- public void Activate() {
+ public void Activate ()
+ {
Form active;
// The docs say activate only activates if our app is already active
if (IsHandleCreated) {
if (IsMdiChild) {
MdiParent.ActivateMdiChild (this);
+ } else if (IsMdiContainer) {
+ mdi_container.SendFocusToActiveChild ();
} else {
active = ActiveForm;
if ((active != null) && (this != active)) {
if (!is_visible)
return;
-#if NET_2_0
- FormClosingEventArgs ce = new FormClosingEventArgs (CloseReason.FormOwnerClosing, false);
- OnFormClosing (ce);
- if (ce.Cancel)
- return;
-#endif
XplatUI.SendMessage(this.Handle, Msg.WM_CLOSE, IntPtr.Zero, IntPtr.Zero);
}
DesktopLocation = new Point(x, y);
}
+#if NET_2_0
+ public void Show (IWin32Window owner)
+ {
+ if (owner == null)
+ this.Owner = null;
+ else
+ this.Owner = Control.FromHandle (owner.Handle).TopLevelControl as Form;
+
+ if (owner == this)
+ throw new InvalidOperationException ("The 'owner' cannot be the form being shown.");
+
+ base.Show ();
+ }
+#endif
+
public DialogResult ShowDialog() {
return ShowDialog(this.owner);
}
}
if (owner == this) {
- throw new InvalidOperationException("The 'ownerWin32' cannot be the form being shown.");
+ 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.");
+ throw new InvalidOperationException ("The form is already displayed as a modal dialog.");
}
if (Visible) {
- throw new InvalidOperationException("Already visible forms cannot be displayed as a modal dialog. Set the Visible property to 'false' prior to calling Form.ShowDialog.");
+ 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("Cannot display a disabled form as modal dialog.");
+ 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 (TopLevelControl != this) {
- throw new InvalidOperationException("Can only display TopLevel forms as modal dialog.");
+ 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 broken
base.AdjustFormScrollbars (displayScrollbars);
}
+#if NET_2_0
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ [Obsolete ("This method has been deprecated")] // XXX what to use instead?
+#else
[EditorBrowsable(EditorBrowsableState.Advanced)]
+#endif
protected void ApplyAutoScaling()
{
SizeF current_size_f = GetAutoScaleSize (DeviceContext, Font);
}
ctl = null;
- if (parent != null) {
- ctl = parent;
+ if (Parent != null) {
+ ctl = Parent;
} else if (owner != null) {
ctl = owner;
}
protected override void CreateHandle() {
base.CreateHandle ();
+ Application.AddForm (this);
+
UpdateBounds();
if ((XplatUI.SupportsTransparency() & TransparencySupport.Set) != 0) {
}
}
+ if (this.ShowWithoutActivation)
+ Hwnd.ObjectFromHandle (this.Handle).no_activate = true;
+
XplatUI.SetWindowMinMax(window.Handle, maximized_bounds, minimum_size, maximum_size);
if ((FormBorderStyle != FormBorderStyle.FixedDialog) && (icon != null)) {
XplatUI.SetIcon(window.Handle, icon);
XplatUI.SetTopmost(owned_forms[i].window.Handle, window.Handle, true);
}
- if (window_manager != null && window_state != FormWindowState.Normal) {
- window_manager.SetWindowState (FormWindowState.Normal, window_state);
+ if (window_manager != null) {
+ if (window_state != FormWindowState.Normal) {
+ window_manager.SetWindowState (FormWindowState.Normal, window_state);
+ }
+ XplatUI.RequestNCRecalc (window.Handle);
}
}
owned_forms.Clear ();
base.Dispose (disposing);
+
+ Application.RemoveForm (this);
}
[EditorBrowsable(EditorBrowsableState.Advanced)]
protected virtual void OnActivated(EventArgs e)
{
- if (is_loaded)
- SelectActiveControl ();
-
EventHandler eh = (EventHandler)(Events [ActivatedEvent]);
if (eh != null)
eh (this, e);
eh (this, e);
}
- [EditorBrowsable(EditorBrowsableState.Advanced)]
+ // 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)
OnLoad(EventArgs.Empty);
- SelectActiveControl ();
-
// Send initial location
OnLocationChanged(EventArgs.Empty);
[EditorBrowsable(EditorBrowsableState.Advanced)]
protected override void OnPaint (PaintEventArgs pevent) {
base.OnPaint (pevent);
+
+ if (size_grip != null) {
+ size_grip.HandlePaint (this, pevent);
+ }
}
[EditorBrowsable(EditorBrowsableState.Advanced)]
protected override void OnResize(EventArgs e) {
base.OnResize(e);
- if (this.IsMdiChild && ParentForm != null) {
- ParentForm.PerformLayout();
- ParentForm.Size = ParentForm.Size;
- }
}
[EditorBrowsable(EditorBrowsableState.Advanced)]
return ActiveMenu.ProcessCmdKey(ref msg, keyData);
}
+ if (IsMdiChild) {
+ switch (keyData)
+ {
+ case Keys.Control | Keys.F4:
+ case Keys.Control | Keys.Shift | Keys.F4:
+ Close ();
+ return true;
+ case Keys.Control | Keys.Tab:
+ case Keys.Control | Keys.F6:
+ MdiParent.MdiContainer.ActivateNextChild ();
+ return true;
+ case Keys.Control | Keys.Shift | Keys.Tab:
+ case Keys.Control | Keys.Shift | Keys.F6:
+ MdiParent.MdiContainer.ActivatePreviousChild ();
+ return true;
+ }
+ }
+
return false;
}
return SelectNextControl(ActiveControl, forward, true, true, true);
}
+#if NET_2_0
+ [EditorBrowsable(EditorBrowsableState.Never)]
+#else
[EditorBrowsable(EditorBrowsableState.Advanced)]
+#endif
protected override void ScaleCore(float dx, float dy) {
try {
SuspendLayout();
}
/* Now scale our children */
- Control [] controls = child_controls.GetAllControls ();
+ Control [] controls = Controls.GetAllControls ();
for (int i=0; i < controls.Length; i++) {
controls[i].Scale(dx, dy);
}
has_been_visible = value || has_been_visible;
base.SetVisibleCore (value);
is_changing_visible_state = false;
+
+#if NET_2_0
+ // 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;
+ }
+#endif
}
protected override void 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.HandleMessage (ref m)) {
return;
switch((Msg)m.Msg) {
case Msg.WM_DESTROY: {
base.WndProc(ref m);
- if (!is_recreating) {
+ if (!RecreatingHandle) {
this.closing = true;
}
return;
return;
}
- CancelEventArgs args = new CancelEventArgs ();
-
if (mdi_container != null) {
foreach (Form mdi_child in mdi_container.MdiChildren) {
- mdi_child.OnClosing (args);
+ mdi_child.FireClosingEvents (CloseReason.MdiFormClosing);
}
}
if (!is_modal) {
- OnClosing (args);
- if (!args.Cancel) {
+ if (!FireClosingEvents (CloseReason.UserClosing)) {
OnClosed (EventArgs.Empty);
+#if NET_2_0
+ OnFormClosed (new FormClosedEventArgs (CloseReason.UserClosing));
+#endif
closing = true;
+ Dispose ();
+ }
+ else {
+ closing = false;
}
- Dispose ();
} else {
- OnClosing (args);
- if (args.Cancel) {
+ if (FireClosingEvents (CloseReason.UserClosing)) {
DialogResult = DialogResult.None;
closing = false;
- } else {
+ }
+ else {
OnClosed (EventArgs.Empty);
+#if NET_2_0
+ OnFormClosed (new FormClosedEventArgs (CloseReason.UserClosing));
+#endif
closing = true;
Hide ();
}
case Msg.WM_ACTIVATE: {
if (m.WParam != (IntPtr)WindowActiveFlags.WA_INACTIVE) {
+ if (is_loaded) {
+ SelectActiveControl ();
+
+ if (ActiveControl != null && !ActiveControl.Focused)
+ SendControlFocus (ActiveControl);
+ }
+
OnActivated(EventArgs.Empty);
} else {
OnDeactivate(EventArgs.Empty);
ActiveControl.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);
return;
}
// Menu drawing
- case Msg.WM_NCLBUTTONDOWN: {
+ case Msg.WM_NCHITTEST: {
+ 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);
+ return;
+ }
+
+ case Msg.WM_NCLBUTTONDOWN: {
if (XplatUI.IsEnabled (Handle) && ActiveMenu != null) {
ActiveMenu.OnMouseDown(this, new MouseEventArgs (FromParamToMouseButtons ((int) m.WParam.ToInt32()), mouse_clicks, Control.MousePosition.X, Control.MousePosition.Y, 0));
}
base.WndProc(ref m);
return;
}
- case Msg.WM_NCLBUTTONUP: {
+
+ case Msg.WM_NCLBUTTONUP: {
if (ActiveMaximizedMdiChild != null) {
ActiveMaximizedMdiChild.HandleMenuMouseUp (ActiveMenu,
LowOrder ((int)m.LParam.ToInt32 ()),
}
if (ActiveMaximizedMdiChild != null) {
+ XplatUI.RequestAdditionalWM_NCMessages (Handle, false, true);
ActiveMaximizedMdiChild.HandleMenuMouseMove (ActiveMenu,
LowOrder ((int)m.LParam.ToInt32 ()),
HighOrder ((int)m.LParam.ToInt32 ()));
ncp = (XplatUIWin32.NCCALCSIZE_PARAMS)Marshal.PtrToStructure(m.LParam, typeof(XplatUIWin32.NCCALCSIZE_PARAMS));
// Adjust for menu
- ncp.rgrc1.top += ThemeEngine.Current.CalcMenuBarSize (DeviceContext, ActiveMenu, ncp.rgrc1.right - ncp.rgrc1.left);
+ ncp.rgrc1.top += ThemeEngine.Current.CalcMenuBarSize (DeviceContext, ActiveMenu, ClientSize.Width);
Marshal.StructureToPtr(ncp, m.LParam, true);
}
DefWndProc(ref m);
active_tracker.OnMouseDown(new MouseEventArgs (args.Button, args.Clicks, Control.MousePosition.X, Control.MousePosition.Y, args.Delta));
return;
}
- base.WndProc(ref m);
+#if NET_2_0
+ ToolStripManager.FireAppClicked ();
+#endif
+ base.WndProc (ref m);
return;
}
}
#endregion // Protected Instance Methods
+ 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;
remove { Events.RemoveHandler (ActivatedEvent, value); }
}
+#if NET_2_0
+ [Browsable (false)]
+ [EditorBrowsable (EditorBrowsableState.Never)]
+#endif
public event EventHandler Closed {
add { Events.AddHandler (ClosedEvent, value); }
remove { Events.RemoveHandler (ClosedEvent, value); }
}
+#if NET_2_0
+ [Browsable (false)]
+ [EditorBrowsable (EditorBrowsableState.Never)]
+#endif
public event CancelEventHandler Closing {
add { Events.AddHandler (ClosingEvent, value); }
remove { Events.RemoveHandler (ClosingEvent, value); }
remove { Events.RemoveHandler (MdiChildActivateEvent, value); }
}
+#if NET_2_0
+ [Browsable (false)]
+#endif
public event EventHandler MenuComplete {
add { Events.AddHandler (MenuCompleteEvent, value); }
remove { Events.RemoveHandler (MenuCompleteEvent, value); }
}
+#if NET_2_0
+ [Browsable (false)]
+#endif
public event EventHandler MenuStart {
add { Events.AddHandler (MenuStartEvent, value); }
remove { Events.RemoveHandler (MenuStartEvent, value); }
#endregion // Events
#if NET_2_0
+ [SettingsBindable (true)]
public override string Text {
get {
return base.Text;
}
}
+ [SettingsBindable (true)]
public new Point Location {
get {
return base.Location;
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); }
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) {
+ FormClosedEventHandler eh = (FormClosedEventHandler)(Events[FormClosedEvent]);
+ if (eh != null)
+ eh (this, e);
+ }
+ // 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 ("Not hooked up to event")]
+ [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);
+ }
+
+ [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 OnShown (EventArgs e)
+ {
+ EventHandler eh = (EventHandler) (Events [ShownEvent]);
+ if (eh != null)
+ eh (this, e);
+ }
#endif
}
}
projects / mono.git / blobdiff