mcs/class/Managed.Windows.Forms/System.Windows.Forms/Form.cs

   1 // Permission is hereby granted, free of charge, to any person obtaining
   2 // a copy of this software and associated documentation files (the
   3 // "Software"), to deal in the Software without restriction, including
   4 // without limitation the rights to use, copy, modify, merge, publish,
   5 // distribute, sublicense, and/or sell copies of the Software, and to
   6 // permit persons to whom the Software is furnished to do so, subject to
   7 // the following conditions:
   8 //
   9 // The above copyright notice and this permission notice shall be
  10 // included in all copies or substantial portions of the Software.
  11 //
  12 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  13 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  14 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  15 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  16 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  17 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  18 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  19 //
  20 // Copyright (c) 2004-2006 Novell, Inc.
  21 //
  22 // Authors:
  23 //      Peter Bartok    pbartok@novell.com
  24 //
  25
  26 // NOT COMPLETE
  27
  28 using System;
  29 using System.Drawing;
  30 using System.ComponentModel;
  31 using System.ComponentModel.Design;
  32 using System.ComponentModel.Design.Serialization;
  33 using System.Collections;
  34 using System.Runtime.InteropServices;
  35 using System.Threading;
  36
  37 namespace System.Windows.Forms {
  38         [DesignerCategory("Form")]
  39         [DesignTimeVisible(false)]
  40         [Designer("System.Windows.Forms.Design.FormDocumentDesigner, " + Consts.AssemblySystem_Design, typeof(IRootDesigner))]
  41         [DefaultEvent("Load")]
  42         [ToolboxItem(false)]
  43         public class Form : ContainerControl {
  44                 #region Local Variables
  45                 internal static Form            active_form;
  46                 internal bool                   closing;
  47                 FormBorderStyle                 form_border_style;
  48                 private bool                    autoscale;
  49                 private Size                    clientsize_set;
  50                 private Size                    autoscale_base_size;
  51                 private bool                    allow_transparency;
  52                 private static Icon             default_icon;
  53                 internal bool                   is_modal;
  54                 internal FormWindowState        window_state;
  55                 private bool                    control_box;
  56                 private bool                    minimize_box;
  57                 private bool                    maximize_box;
  58                 private bool                    help_button;
  59                 private bool                    show_in_taskbar;
  60                 private bool                    topmost;
  61                 private IButtonControl          accept_button;
  62                 private IButtonControl          cancel_button;
  63                 private DialogResult            dialog_result;
  64                 private FormStartPosition       start_position;
  65                 private Form                    owner;
  66                 private Form.ControlCollection  owned_forms;
  67                 private MdiClient               mdi_container;
  68                 internal InternalWindowManager  window_manager;
  69                 private Form                    mdi_parent;
  70                 private bool                    key_preview;
  71                 private MainMenu                menu;
  72                 private Icon                    icon;
  73                 private Size                    maximum_size;
  74                 private Size                    minimum_size;
  75                 private SizeGripStyle           size_grip_style;
  76                 private Rectangle               maximized_bounds;
  77                 private Rectangle               default_maximized_bounds;
  78                 private double                  opacity;
  79                 internal ApplicationContext     context;
  80                 Color                           transparency_key;
  81                 internal MenuTracker            active_tracker;
  82
  83                 #endregion      // Local Variables
  84
  85                 #region Private & Internal Methods
  86                 static Form ()
  87                 {
  88                         default_icon = (Icon)Locale.GetResource("mono.ico");
  89                 }
  90
  91                 // warning: this is only hooked up when an mdi container is created.
  92                 private void ControlAddedHandler (object sender, ControlEventArgs e)
  93                 {
  94                         if (mdi_container != null) {
  95                                 Console.WriteLine ("SENDING TO BACK");
  96                                 mdi_container.SendToBack ();
  97                         }
  98                 }
  99                 #endregion      // Private & Internal Methods
 100
 101                 #region Public Classes
 102                 public new class ControlCollection : Control.ControlCollection {
 103                         Form    form_owner;
 104
 105                         public ControlCollection(Form owner) : base(owner) {
 106                                 this.form_owner = owner;
 107                         }
 108
 109                         public override void Add(Control value) {
 110                                 if (Contains (value))
 111                                         return;
 112                                 AddToList (value);
 113                                 ((Form)value).owner=(Form)owner;
 114                         }
 115
 116                         public override void Remove(Control value) {
 117                                 ((Form)value).owner = null;
 118                                 base.Remove (value);
 119                         }
 120                 }
 121                 #endregion      // Public Classes
 122
 123                 #region Public Constructor & Destructor
 124                 public Form ()
 125                 {
 126                         SizeF current_scale = GetAutoScaleSize (DeviceContext, Font);
 127
 128                         autoscale = true;
 129                         autoscale_base_size = new Size ((int)current_scale.Width, (int) current_scale.Height);
 130                         allow_transparency = false;
 131                         closing = false;
 132                         is_modal = false;
 133                         dialog_result = DialogResult.None;
 134                         start_position = FormStartPosition.WindowsDefaultLocation;
 135                         form_border_style = FormBorderStyle.Sizable;
 136                         window_state = FormWindowState.Normal;
 137                         key_preview = false;
 138                         opacity = 1D;
 139                         menu = null;
 140                         icon = default_icon;
 141                         minimum_size = Size.Empty;
 142                         maximum_size = Size.Empty;
 143                         clientsize_set = Size.Empty;
 144                         control_box = true;
 145                         minimize_box = true;
 146                         maximize_box = true;
 147                         help_button = false;
 148                         show_in_taskbar = true;
 149                         ime_mode = ImeMode.NoControl;
 150                         is_visible = false;
 151                         is_toplevel = true;
 152                         size_grip_style = SizeGripStyle.Auto;
 153                         maximized_bounds = Rectangle.Empty;
 154                         default_maximized_bounds = Rectangle.Empty;
 155                         owned_forms = new Form.ControlCollection(this);
 156                         transparency_key = Color.Empty;
 157                 }
 158                 #endregion      // Public Constructor & Destructor
 159
 160                 #region Public Static Properties
 161
 162                 public static Form ActiveForm {
 163                         get {
 164                                 Control active;
 165
 166                                 active = FromHandle(XplatUI.GetActive());
 167
 168                                 if (active != null) {
 169                                         if ( !(active is Form)) {
 170                                                 Control parent;
 171
 172                                                 parent = active.Parent;
 173                                                 while (parent != null) {
 174                                                         if (parent is Form) {
 175                                                                 return (Form)parent;
 176                                                         }
 177                                                         parent = parent.Parent;
 178                                                 }
 179                                         } else {
 180                                                 return (Form)active;
 181                                         }
 182                                 }
 183                                 return null;
 184                         }
 185                 }
 186
 187                 #endregion      // Public Static Properties
 188
 189                 #region Public Instance Properties
 190                 [DefaultValue(null)]
 191                 public IButtonControl AcceptButton {
 192                         get {
 193                                 return accept_button;
 194                         }
 195
 196                         set {
 197                                 accept_button = value;
 198                                 CheckAcceptButton();
 199                         }
 200                 }
 201
 202                 [Browsable(false)]
 203                 [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
 204                 public bool AllowTransparency {
 205                         get {
 206                                 return allow_transparency;
 207                         }
 208
 209                         set {
 210                                 if (value == allow_transparency) {
 211                                         return;
 212                                 }
 213
 214                                 if (XplatUI.SupportsTransparency()) {
 215                                         allow_transparency = value;
 216
 217                                         if (value) {
 218                                                 if (IsHandleCreated) {
 219                                                         XplatUI.SetWindowTransparency(Handle, Opacity, TransparencyKey);
 220                                                 }
 221                                         } else {
 222                                                 UpdateStyles(); // Remove the WS_EX_LAYERED style
 223                                         }
 224                                 }
 225                         }
 226                 }
 227
 228                 [DefaultValue(true)]
 229                 [MWFCategory("Layout")]
 230                 public bool AutoScale {
 231                         get {
 232                                 return autoscale;
 233                         }
 234
 235                         set {
 236                                 autoscale = value;
 237                         }
 238                 }
 239
 240                 [Localizable(true)]
 241                 [Browsable(false)]
 242                 [EditorBrowsable(EditorBrowsableState.Advanced)]
 243                 public virtual Size AutoScaleBaseSize {
 244                         get {
 245                                 return autoscale_base_size;
 246                         }
 247
 248                         set {
 249                                 autoscale_base_size = value;
 250                         }
 251                 }
 252
 253                 [Localizable(true)]
 254                 public override bool AutoScroll {
 255                         get {
 256                                 return base.AutoScroll;
 257                         }
 258                         set {
 259                                 base.AutoScroll = value;
 260                         }
 261                 }
 262
 263                 public override Color BackColor {
 264                         get {
 265                                 return base.BackColor;
 266                         }
 267                         set {
 268                                 base.BackColor = value;
 269                         }
 270                 }
 271
 272                 [DefaultValue(null)]
 273                 public IButtonControl CancelButton {
 274                         get {
 275                                 return cancel_button;
 276                         }
 277
 278                         set {
 279                                 cancel_button = value;
 280                         }
 281                 }
 282
 283                 [DesignerSerializationVisibility(DesignerSerializationVisibility.Visible)]
 284                 [Localizable(true)]
 285                 public Size ClientSize {
 286                         get {
 287                                 return base.ClientSize;
 288                         }
 289
 290                         set {
 291                                 base.ClientSize = value;
 292                         }
 293                 }
 294
 295                 [DefaultValue(true)]
 296                 [MWFCategory("Window Style")]
 297                 public bool ControlBox {
 298                         get {
 299                                 return control_box;
 300                         }
 301
 302                         set {
 303                                 if (control_box != value) {
 304                                         control_box = value;
 305                                         UpdateStyles();
 306                                 }
 307                         }
 308                 }
 309
 310                 [Browsable(false)]
 311                 [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
 312                 public Rectangle DesktopBounds {
 313                         get {
 314                                 return new Rectangle(Location, Size);
 315                         }
 316
 317                         set {
 318                                 Bounds = value;
 319                         }
 320                 }
 321
 322                 [Browsable(false)]
 323                 [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
 324                 public Point DesktopLocation {
 325                         get {
 326                                 return Location;
 327                         }
 328
 329                         set {
 330                                 Location = value;
 331                         }
 332                 }
 333
 334                 [Browsable(false)]
 335                 [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
 336                 public DialogResult DialogResult {
 337                         get {
 338                                 return dialog_result;
 339                         }
 340
 341                         set {
 342                                 if (value < DialogResult.None || value > DialogResult.No)
 343                                         throw new InvalidEnumArgumentException ("value", (int) value,
 344                                                         typeof (DialogResult));
 345
 346                                 dialog_result = value;
 347                                 if (is_modal) {
 348                                         closing = true;
 349                                 }
 350                         }
 351                 }
 352
 353                 [DefaultValue(FormBorderStyle.Sizable)]
 354                 [DispId(-504)]
 355                 [MWFCategory("Appearance")]
 356                 public FormBorderStyle FormBorderStyle {
 357                         get {
 358                                 return form_border_style;
 359                         }
 360                         set {
 361                                 form_border_style = value;
 362
 363                                 if (window_manager == null) {
 364                                         if (IsHandleCreated) {
 365                                                 XplatUI.SetBorderStyle(window.Handle, form_border_style);
 366                                         }
 367                                 } else {
 368                                         window_manager.UpdateBorderStyle (value);
 369                                 }
 370
 371                                 UpdateStyles();
 372                         }
 373                 }
 374
 375                 [DefaultValue(false)]
 376                 [MWFCategory("Window Style")]
 377                 public bool HelpButton {
 378                         get {
 379                                 return help_button;
 380                         }
 381
 382                         set {
 383                                 if (help_button != value) {
 384                                         help_button = value;
 385                                         UpdateStyles();
 386                                 }
 387                         }
 388                 }
 389
 390                 [Localizable(true)]
 391                 [AmbientValue(null)]
 392                 [MWFCategory("Window Style")]
 393                 public Icon Icon {
 394                         get {
 395                                 return icon;
 396                         }
 397
 398                         set {
 399                                 if (icon != value) {
 400                                         icon = value;
 401
 402                                         if (IsHandleCreated) {
 403                                                 XplatUI.SetIcon(Handle, icon == null ? default_icon : icon);
 404                                         }
 405                                 }
 406                         }
 407                 }
 408
 409                 [Browsable(false)]
 410                 [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
 411                 public bool IsMdiChild {
 412                         get {
 413                                 return mdi_parent != null;
 414                         }
 415                 }
 416
 417                 [DefaultValue(false)]
 418                 [MWFCategory("Window Style")]
 419                 public bool IsMdiContainer {
 420                         get {
 421                                 return mdi_container != null;
 422                         }
 423
 424                         set {
 425                                 if (value && mdi_container == null) {
 426                                         mdi_container = new MdiClient ();
 427                                         Controls.Add(mdi_container);
 428                                         ControlAdded += new ControlEventHandler (ControlAddedHandler);
 429                                         mdi_container.SendToBack ();
 430                                 } else if (!value && mdi_container != null) {
 431                                         Controls.Remove(mdi_container);
 432                                         mdi_container = null;
 433                                 }
 434                         }
 435                 }
 436
 437                 [Browsable(false)]
 438                 [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
 439                 public Form ActiveMdiChild {
 440                         get {
 441                                 if (!IsMdiContainer)
 442                                         return null;
 443                                 return (Form) mdi_container.ActiveMdiChild;
 444                         }
 445                 }
 446
 447                 [Browsable(false)]
 448                 [EditorBrowsable(EditorBrowsableState.Advanced)]
 449                 public bool IsRestrictedWindow {
 450                         get {
 451                                 return false;
 452                         }
 453                 }
 454
 455                 [DefaultValue(false)]
 456                 public bool KeyPreview {
 457                         get {
 458                                 return key_preview;
 459                         }
 460
 461                         set {
 462                                 key_preview = value;
 463                         }
 464                 }
 465
 466                 [DefaultValue(true)]
 467                 [MWFCategory("Window Style")]
 468                 public bool MaximizeBox {
 469                         get {
 470                                 return maximize_box;
 471                         }
 472                         set {
 473                                 if (maximize_box != value) {
 474                                         maximize_box = value;
 475                                         if (IsHandleCreated) {
 476                                                 RecreateHandle();
 477                                         }
 478                                         UpdateStyles();
 479                                 }
 480                         }
 481                 }
 482
 483                 [DefaultValue("{Width=0, Height=0}")]
 484                 [Localizable(true)]
 485                 [RefreshProperties(RefreshProperties.Repaint)]
 486                 [MWFCategory("Layout")]
 487                 public Size MaximumSize {
 488                         get {
 489                                 return maximum_size;
 490                         }
 491
 492                         set {
 493                                 if (maximum_size != value) {
 494                                         maximum_size = value;
 495                                         OnMaximumSizeChanged(EventArgs.Empty);
 496                                         if (IsHandleCreated) {
 497                                                 XplatUI.SetWindowMinMax(Handle, maximized_bounds, minimum_size, maximum_size);
 498                                         }
 499                                 }
 500                         }
 501                 }
 502
 503                 [Browsable(false)]
 504                 [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
 505                 public Form[] MdiChildren {
 506                         get {
 507                                 if (mdi_container != null)
 508                                         return mdi_container.MdiChildren;
 509                                 else
 510                                         return new Form[0];
 511                         }
 512                 }
 513
 514                 [Browsable(false)]
 515                 [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
 516                 public Form MdiParent {
 517                         get {
 518                                 return mdi_parent;
 519                         }
 520
 521                         set {
 522                                 if (value != null && !value.IsMdiContainer)
 523                                         throw new ArgumentException ();
 524
 525                                 if (mdi_parent != null) {
 526                                         mdi_parent.MdiContainer.Controls.Remove (this);
 527                                 }
 528
 529                                 if (value != null) {
 530                                         mdi_parent = value;
 531                                         window_manager = new MdiWindowManager (this,
 532                                                         mdi_parent.MdiContainer);
 533                                         mdi_parent.MdiContainer.Controls.Add (this);
 534
 535                                         RecreateHandle ();
 536
 537                                 } else if (mdi_parent != null) {
 538                                         mdi_parent = null;
 539
 540                                         // Create a new window manager
 541                                         window_manager = null;
 542                                         FormBorderStyle = form_border_style;
 543
 544                                         RecreateHandle ();
 545                                 }
 546                         }
 547                 }
 548
 549                 internal MenuTracker ActiveTracker {
 550                         get { return active_tracker; }
 551                         set {
 552                                 if (value == active_tracker)
 553                                         return;
 554
 555                                 Capture = value != null;
 556                                 active_tracker = value;
 557                         }
 558                 }
 559
 560                 internal MdiClient MdiContainer {
 561                         get { return mdi_container; }
 562                 }
 563
 564                 internal InternalWindowManager WindowManager {
 565                         get { return window_manager; }
 566                 }
 567
 568                 [DefaultValue(null)]
 569                 [MWFCategory("Window Style")]
 570                 public MainMenu Menu {
 571                         get {
 572                                 return menu;
 573                         }
 574
 575                         set {
 576                                 if (menu != value) {
 577                                         menu = value;
 578
 579                                         if (menu != null && !IsMdiChild) {
 580                                                 menu.SetForm (this);
 581
 582                                                 if (IsHandleCreated) {
 583                                                         XplatUI.SetMenu (window.Handle, menu);
 584                                                 }
 585
 586                                                 if (clientsize_set != Size.Empty) {
 587                                                         SetClientSizeCore(clientsize_set.Width, clientsize_set.Height);
 588                                                 } else {
 589                                                         UpdateBounds (bounds.X, bounds.Y, bounds.Width, bounds.Height, ClientSize.Width, ClientSize.Height -
 590                                                                 ThemeEngine.Current.CalcMenuBarSize (DeviceContext, menu, ClientSize.Width));
 591                                                 }
 592                                         } else
 593                                                 UpdateBounds ();
 594                                 }
 595                         }
 596                 }
 597
 598                 [Browsable(false)]
 599                 [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
 600                 [EditorBrowsable(EditorBrowsableState.Advanced)]
 601                 public MainMenu MergedMenu {
 602                         get {
 603                                 if (!IsMdiChild || window_manager == null)
 604                                         return null;
 605                                 return ((MdiWindowManager) window_manager).MergedMenu;
 606                         }
 607                 }
 608
 609                 // This is the menu in display and being used because of merging this can
 610                 // be different then the menu that is actually assosciated with the form
 611                 internal MainMenu ActiveMenu {
 612                         get {
 613                                 if (IsMdiChild)
 614                                         return null;
 615
 616                                 if (IsMdiContainer && mdi_container.Controls.Count > 0 &&
 617                                                 ((Form) mdi_container.Controls [0]).WindowState == FormWindowState.Maximized) {
 618                                         MdiWindowManager wm = (MdiWindowManager) ((Form) mdi_container.Controls [0]).WindowManager;
 619                                         return wm.MaximizedMenu;
 620                                 }
 621
 622                                 Form amc = ActiveMdiChild;
 623                                 if (amc == null || amc.Menu == null)
 624                                         return menu;
 625                                 return amc.MergedMenu;
 626                         }
 627                 }
 628
 629                 internal MdiWindowManager ActiveMaximizedMdiChild {
 630                         get {
 631                                 Form child = ActiveMdiChild;
 632                                 if (child == null)
 633                                         return null;
 634                                 if (child.WindowManager == null || child.window_state != FormWindowState.Maximized)
 635                                         return null;
 636                                 return (MdiWindowManager) child.WindowManager;
 637                         }
 638                 }
 639
 640                 [DefaultValue(true)]
 641                 [MWFCategory("Window Style")]
 642                 public bool MinimizeBox {
 643                         get {
 644                                 return minimize_box;
 645                         }
 646                         set {
 647                                 if (minimize_box != value) {
 648                                         minimize_box = value;
 649                                         if (IsHandleCreated) {
 650                                                 RecreateHandle();
 651                                         }
 652                                         UpdateStyles();
 653                                 }
 654                         }
 655                 }
 656
 657                 [DefaultValue("{Width=0, Height=0}")]
 658                 [Localizable(true)]
 659                 [RefreshProperties(RefreshProperties.Repaint)]
 660                 [MWFCategory("Layout")]
 661                 public Size MinimumSize {
 662                         get {
 663                                 return minimum_size;
 664                         }
 665
 666                         set {
 667                                 if (minimum_size != value) {
 668                                         minimum_size = value;
 669
 670                                         if ((Size.Width < value.Width) || (Size.Height < value.Height)) {
 671                                                 Size = new Size(Math.Max(Size.Width, value.Width), Math.Max(Size.Height, value.Height));
 672                                         }
 673
 674
 675                                         OnMinimumSizeChanged(EventArgs.Empty);
 676                                         if (IsHandleCreated) {
 677                                                 XplatUI.SetWindowMinMax(Handle, maximized_bounds, minimum_size, maximum_size);
 678                                         }
 679                                 }
 680                         }
 681                 }
 682
 683                 [Browsable(false)]
 684                 [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
 685                 public bool Modal  {
 686                         get {
 687                                 return is_modal;
 688                         }
 689                 }
 690
 691                 [DefaultValue(1D)]
 692                 [TypeConverter(typeof(OpacityConverter))]
 693                 [MWFCategory("Window Style")]
 694                 public double Opacity {
 695                         get {
 696                                 return opacity;
 697                         }
 698
 699                         set {
 700                                 opacity = value;
 701
 702                                 AllowTransparency = true;
 703
 704                                 if (IsHandleCreated) {
 705                                         UpdateStyles();
 706                                         XplatUI.SetWindowTransparency(Handle, opacity, TransparencyKey);
 707                                 }
 708                         }
 709                 }
 710
 711
 712                 [Browsable(false)]
 713                 [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
 714                 public Form[] OwnedForms {
 715                         get {
 716                                 Form[] form_list;
 717
 718                                 form_list = new Form[owned_forms.Count];
 719
 720                                 for (int i=0; i<owned_forms.Count; i++) {
 721                                         form_list[i] = (Form)owned_forms[i];
 722                                 }
 723
 724                                 return form_list;
 725                         }
 726                 }
 727
 728                 [Browsable(false)]
 729                 [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
 730                 public Form Owner {
 731                         get {
 732                                 return owner;
 733                         }
 734
 735                         set {
 736                                 if (owner != value) {
 737                                         if (owner != null) {
 738                                                 owner.RemoveOwnedForm(this);
 739                                         }
 740                                         owner = value;
 741                                         owner.AddOwnedForm(this);
 742                                         if (IsHandleCreated) {
 743                                                 if (owner != null && owner.IsHandleCreated) {
 744                                                         XplatUI.SetTopmost(this.window.Handle, owner.window.Handle, true);
 745                                                 } else {
 746                                                         XplatUI.SetTopmost(this.window.Handle, IntPtr.Zero, false);
 747                                                 }
 748                                         }
 749                                 }
 750                         }
 751                 }
 752
 753                 [DefaultValue(true)]
 754                 [MWFCategory("Window Style")]
 755                 public bool ShowInTaskbar {
 756                         get {
 757                                 return show_in_taskbar;
 758                         }
 759                         set {
 760                                 if (show_in_taskbar != value) {
 761                                         show_in_taskbar = value;
 762                                         if (IsHandleCreated) {
 763                                                 RecreateHandle();
 764                                         }
 765                                         UpdateStyles();
 766                                 }
 767                         }
 768                 }
 769
 770                 [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
 771                 [Localizable(false)]
 772                 public Size Size {
 773                         get {
 774                                 return base.Size;
 775                         }
 776
 777                         set {
 778                                 base.Size = value;
 779                         }
 780                 }
 781
 782                 [MonoTODO("Trigger something when GripStyle is set")]
 783                 [DefaultValue(SizeGripStyle.Auto)]
 784                 [MWFCategory("Window Style")]
 785                 public SizeGripStyle SizeGripStyle {
 786                         get {
 787                                 return size_grip_style;
 788                         }
 789
 790                         set {
 791                                 size_grip_style = value;
 792                         }
 793                 }
 794
 795                 [DefaultValue(FormStartPosition.WindowsDefaultLocation)]
 796                 [Localizable(true)]
 797                 [MWFCategory("Layout")]
 798                 public FormStartPosition StartPosition {
 799                         get {
 800                                 return start_position;
 801                         }
 802
 803                         set {
 804                                 if (start_position == FormStartPosition.WindowsDefaultLocation) {               // Only do this if it's not set yet
 805                                         start_position = value;
 806                                         if (IsHandleCreated) {
 807                                                 switch(start_position) {
 808                                                         case FormStartPosition.CenterParent: {
 809                                                                 CenterToParent();
 810                                                                 break;
 811                                                         }
 812
 813                                                         case FormStartPosition.CenterScreen: {
 814                                                                 CenterToScreen();
 815                                                                 break;
 816                                                         }
 817
 818                                                         case FormStartPosition.Manual: {
 819                                                                 Left = CreateParams.X;
 820                                                                 Top = CreateParams.Y;
 821                                                                 break;
 822                                                         }
 823
 824                                                         default: {
 825                                                                 break;
 826                                                         }
 827                                                 }
 828                                         }
 829                                 }
 830                         }
 831                 }
 832
 833                 [Browsable(false)]
 834                 [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
 835                 [EditorBrowsable(EditorBrowsableState.Never)]
 836                 public int TabIndex {
 837                         get {
 838                                 return base.TabIndex;
 839                         }
 840
 841                         set {
 842                                 base.TabIndex = value;
 843                         }
 844                 }
 845
 846                 [Browsable(false)]
 847                 [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
 848                 [EditorBrowsable(EditorBrowsableState.Advanced)]
 849                 public bool TopLevel {
 850                         get {
 851                                 return GetTopLevel();
 852                         }
 853
 854                         set {
 855                                 if (!value && IsMdiContainer)
 856                                         throw new ArgumentException ("MDI Container forms must be top level.");
 857                                 SetTopLevel(value);
 858                         }
 859                 }
 860
 861                 [DefaultValue(false)]
 862                 [MWFCategory("Window Style")]
 863                 public bool TopMost {
 864                         get {
 865                                 return topmost;
 866                         }
 867
 868                         set {
 869                                 if (topmost != value) {
 870                                         topmost = value;
 871                                         if (IsHandleCreated)
 872                                                 XplatUI.SetTopmost(window.Handle, owner != null ? owner.window.Handle : IntPtr.Zero, value);
 873                                 }
 874                         }
 875                 }
 876
 877                 [MWFCategory("Window Style")]
 878                 public Color TransparencyKey {
 879                         get {
 880                                 return transparency_key;
 881                         }
 882
 883                         set {
 884                                 transparency_key = value;
 885
 886                                 AllowTransparency = true;
 887                                 UpdateStyles();
 888                                 XplatUI.SetWindowTransparency(Handle, Opacity, transparency_key);
 889                         }
 890                 }
 891
 892                 [DefaultValue(FormWindowState.Normal)]
 893                 [MWFCategory("Layout")]
 894                 public FormWindowState WindowState {
 895                         get {
 896                                 if (IsHandleCreated) {
 897
 898                                         if (window_manager != null)
 899                                                 return window_manager.GetWindowState ();
 900
 901                                         try {
 902                                                 window_state = XplatUI.GetWindowState(Handle);
 903                                         }
 904
 905                                         catch(NotSupportedException) {
 906                                         }
 907                                 }
 908
 909                                 return window_state;
 910                         }
 911
 912                         set {
 913                                 FormWindowState old_state = window_state;
 914                                 window_state = value;
 915                                 if (IsHandleCreated) {
 916
 917                                         if (window_manager != null) {
 918                                                 window_manager.SetWindowState (old_state, value);
 919                                                 return;
 920                                         }
 921
 922                                         try {
 923                                                 XplatUI.SetWindowState(Handle, value);
 924                                         }
 925
 926                                         catch(NotSupportedException) {
 927                                         }
 928                                 }
 929                         }
 930                 }
 931
 932                 #endregion      // Public Instance Properties
 933
 934                 #region Protected Instance Properties
 935                 protected override CreateParams CreateParams {
 936                         get {
 937                                 CreateParams cp = new CreateParams ();
 938
 939                                 cp.Caption = Text;
 940                                 cp.ClassName = XplatUI.DefaultClassName;
 941                                 cp.ClassStyle = 0;
 942                                 cp.Style = 0;
 943                                 cp.ExStyle = 0;
 944                                 cp.Param = 0;
 945                                 cp.Parent = IntPtr.Zero;
 946                                 cp.menu = ActiveMenu;
 947
 948                                 if (start_position == FormStartPosition.WindowsDefaultLocation && !IsMdiChild) {
 949                                         cp.X = unchecked((int)0x80000000);
 950                                         cp.Y = unchecked((int)0x80000000);
 951                                 } else {
 952                                         cp.X = Left;
 953                                         cp.Y = Top;
 954                                 }
 955                                 cp.Width = Width;
 956                                 cp.Height = Height;
 957
 958                                 cp.Style = (int)(WindowStyles.WS_CLIPCHILDREN | WindowStyles.WS_CLIPSIBLINGS);
 959
 960                                 if (IsMdiChild) {
 961                                         cp.Style |= (int)(WindowStyles.WS_CHILD | WindowStyles.WS_CAPTION);
 962                                         if (Parent != null) {
 963                                                 cp.Parent = Parent.Handle;
 964                                         }
 965
 966                                         cp.ExStyle |= (int) (WindowExStyles.WS_EX_WINDOWEDGE | WindowExStyles.WS_EX_MDICHILD);
 967
 968                                         switch (FormBorderStyle) {
 969                                         case FormBorderStyle.None:
 970                                                 break;
 971                                         case FormBorderStyle.FixedToolWindow:
 972                                         case FormBorderStyle.SizableToolWindow:
 973                                                 cp.ExStyle |= (int) WindowExStyles.WS_EX_TOOLWINDOW;
 974                                                 goto default;
 975                                         default:
 976                                                 cp.Style |= (int) WindowStyles.WS_OVERLAPPEDWINDOW;
 977                                                 break;
 978                                         }
 979
 980                                 } else {
 981                                         switch (FormBorderStyle) {
 982                                                 case FormBorderStyle.Fixed3D: {
 983                                                         cp.Style |= (int)(WindowStyles.WS_CAPTION | WindowStyles.WS_BORDER);
 984                                                         cp.ExStyle |= (int)WindowExStyles.WS_EX_CLIENTEDGE;
 985                                                         break;
 986                                                 }
 987
 988                                                 case FormBorderStyle.FixedDialog: {
 989                                                         cp.Style |= (int)(WindowStyles.WS_CAPTION | WindowStyles.WS_BORDER);
 990                                                         cp.ExStyle |= (int)(WindowExStyles.WS_EX_DLGMODALFRAME);
 991                                                         break;
 992                                                 }
 993
 994                                                 case FormBorderStyle.FixedSingle: {
 995                                                         cp.Style |= (int)(WindowStyles.WS_CAPTION | WindowStyles.WS_BORDER);
 996                                                         break;
 997                                                 }
 998
 999                                                 case FormBorderStyle.FixedToolWindow: {
1000                                                         cp.Style |= (int)(WindowStyles.WS_CAPTION | WindowStyles.WS_BORDER);
1001                                                         cp.ExStyle |= (int)(WindowExStyles.WS_EX_TOOLWINDOW);
1002                                                         break;
1003                                                 }
1004
1005                                                 case FormBorderStyle.Sizable: {
1006                                                         cp.Style |= (int)(WindowStyles.WS_BORDER | WindowStyles.WS_THICKFRAME | WindowStyles.WS_CAPTION);
1007                                                         break;
1008                                                 }
1009
1010                                                 case FormBorderStyle.SizableToolWindow: {
1011                                                         cp.Style |= (int)(WindowStyles.WS_BORDER | WindowStyles.WS_THICKFRAME | WindowStyles.WS_CAPTION);
1012                                                         cp.ExStyle |= (int)(WindowExStyles.WS_EX_TOOLWINDOW);
1013                                                         break;
1014                                                 }
1015
1016                                                 case FormBorderStyle.None: {
1017                                                         break;
1018                                                 }
1019                                         }
1020                                 }
1021
1022                                 switch(window_state) {
1023                                         case FormWindowState.Maximized: {
1024                                                 cp.Style |= (int)WindowStyles.WS_MAXIMIZE;
1025                                                 break;
1026                                         }
1027
1028                                         case FormWindowState.Minimized: {
1029                                                 cp.Style |= (int)WindowStyles.WS_MINIMIZE;
1030                                                 break;
1031                                         }
1032                                 }
1033
1034                                 if (TopMost) {
1035                                         cp.ExStyle |= (int) WindowExStyles.WS_EX_TOPMOST;
1036                                 }
1037
1038                                 if (ShowInTaskbar) {
1039                                         cp.ExStyle |= (int)WindowExStyles.WS_EX_APPWINDOW;
1040                                 }
1041
1042                                 if (MaximizeBox) {
1043                                         cp.Style |= (int)WindowStyles.WS_MAXIMIZEBOX;
1044                                 }
1045
1046                                 if (MinimizeBox) {
1047                                         cp.Style |= (int)WindowStyles.WS_MINIMIZEBOX;
1048                                 }
1049
1050                                 if (ControlBox) {
1051                                         cp.Style |= (int)WindowStyles.WS_SYSMENU;
1052                                 }
1053
1054                                 if (HelpButton && !MaximizeBox && !MinimizeBox) {
1055                                         cp.ExStyle |= (int)WindowExStyles.WS_EX_CONTEXTHELP;
1056                                 }
1057
1058                                 if (Visible)
1059                                         cp.Style |= (int)WindowStyles.WS_VISIBLE;
1060
1061                                 if (Opacity < 1.0 || TransparencyKey != Color.Empty) {
1062                                         cp.ExStyle |= (int)WindowExStyles.WS_EX_LAYERED;
1063                                 }
1064
1065                                 if (!is_enabled && context == null) {
1066                                         cp.Style |= (int)(WindowStyles.WS_DISABLED);
1067                                 }
1068
1069                                 return cp;
1070                         }
1071                 }
1072
1073                 protected override ImeMode DefaultImeMode {
1074                         get {
1075                                 return ImeMode.NoControl;
1076                         }
1077                 }
1078
1079                 protected override Size DefaultSize {
1080                         get {
1081                                 return new Size (300, 300);
1082                         }
1083                 }
1084
1085                 protected Rectangle MaximizedBounds {
1086                         get {
1087                                 if (maximized_bounds != Rectangle.Empty) {
1088                                         return maximized_bounds;
1089                                 }
1090                                 return default_maximized_bounds;
1091                         }
1092
1093                         set {
1094                                 maximized_bounds = value;
1095                                 OnMaximizedBoundsChanged(EventArgs.Empty);
1096                                 if (IsHandleCreated) {
1097                                         XplatUI.SetWindowMinMax(Handle, maximized_bounds, minimum_size, maximum_size);
1098                                 }
1099                         }
1100                 }
1101                 #endregion      // Protected Instance Properties
1102
1103                 #region Public Static Methods
1104                 [EditorBrowsable(EditorBrowsableState.Advanced)]
1105                 public static SizeF GetAutoScaleSize (Font font)
1106                 {
1107                         return XplatUI.GetAutoScaleSize(font);
1108                 }
1109
1110                 #endregion      // Public Static Methods
1111
1112                 #region Public Instance Methods
1113                 internal SizeF GetAutoScaleSize (Graphics g, Font font)
1114                 {
1115                         //
1116                         // The following constants come from the dotnet mailing list
1117                         // discussion: http://discuss.develop.com/archives/wa.exe?A2=ind0203A&L=DOTNET&P=R3655
1118                         //
1119                         // The magic number is "Its almost the length
1120                         // of the string with a smattering added in
1121                         // for compat with earlier code".
1122                         //
1123
1124                         string magic_string = "The quick brown fox jumped over the lazy dog.";
1125                         double magic_number = 44.549996948242189;
1126                         float width = (float) (g.MeasureString (magic_string, font).Width / magic_number);
1127
1128                         return new SizeF (width, font.Height);
1129                 }
1130
1131                 public void Activate() {
1132                         Form    active;
1133
1134                         // The docs say activate only activates if our app is already active
1135                         active = ActiveForm;
1136                         if ((active != null) && (this != active)) {
1137                                 XplatUI.Activate(window.Handle);
1138                         }
1139                 }
1140
1141                 public void AddOwnedForm(Form ownedForm) {
1142                         if (!owned_forms.Contains(ownedForm)) {
1143                                 owned_forms.Add(ownedForm);
1144                         }
1145                         ownedForm.Owner = this;
1146                 }
1147
1148                 public void Close () {
1149                         if (!IsDisposed) {
1150                                 XplatUI.SendMessage(this.Handle, Msg.WM_CLOSE, IntPtr.Zero, IntPtr.Zero);
1151                         }
1152                 }
1153
1154                 public void LayoutMdi(MdiLayout value) {
1155                         if (mdi_container != null) {
1156                                 mdi_container.LayoutMdi(value);
1157                         }
1158                 }
1159
1160                 public void RemoveOwnedForm(Form ownedForm) {
1161                         owned_forms.Remove(ownedForm);
1162                 }
1163
1164                 public void SetDesktopBounds(int x, int y, int width, int height) {
1165                         DesktopBounds = new Rectangle(x, y, width, height);
1166                 }
1167
1168                 public void SetDesktopLocation(int x, int y) {
1169                         DesktopLocation = new Point(x, y);
1170                 }
1171
1172                 public DialogResult ShowDialog() {
1173                         return ShowDialog(null);
1174                 }
1175
1176                 public DialogResult ShowDialog(IWin32Window ownerWin32) {
1177                         Form            previous;
1178                         Rectangle       area;
1179                         bool            confined;
1180                         IntPtr          capture_window;
1181
1182                         owner = null;
1183
1184                         if (ownerWin32 != null) {
1185                                 Control c = Control.FromHandle (ownerWin32.Handle);
1186                                 if (c != null)
1187                                         owner = c.TopLevelControl as Form;
1188                         }
1189
1190                         if (owner == this) {
1191                                 throw new InvalidOperationException("The 'ownerWin32' cannot be the form being shown.");
1192                         }
1193
1194                         if (is_modal) {
1195                                 throw new InvalidOperationException("The form is already displayed as a modal dialog.");
1196                         }
1197
1198                         if (Visible) {
1199                                 throw new InvalidOperationException("Already visible forms cannot be displayed as a modal dialog. Set the Visible property to 'false' prior to calling Form.ShowDialog.");
1200                         }
1201
1202                         if (!Enabled) {
1203                                 throw new InvalidOperationException("Cannot display a disabled form as modal dialog.");
1204                         }
1205
1206                         if (TopLevelControl != this) {
1207                                 throw new InvalidOperationException("Can only display TopLevel forms as modal dialog.");
1208                         }
1209
1210                         #if broken
1211                         // Can't do this, will screw us in the modal loop
1212                         form_parent_window.Parent = this.owner;
1213                         #endif
1214
1215                         // Release any captures
1216                         XplatUI.GrabInfo(out capture_window, out confined, out area);
1217                         if (capture_window != IntPtr.Zero) {
1218                                 XplatUI.UngrabWindow(capture_window);
1219                         }
1220
1221                         previous = Form.ActiveForm;
1222
1223 #if not
1224                         // Commented out; we instead let the Visible=true inside the runloop create the control
1225                         // otherwise setting DialogResult inside any of the events that are triggered by the
1226                         // create will not actually cause the form to not be displayed.
1227                         // Leaving this comment here in case there was an actual purpose to creating the control
1228                         // in here.
1229                         if (!IsHandleCreated) {
1230                                 CreateControl();
1231                         }
1232 #endif
1233
1234                         Application.RunLoop(true, new ApplicationContext(this));
1235
1236                         if (previous != null) {
1237                                 // Cannot use Activate(), it has a check for the current active window...
1238                                 XplatUI.Activate(previous.window.Handle);
1239                         }
1240
1241                         if (DialogResult != DialogResult.None) {
1242                                 return DialogResult;
1243                         }
1244                         DialogResult = DialogResult.Cancel;
1245                         return DialogResult.Cancel;
1246                 }
1247
1248                 public override string ToString() {
1249                         return GetType().FullName.ToString() + ", Text: " + Text;
1250                 }
1251                 #endregion      // Public Instance Methods
1252
1253                 #region Protected Instance Methods
1254                 protected void ActivateMdiChild(Form form) {
1255                         if (!IsMdiContainer)
1256                                 return;
1257                         mdi_container.ActivateChild (form);
1258                         OnMdiChildActivate(EventArgs.Empty);
1259                 }
1260
1261                 [EditorBrowsable(EditorBrowsableState.Advanced)]
1262                 protected override void AdjustFormScrollbars(bool displayScrollbars) {
1263                         base.AdjustFormScrollbars (displayScrollbars);
1264                 }
1265
1266                 [EditorBrowsable(EditorBrowsableState.Advanced)]
1267                 protected void ApplyAutoScaling()
1268                 {
1269                         SizeF current_size_f = GetAutoScaleSize (DeviceContext, Font);
1270                         Size current_size = new Size ((int) current_size_f.Width, (int) current_size_f.Height);
1271                         float   dx;
1272                         float   dy;
1273
1274                         if (current_size == autoscale_base_size)
1275                                 return;
1276
1277                         if (Environment.GetEnvironmentVariable ("MONO_MWF_SCALING") == "disable"){
1278                                 Console.WriteLine ("Not scaling");
1279                                 return;
1280                         }
1281
1282                         //
1283                         // I tried applying the Fudge height factor from:
1284                         // http://blogs.msdn.com/mharsh/archive/2004/01/25/62621.aspx
1285                         // but it makes things larger without looking better.
1286                         //
1287                         if (current_size_f.Width != AutoScaleBaseSize.Width) {
1288                                 dx = current_size_f.Width / AutoScaleBaseSize.Width + 0.08f;
1289                         } else {
1290                                 dx = 1;
1291                         }
1292
1293                         if (current_size_f.Height != AutoScaleBaseSize.Height) {
1294                                 dy = current_size_f.Height / AutoScaleBaseSize.Height + 0.08f;
1295                         } else {
1296                                 dy = 1;
1297                         }
1298
1299                         Scale (dx, dy);
1300
1301                         AutoScaleBaseSize = current_size;
1302                 }
1303
1304                 protected void CenterToParent() {
1305                         Control ctl;
1306                         int     w;
1307                         int     h;
1308
1309                         if (Width > 0) {
1310                                 w = Width;
1311                         } else {
1312                                 w = DefaultSize.Width;
1313                         }
1314
1315                         if (Height > 0) {
1316                                 h = Height;
1317                         } else {
1318                                 h = DefaultSize.Height;
1319                         }
1320
1321                         ctl = null;
1322                         if (parent != null) {
1323                                 ctl = parent;
1324                         } else if (owner != null) {
1325                                 ctl = owner;
1326                         }
1327
1328                         if (owner != null) {
1329                                 this.Location = new Point(ctl.Left + ctl.Width / 2 - w /2, ctl.Top + ctl.Height / 2 - h / 2);
1330                         }
1331                 }
1332
1333                 protected void CenterToScreen() {
1334                         Size    DisplaySize;
1335                         int     w;
1336                         int     h;
1337
1338                         if (Width > 0) {
1339                                 w = Width;
1340                         } else {
1341                                 w = DefaultSize.Width;
1342                         }
1343
1344                         if (Height > 0) {
1345                                 h = Height;
1346                         } else {
1347                                 h = DefaultSize.Height;
1348                         }
1349
1350                         XplatUI.GetDisplaySize(out DisplaySize);
1351                         this.Location = new Point(DisplaySize.Width / 2 - w / 2, DisplaySize.Height / 2 - h / 2);
1352                 }
1353
1354                 [EditorBrowsable(EditorBrowsableState.Advanced)]
1355                 protected override Control.ControlCollection CreateControlsInstance() {
1356                         return base.CreateControlsInstance ();
1357                 }
1358
1359                 [EditorBrowsable(EditorBrowsableState.Advanced)]
1360                 protected override void CreateHandle() {
1361                         base.CreateHandle ();
1362
1363                         if (XplatUI.SupportsTransparency()) {
1364                                 if (allow_transparency) {
1365                                         XplatUI.SetWindowTransparency(Handle, Opacity, TransparencyKey);
1366                                 }
1367                         }
1368
1369                         XplatUI.SetWindowMinMax(window.Handle, maximized_bounds, minimum_size, maximum_size);
1370                         if (icon != null) {
1371                                 XplatUI.SetIcon(window.Handle, icon);
1372                         }
1373
1374                         if ((owner != null) && (owner.IsHandleCreated)) {
1375                                 XplatUI.SetTopmost(window.Handle, owner.window.Handle, true);
1376                         }
1377
1378                         if (owned_forms.Count > 0) {
1379                                 for (int i = 0; i < owned_forms.Count; i++) {
1380                                         if (owned_forms[i].IsHandleCreated) {
1381                                                 XplatUI.SetTopmost(owned_forms[i].window.Handle, window.Handle, true);
1382                                         }
1383                                 }
1384                         }
1385
1386                 }
1387
1388                 [EditorBrowsable(EditorBrowsableState.Advanced)]
1389                 protected override void DefWndProc(ref Message m) {
1390                         base.DefWndProc (ref m);
1391                 }
1392
1393                 protected override void Dispose(bool disposing) {
1394                         base.Dispose (disposing);
1395                 }
1396
1397                 [EditorBrowsable(EditorBrowsableState.Advanced)]
1398                 protected virtual void OnActivated(EventArgs e) {
1399                         if (Activated != null) {
1400                                 Activated(this, e);
1401                         }
1402                 }
1403
1404                 [EditorBrowsable(EditorBrowsableState.Advanced)]
1405                 protected virtual void OnClosed(EventArgs e) {
1406                         if (Closed != null) {
1407                                 Closed(this, e);
1408                         }
1409                 }
1410
1411                 [EditorBrowsable(EditorBrowsableState.Advanced)]
1412                 protected virtual void OnClosing(System.ComponentModel.CancelEventArgs e) {
1413                         if (Closing != null) {
1414                                 Closing(this, e);
1415                         }
1416                 }
1417
1418                 [EditorBrowsable(EditorBrowsableState.Advanced)]
1419                 protected override void OnCreateControl() {
1420                         base.OnCreateControl ();
1421                         if (this.ActiveControl == null) {
1422                                 bool visible;
1423
1424                                 // This visible hack is to work around CanSelect always being false if one of the parents
1425                                 // is not visible; and we by default create Form invisible...
1426                                 visible = this.is_visible;
1427                                 this.is_visible = true;
1428
1429                                 if (SelectNextControl(this, true, true, true, true) == false) {
1430                                         Select(this);
1431                                 }
1432
1433                                 this.is_visible = visible;
1434                         } else {
1435                                 Select(ActiveControl);
1436                         }
1437
1438                         if (menu != null) {
1439                                 XplatUI.SetMenu(window.Handle, menu);
1440                         }
1441
1442                         OnLoad(EventArgs.Empty);
1443
1444                         // Send initial location
1445                         OnLocationChanged(EventArgs.Empty);
1446
1447                         if (IsMdiContainer) {
1448                                 mdi_container.LayoutMdi (MdiLayout.Cascade);
1449                         }
1450                 }
1451
1452                 [EditorBrowsable(EditorBrowsableState.Advanced)]
1453                 protected virtual void OnDeactivate(EventArgs e) {
1454                         if (Deactivate != null) {
1455                                 Deactivate(this, e);
1456                         }
1457                 }
1458
1459                 [EditorBrowsable(EditorBrowsableState.Advanced)]
1460                 protected override void OnFontChanged(EventArgs e) {
1461                         base.OnFontChanged (e);
1462                 }
1463
1464                 [EditorBrowsable(EditorBrowsableState.Advanced)]
1465                 protected override void OnHandleCreated(EventArgs e) {
1466                         XplatUI.SetBorderStyle(window.Handle, form_border_style);
1467                         base.OnHandleCreated (e);
1468                 }
1469
1470                 [EditorBrowsable(EditorBrowsableState.Advanced)]
1471                 protected override void OnHandleDestroyed(EventArgs e) {
1472                         base.OnHandleDestroyed (e);
1473                 }
1474
1475                 [EditorBrowsable(EditorBrowsableState.Advanced)]
1476                 protected virtual void OnInputLanguageChanged(InputLanguageChangedEventArgs e) {
1477                         if (InputLanguageChanged!=null) {
1478                                 InputLanguageChanged(this, e);
1479                         }
1480                 }
1481
1482                 [EditorBrowsable(EditorBrowsableState.Advanced)]
1483                 protected virtual void OnInputLanguageChanging(InputLanguageChangingEventArgs e) {
1484                         if (InputLanguageChanging!=null) {
1485                                 InputLanguageChanging(this, e);
1486                         }
1487                 }
1488
1489                 [EditorBrowsable(EditorBrowsableState.Advanced)]
1490                 protected virtual void OnLoad(EventArgs e) {
1491                         if (AutoScale){
1492                                 ApplyAutoScaling ();
1493                                 AutoScale = false;
1494                         }
1495
1496                         if (Load != null) {
1497                                 Load(this, e);
1498                         }
1499
1500                         if (!IsMdiChild) {
1501                                 switch (StartPosition) {
1502                                         case FormStartPosition.CenterScreen:
1503                                                 this.CenterToScreen();
1504                                                 break;
1505                                         case FormStartPosition.CenterParent:
1506                                                 this.CenterToParent ();
1507                                                 break;
1508                                         case FormStartPosition.Manual:
1509                                                 Left = CreateParams.X;
1510                                                 Top = CreateParams.Y;
1511                                                 break;
1512                                 }
1513                         }
1514                 }
1515
1516                 [EditorBrowsable(EditorBrowsableState.Advanced)]
1517                 protected virtual void OnMaximizedBoundsChanged(EventArgs e) {
1518                         if (MaximizedBoundsChanged != null) {
1519                                 MaximizedBoundsChanged(this, e);
1520                         }
1521                 }
1522
1523                 [EditorBrowsable(EditorBrowsableState.Advanced)]
1524                 protected virtual void OnMaximumSizeChanged(EventArgs e) {
1525                         if (MaximumSizeChanged != null) {
1526                                 MaximumSizeChanged(this, e);
1527                         }
1528                 }
1529
1530                 [EditorBrowsable(EditorBrowsableState.Advanced)]
1531                 protected virtual void OnMdiChildActivate(EventArgs e) {
1532                         if (MdiChildActivate != null) {
1533                                 MdiChildActivate(this, e);
1534                         }
1535                 }
1536
1537                 [EditorBrowsable(EditorBrowsableState.Advanced)]
1538                 protected virtual void OnMenuComplete(EventArgs e) {
1539                         if (MenuComplete != null) {
1540                                 MenuComplete(this, e);
1541                         }
1542                 }
1543
1544                 [EditorBrowsable(EditorBrowsableState.Advanced)]
1545                 protected virtual void OnMenuStart(EventArgs e) {
1546                         if (MenuStart != null) {
1547                                 MenuStart(this, e);
1548                         }
1549                 }
1550
1551                 [EditorBrowsable(EditorBrowsableState.Advanced)]
1552                 protected virtual void OnMinimumSizeChanged(EventArgs e) {
1553                         if (MinimumSizeChanged != null) {
1554                                 MinimumSizeChanged(this, e);
1555                         }
1556                 }
1557
1558                 [EditorBrowsable(EditorBrowsableState.Advanced)]
1559                 protected override void OnPaint (PaintEventArgs pevent) {
1560                         base.OnPaint (pevent);
1561                 }
1562
1563                 [EditorBrowsable(EditorBrowsableState.Advanced)]
1564                 protected override void OnResize(EventArgs e) {
1565                         base.OnResize(e);
1566                 }
1567
1568                 [EditorBrowsable(EditorBrowsableState.Advanced)]
1569                 protected override void OnStyleChanged(EventArgs e) {
1570                         base.OnStyleChanged (e);
1571                 }
1572
1573                 [EditorBrowsable(EditorBrowsableState.Advanced)]
1574                 protected override void OnTextChanged(EventArgs e) {
1575                         base.OnTextChanged (e);
1576                 }
1577
1578                 [EditorBrowsable(EditorBrowsableState.Advanced)]
1579                 protected override void OnVisibleChanged(EventArgs e) {
1580                         base.OnVisibleChanged (e);
1581                 }
1582
1583                 protected override bool ProcessCmdKey(ref Message msg, Keys keyData) {
1584                         if (base.ProcessCmdKey (ref msg, keyData)) {
1585                                 return true;
1586                         }
1587
1588                         // Give our menu a shot
1589                         if (ActiveMenu != null) {
1590                                 return ActiveMenu.ProcessCmdKey(ref msg, keyData);
1591                         }
1592
1593                         return false;
1594                 }
1595
1596                 // LAMESPEC - Not documented that Form overrides ProcessDialogChar; class-status showed
1597                 [EditorBrowsable (EditorBrowsableState.Advanced)]
1598                 protected override bool ProcessDialogChar(char charCode) {
1599                         return base.ProcessDialogChar (charCode);
1600                 }
1601
1602                 protected override bool ProcessDialogKey(Keys keyData) {
1603                         if ((keyData & Keys.Modifiers) == 0) {
1604                                 if (keyData == Keys.Enter && accept_button != null) {
1605                                         accept_button.PerformClick();
1606                                         return true;
1607                                 } else if (keyData == Keys.Escape && cancel_button != null) {
1608                                         cancel_button.PerformClick();
1609                                         return true;
1610                                 }
1611                         }
1612                         return base.ProcessDialogKey(keyData);
1613                 }
1614
1615                 protected override bool ProcessKeyPreview(ref Message msg) {
1616                         if (key_preview) {
1617                                 if (ProcessKeyEventArgs(ref msg)) {
1618                                         return true;
1619                                 }
1620                         }
1621                         return base.ProcessKeyPreview (ref msg);
1622                 }
1623
1624                 protected override bool ProcessTabKey(bool forward) {
1625                         return SelectNextControl(ActiveControl, forward, true, true, true);
1626                 }
1627
1628                 [EditorBrowsable(EditorBrowsableState.Advanced)]
1629                 protected override void ScaleCore(float dx, float dy) {
1630                         try {
1631                                 SuspendLayout();
1632
1633                                 // We can't scale max or min windows
1634                                 if (WindowState == FormWindowState.Normal) {
1635                                         // We cannot call base since base also adjusts X/Y, but
1636                                         // a form is toplevel and doesn't move
1637                                         Size    size;
1638
1639                                         size = ClientSize;
1640                                         if (!GetStyle(ControlStyles.FixedWidth)) {
1641                                                 size.Width = (int)(size.Width * dx);
1642                                         }
1643
1644                                         if (!GetStyle(ControlStyles.FixedHeight)) {
1645                                                 size.Height = (int)(size.Height * dy);
1646                                         }
1647
1648                                         ClientSize = size;
1649                                 }
1650
1651                                 /* Now scale our children */
1652                                 Control [] controls = child_controls.GetAllControls ();
1653                                 for (int i=0; i < controls.Length; i++) {
1654                                         controls[i].Scale(dx, dy);
1655                                 }
1656                         }
1657
1658                         finally {
1659                                 ResumeLayout();
1660                         }
1661                 }
1662
1663                 protected override void Select(bool directed, bool forward) {
1664                         Form    parent;
1665
1666                         if (directed) {
1667                                 base.SelectNextControl(null, forward, true, true, true);
1668                         }
1669
1670                         parent = this.ParentForm;
1671                         if (parent != null) {
1672                                 parent.ActiveControl = this;
1673                         }
1674
1675                         Activate();
1676                 }
1677
1678                 [EditorBrowsable(EditorBrowsableState.Advanced)]
1679                 protected override void SetBoundsCore(int x, int y, int width, int height, BoundsSpecified specified) {
1680                         base.SetBoundsCore (x, y, width, height, specified);
1681                 }
1682
1683                 [EditorBrowsable(EditorBrowsableState.Advanced)]
1684                 protected override void SetClientSizeCore(int x, int y) {
1685                         if ((minimum_size.Width != 0) && (x < minimum_size.Width)) {
1686                                 x = minimum_size.Width;
1687                         } else if ((maximum_size.Width != 0) && (x > maximum_size.Width)) {
1688                                 x = maximum_size.Width;
1689                         }
1690
1691                         if ((minimum_size.Height != 0) && (y < minimum_size.Height)) {
1692                                 y = minimum_size.Height;
1693                         } else if ((maximum_size.Height != 0) && (y > maximum_size.Height)) {
1694                                 y = maximum_size.Height;
1695                         }
1696
1697                         Rectangle ClientRect = new Rectangle(0, 0, x, y);
1698                         Rectangle WindowRect;
1699                         CreateParams cp = this.CreateParams;
1700
1701                         clientsize_set = new Size(x, y);
1702
1703                         if (!IsMdiChild) {
1704                                 if (XplatUI.CalculateWindowRect(ref ClientRect, cp.Style, cp.ExStyle, cp.menu, out WindowRect)) {
1705                                         SetBoundsCore(bounds.X, bounds.Y, WindowRect.Width, WindowRect.Height, BoundsSpecified.Size);
1706                                 }
1707                         } else {
1708                                 if (XplatUI.CalculateWindowRect(ref ClientRect, cp.Style, cp.ExStyle, cp.menu, out WindowRect)) {
1709                                         SetBoundsCore(bounds.X, bounds.Y, WindowRect.Width, WindowRect.Height, BoundsSpecified.Size);
1710                                 }
1711                         }
1712                 }
1713
1714                 [EditorBrowsable(EditorBrowsableState.Advanced)]
1715                 protected override void SetVisibleCore(bool value) {
1716                         base.SetVisibleCore (value);
1717                 }
1718
1719                 protected override void UpdateDefaultButton() {
1720                         base.UpdateDefaultButton ();
1721                 }
1722
1723                 [EditorBrowsable(EditorBrowsableState.Advanced)]
1724                 protected override void WndProc(ref Message m) {
1725
1726                         if (window_manager != null && window_manager.HandleMessage (ref m)) {
1727                                 return;
1728                         }
1729
1730                         bool native_enabled = XplatUI.IsEnabled (Handle);
1731
1732                         switch((Msg)m.Msg) {
1733                                 case Msg.WM_DESTROY: {
1734                                         base.WndProc(ref m);
1735                                         if (!is_recreating) {
1736                                                 this.closing = true;
1737                                         }
1738                                         return;
1739                                 }
1740
1741                                 case Msg.WM_CLOSE_INTERNAL: {
1742                                         DestroyHandle();
1743                                         break;
1744                                 }
1745
1746                                 case Msg.WM_CLOSE: {
1747                                         Form act = Form.ActiveForm;
1748                                         if (act != null && act != this && act.Modal == true) {
1749                                                 return;
1750                                         }
1751
1752                                         CancelEventArgs args = new CancelEventArgs ();
1753
1754                                         if (mdi_container != null) {
1755                                                 foreach (Form mdi_child in mdi_container.MdiChildren) {
1756                                                         mdi_child.OnClosing (args);
1757                                                 }
1758                                         }
1759
1760                                         if (!is_modal) {
1761                                                 OnClosing (args);
1762                                                 if (!args.Cancel) {
1763                                                         OnClosed (EventArgs.Empty);
1764                                                         base.Dispose();
1765                                                 }
1766                                                 return;
1767                                         } else {
1768                                                 OnClosing (args);
1769                                                 if (!args.Cancel) {
1770                                                         OnClosed (EventArgs.Empty);
1771                                                         closing = true;
1772                                                 } else {
1773                                                         DialogResult = DialogResult.None;
1774                                                         closing = false;
1775                                                 }
1776                                         }
1777                                         return;
1778                                 }
1779
1780                                 case Msg.WM_WINDOWPOSCHANGED: {
1781                                         if (WindowState != FormWindowState.Minimized) {
1782                                                 base.WndProc(ref m);
1783                                         }
1784                                         return;
1785                                 }
1786
1787                                 case Msg.WM_ACTIVATE: {
1788                                         if (m.WParam != (IntPtr)WindowActiveFlags.WA_INACTIVE) {
1789                                                 OnActivated(EventArgs.Empty);
1790                                         } else {
1791                                                 OnDeactivate(EventArgs.Empty);
1792                                         }
1793                                         return;
1794                                 }
1795
1796                                 case Msg.WM_KILLFOCUS: {
1797                                         base.WndProc(ref m);
1798                                         return;
1799                                 }
1800
1801                                 case Msg.WM_SETFOCUS: {
1802                                         if (ActiveControl != null && ActiveControl != this) {
1803                                                 ActiveControl.Focus();
1804                                                 return; // FIXME - do we need to run base.WndProc, even though we just changed focus?
1805                                         }
1806                                         base.WndProc(ref m);
1807                                         return;
1808                                 }
1809
1810                                 // Menu drawing
1811                                 case Msg.WM_NCLBUTTONDOWN: {
1812                                         if (native_enabled && ActiveMenu != null) {
1813                                                 ActiveMenu.OnMouseDown(this, new MouseEventArgs (FromParamToMouseButtons ((int) m.WParam.ToInt32()), mouse_clicks, Control.MousePosition.X, Control.MousePosition.Y, 0));
1814                                         }
1815
1816                                         if (ActiveMaximizedMdiChild != null) {
1817                                                 ActiveMaximizedMdiChild.HandleMenuMouseDown (ActiveMenu,
1818                                                                 LowOrder ((int) m.LParam.ToInt32 ()),
1819                                                                 HighOrder ((int) m.LParam.ToInt32 ()));
1820                                         }
1821                                         base.WndProc(ref m);
1822                                         return;
1823                                 }
1824
1825                                 case Msg.WM_NCMOUSEMOVE: {
1826                                         if (native_enabled && ActiveMenu != null) {
1827                                                 ActiveMenu.OnMouseMove(this, new MouseEventArgs (FromParamToMouseButtons ((int) m.WParam.ToInt32()), mouse_clicks, LowOrder ((int) m.LParam.ToInt32 ()), HighOrder ((int) m.LParam.ToInt32 ()), 0));
1828                                         }
1829                                         base.WndProc(ref m);
1830                                         return;
1831                                 }
1832
1833                                 case Msg.WM_NCPAINT: {
1834                                         if (ActiveMenu != null) {
1835                                                 PaintEventArgs  pe;
1836                                                 Point           pnt;
1837
1838                                                 pe = XplatUI.PaintEventStart(Handle, false);
1839                                                 pnt = XplatUI.GetMenuOrigin(window.Handle);
1840
1841                                                 ActiveMenu.Draw (pe, new Rectangle (pnt.X, pnt.Y, ClientSize.Width, 0));
1842
1843                                                 if (ActiveMaximizedMdiChild != null) {
1844                                                         ActiveMaximizedMdiChild.DrawMaximizedButtons (ActiveMenu, pe);
1845                                                 }
1846
1847                                                 XplatUI.PaintEventEnd(Handle, false);
1848                                         }
1849
1850                                         base.WndProc(ref m);
1851                                         return;
1852                                 }
1853
1854                                 case Msg.WM_NCCALCSIZE: {
1855                                         XplatUIWin32.NCCALCSIZE_PARAMS  ncp;
1856
1857                                         if ((ActiveMenu != null) && (m.WParam == (IntPtr)1)) {
1858                                                 ncp = (XplatUIWin32.NCCALCSIZE_PARAMS)Marshal.PtrToStructure(m.LParam, typeof(XplatUIWin32.NCCALCSIZE_PARAMS));
1859
1860                                                 // Adjust for menu
1861                                                 ncp.rgrc1.top += ThemeEngine.Current.CalcMenuBarSize (DeviceContext, ActiveMenu, ncp.rgrc1.right - ncp.rgrc1.left);
1862                                                 Marshal.StructureToPtr(ncp, m.LParam, true);
1863                                         }
1864                                         DefWndProc(ref m);
1865                                         break;
1866                                 }
1867
1868                                 case Msg.WM_MOUSEMOVE: {
1869                                         if (native_enabled && active_tracker != null) {
1870                                                 MouseEventArgs args;
1871
1872                                                 args = new MouseEventArgs (FromParamToMouseButtons ((int) m.WParam.ToInt32()),
1873                                                         mouse_clicks,  LowOrder ((int) m.LParam.ToInt32 ()), HighOrder ((int) m.LParam.ToInt32 ()),  0);
1874                                                 active_tracker.OnMotion(new MouseEventArgs (args.Button, args.Clicks, Control.MousePosition.X, Control.MousePosition.Y, args.Delta));
1875                                                 break;
1876                                         }
1877                                         base.WndProc(ref m);
1878                                         break;
1879                                 }
1880
1881                                 case Msg.WM_LBUTTONDOWN:
1882                                 case Msg.WM_MBUTTONDOWN:
1883                                 case Msg.WM_RBUTTONDOWN: {
1884                                         if (native_enabled && active_tracker != null) {
1885                                                 MouseEventArgs args;
1886
1887                                                 args = new MouseEventArgs (FromParamToMouseButtons ((int) m.WParam.ToInt32()),
1888                                                         mouse_clicks, LowOrder ((int) m.LParam.ToInt32 ()), HighOrder ((int) m.LParam.ToInt32 ()), 0);
1889                                                 active_tracker.OnMouseDown(new MouseEventArgs (args.Button, args.Clicks, Control.MousePosition.X, Control.MousePosition.Y, args.Delta));
1890                                                 return;
1891                                         }
1892                                         base.WndProc(ref m);
1893                                         return;
1894                                 }
1895
1896                                 case Msg.WM_LBUTTONUP:
1897                                 case Msg.WM_MBUTTONUP:
1898                                 case Msg.WM_RBUTTONUP: {
1899                                         if (native_enabled && active_tracker != null) {
1900                                                 MouseEventArgs args;
1901
1902                                                 args = new MouseEventArgs (FromParamToMouseButtons ((int) m.WParam.ToInt32()),
1903                                                         mouse_clicks, LowOrder ((int) m.LParam.ToInt32 ()), HighOrder ((int) m.LParam.ToInt32 ()), 0);
1904                                                 active_tracker.OnMouseUp(new MouseEventArgs (args.Button, args.Clicks, Control.MousePosition.X, Control.MousePosition.Y, args.Delta));
1905                                                 mouse_clicks = 1;
1906                                                 return;
1907                                         }
1908                                         base.WndProc(ref m);
1909                                         return;
1910                                 }
1911
1912                                 case Msg.WM_GETMINMAXINFO: {
1913                                         MINMAXINFO      mmi;
1914
1915                                         if (m.LParam != IntPtr.Zero) {
1916                                                 mmi = (MINMAXINFO)Marshal.PtrToStructure(m.LParam, typeof(MINMAXINFO));
1917
1918                                                 default_maximized_bounds = new Rectangle(mmi.ptMaxPosition.x, mmi.ptMaxPosition.y, mmi.ptMaxSize.x, mmi.ptMaxSize.y);
1919                                                 if (maximized_bounds != Rectangle.Empty) {
1920                                                         mmi.ptMaxPosition.x = maximized_bounds.Left;
1921                                                         mmi.ptMaxPosition.y = maximized_bounds.Top;
1922                                                         mmi.ptMaxSize.x = maximized_bounds.Width;
1923                                                         mmi.ptMaxSize.y = maximized_bounds.Height;
1924                                                 }
1925
1926                                                 if (minimum_size != Size.Empty) {
1927                                                         mmi.ptMinTrackSize.x = minimum_size.Width;
1928                                                         mmi.ptMinTrackSize.y = minimum_size.Height;
1929                                                 }
1930
1931                                                 if (maximum_size != Size.Empty) {
1932                                                         mmi.ptMaxTrackSize.x = maximum_size.Width;
1933                                                         mmi.ptMaxTrackSize.y = maximum_size.Height;
1934                                                 }
1935                                                 Marshal.StructureToPtr(mmi, m.LParam, false);
1936                                         }
1937                                         break;
1938                                 }
1939
1940                                 default: {
1941                                         base.WndProc (ref m);
1942                                         break;
1943                                 }
1944                         }
1945                 }
1946                 #endregion      // Protected Instance Methods
1947
1948                 internal void RemoveWindowManager ()
1949                 {
1950                         window_manager = null;
1951                 }
1952
1953                 internal override void CheckAcceptButton()
1954                 {
1955                         if (accept_button != null) {
1956                                 Button a_button = accept_button as Button;
1957
1958                                 if (ActiveControl == a_button)
1959                                         return;
1960
1961                                 if (ActiveControl is Button) {
1962                                         a_button.paint_as_acceptbutton = false;
1963                                         a_button.Redraw();
1964                                         return;
1965                                 } else {
1966                                         a_button.paint_as_acceptbutton = true;
1967                                         a_button.Redraw();
1968                                 }
1969                         }
1970                 }
1971
1972                 #region Events
1973                 public event EventHandler Activated;
1974                 public event EventHandler Closed;
1975                 public event CancelEventHandler Closing;
1976                 public event EventHandler Deactivate;
1977                 public event InputLanguageChangedEventHandler InputLanguageChanged;
1978                 public event InputLanguageChangingEventHandler InputLanguageChanging;
1979                 public event EventHandler Load;
1980                 public event EventHandler MaximizedBoundsChanged;
1981                 public event EventHandler MaximumSizeChanged;
1982                 public event EventHandler MdiChildActivate;
1983                 public event EventHandler MenuComplete;
1984                 public event EventHandler MenuStart;
1985                 public event EventHandler MinimumSizeChanged;
1986
1987                 [Browsable(false)]
1988                 [EditorBrowsable(EditorBrowsableState.Never)]
1989                 public new event EventHandler TabIndexChanged {
1990                         add { base.TabIndexChanged += value; }
1991                         remove { base.TabIndexChanged -= value; }
1992                 }
1993                 #endregion      // Events
1994         }
1995 }