mcs/class/Managed.Windows.Forms/System.Windows.Forms/PrintPreviewDialog.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) 2006 Novell, Inc.
  21 //
  22 // Authors:
  23 //      Jonathan Chambers (jonathan.chambers@ansys.com)
  24 //      Peter Dennis Bartok (pbartok@novell.com)
  25 //
  26
  27 using System;
  28 using System.ComponentModel;
  29 using System.ComponentModel.Design;
  30 using System.ComponentModel.Design.Serialization;
  31 using System.Collections;
  32 using System.Diagnostics;
  33 using System.Drawing;
  34 using System.Drawing.Printing;
  35 using System.Reflection;
  36 using System.Runtime.InteropServices;
  37
  38 namespace System.Windows.Forms {
  39         [DefaultProperty("Document")]
  40         [Designer("System.ComponentModel.Design.ComponentDesigner, " + Consts.AssemblySystem_Design)]
  41         [DesignTimeVisible(true)]
  42         [ToolboxItem(true)]
  43 #if NET_2_0
  44         [ClassInterface (ClassInterfaceType.AutoDispatch)]
  45         [ComVisible (true)]
  46         [ToolboxItemFilter ("System.Windows.Forms.Control.TopLevel", ToolboxItemFilterType.Allow)]
  47 #endif
  48         public class PrintPreviewDialog : Form {
  49                 PrintPreviewControl print_preview;
  50                 MenuItem previous_checked_menu_item;
  51                 Menu mag_menu;
  52                 MenuItem auto_zoom_item;
  53                 NumericUpDown pageUpDown;
  54
  55                 public PrintPreviewDialog()
  56                 {
  57                         this.ClientSize = new Size (400, 300);
  58                         ToolBar toolbar = CreateToolBar ();
  59
  60                         toolbar.Location = new Point (0, 0);
  61                         toolbar.Dock = DockStyle.Top;
  62                         Controls.Add (toolbar);
  63
  64
  65                         print_preview = new PrintPreviewControl();
  66                         print_preview.Location = new Point (0, toolbar.Location.Y + toolbar.Size.Height);
  67                         print_preview.Size = new Size (ClientSize.Width, ClientSize.Height - toolbar.Bottom);
  68                         print_preview.Anchor = AnchorStyles.Top | AnchorStyles.Bottom | AnchorStyles.Left | AnchorStyles.Right;
  69                         print_preview.TabStop = false;
  70                         Controls.Add (print_preview);
  71                         print_preview.Show ();
  72                 }
  73
  74                 ToolBar CreateToolBar ()
  75                 {
  76                         ImageList image_list = new ImageList ();
  77                         image_list.Images.Add (ResourceImageLoader.Get ("32_printer.png"));
  78                         image_list.Images.Add (ResourceImageLoader.Get ("22_page-magnifier.png"));
  79                         image_list.Images.Add (ResourceImageLoader.Get ("1-up.png"));
  80                         image_list.Images.Add (ResourceImageLoader.Get ("2-up.png"));
  81                         image_list.Images.Add (ResourceImageLoader.Get ("3-up.png"));
  82                         image_list.Images.Add (ResourceImageLoader.Get ("4-up.png"));
  83                         image_list.Images.Add (ResourceImageLoader.Get ("6-up.png"));
  84
  85                         MenuItem mi;
  86                         mag_menu = new ContextMenu ();
  87
  88                         ToolBar toolbar = new PrintToolBar();
  89                         ToolBarButton print = new ToolBarButton();
  90                         ToolBarButton zoom = new ToolBarButton();
  91                         ToolBarButton separator1 = new ToolBarButton();
  92
  93                         ToolBarButton one_page = new ToolBarButton();
  94                         ToolBarButton two_page = new ToolBarButton();
  95                         ToolBarButton three_page = new ToolBarButton();
  96                         ToolBarButton four_page = new ToolBarButton();
  97                         ToolBarButton six_page = new ToolBarButton();
  98                         ToolBarButton separator2 = new ToolBarButton();
  99
 100                         Button close = new Button();
 101                         Label label = new Label();
 102                         pageUpDown = new NumericUpDown();
 103
 104                         toolbar.ImageList = image_list;
 105                         toolbar.Size = new Size(792, 26);
 106                         toolbar.Dock = DockStyle.Top;
 107                         toolbar.Appearance = ToolBarAppearance.Flat;
 108                         toolbar.ShowToolTips = true;
 109                         toolbar.DropDownArrows = true;
 110                         toolbar.TabStop = true;
 111                         toolbar.Buttons.AddRange(new ToolBarButton[] { print, zoom, separator1,
 112                                                                                                                    one_page, two_page, three_page, four_page, six_page, separator2 });
 113                         toolbar.ButtonClick += new ToolBarButtonClickEventHandler (OnClickToolBarButton);
 114
 115                         /* print button */
 116                         print.ImageIndex = 0;
 117                         print.Tag = 0;
 118                         print.ToolTipText = "Print";
 119
 120                         /* magnify dropdown */
 121                         zoom.ImageIndex = 1;
 122                         zoom.Tag = 1;
 123                         zoom.ToolTipText = "Zoom";
 124                         zoom.Style = ToolBarButtonStyle.DropDownButton;
 125                         zoom.DropDownMenu = mag_menu;
 126
 127                         mi = mag_menu.MenuItems.Add ("Auto", new EventHandler (OnClickPageMagnifierItem)); mi.RadioCheck = true;
 128                         mi.Checked = true;
 129                         previous_checked_menu_item = mi;
 130                         auto_zoom_item = mi;
 131
 132                         mi = mag_menu.MenuItems.Add ("500%", new EventHandler (OnClickPageMagnifierItem)); mi.RadioCheck = true;
 133                         mi = mag_menu.MenuItems.Add ("200%", new EventHandler (OnClickPageMagnifierItem)); mi.RadioCheck = true;
 134                         mi = mag_menu.MenuItems.Add ("150%", new EventHandler (OnClickPageMagnifierItem)); mi.RadioCheck = true;
 135                         mi = mag_menu.MenuItems.Add ("100%", new EventHandler (OnClickPageMagnifierItem)); mi.RadioCheck = true;
 136                         mi = mag_menu.MenuItems.Add ("75%", new EventHandler (OnClickPageMagnifierItem)); mi.RadioCheck = true;
 137                         mi = mag_menu.MenuItems.Add ("50%", new EventHandler (OnClickPageMagnifierItem)); mi.RadioCheck = true;
 138                         mi = mag_menu.MenuItems.Add ("25%", new EventHandler (OnClickPageMagnifierItem)); mi.RadioCheck = true;
 139                         mi = mag_menu.MenuItems.Add ("10%", new EventHandler (OnClickPageMagnifierItem)); mi.RadioCheck = true;
 140
 141
 142                         /* separator */
 143                         separator1.Style = ToolBarButtonStyle.Separator;
 144
 145                         /* n-up icons */
 146                         one_page.ImageIndex = 2;
 147                         one_page.Tag = 2;
 148                         one_page.ToolTipText = "One page";
 149
 150                         two_page.ImageIndex = 3;
 151                         two_page.Tag = 3;
 152                         two_page.ToolTipText = "Two pages";
 153
 154                         three_page.ImageIndex = 4;
 155                         three_page.Tag = 4;
 156                         three_page.ToolTipText = "Three pages";
 157
 158                         four_page.ImageIndex = 5;
 159                         four_page.Tag = 5;
 160                         four_page.ToolTipText = "Four pages";
 161
 162                         six_page.ImageIndex = 6;
 163                         six_page.Tag = 6;
 164                         six_page.ToolTipText = "Six pages";
 165
 166
 167                         /* separator */
 168                         separator2.Style = ToolBarButtonStyle.Separator;
 169
 170                         /* Page label */
 171                         label.Text = "Page";
 172                         label.TabStop = false;
 173                         label.Size = new Size(50, 18);
 174                         label.TextAlign = ContentAlignment.MiddleLeft;
 175                         label.Dock = DockStyle.Right;
 176
 177                         /* the page number updown */
 178                         pageUpDown.Dock = DockStyle.Right;
 179                         pageUpDown.TextAlign = HorizontalAlignment.Right;
 180                         pageUpDown.DecimalPlaces = 0;
 181                         pageUpDown.TabIndex = 1;
 182                         pageUpDown.Text = "1";
 183                         pageUpDown.Minimum = 0;
 184                         pageUpDown.Maximum = 1000;
 185                         pageUpDown.Size = new Size(64, 14);
 186                         pageUpDown.Dock = DockStyle.Right;
 187 //                      pageUpDown.Location = new Point(568, 0);
 188                         pageUpDown.ValueChanged += new EventHandler (OnPageUpDownValueChanged);
 189
 190                         /* close button */
 191                         close.Location = new Point(196, 2);
 192                         close.Size = new Size(50, 20);
 193                         close.TabIndex = 0;
 194                         close.FlatStyle = FlatStyle.Popup;
 195                         close.Text = "Close";
 196                         close.Click += new EventHandler (CloseButtonClicked);
 197
 198                         toolbar.Controls.Add(label);
 199                         toolbar.Controls.Add(pageUpDown);
 200                         toolbar.Controls.Add(close);
 201
 202 //                      close.Location = new Point (b.Rectangle.X + b.Rectangle.Width, toolbar.Height / 2 - close.Height / 2);
 203 //                      MinimumSize = new Size (close.Location.X + close.Width + label.Width + pageUpDown.Width, 220);
 204
 205                         return toolbar;
 206                 }
 207
 208                 class PrintToolBar : ToolBar
 209                 {
 210                         bool left_pressed;
 211
 212                         public int GetNext (int pos)
 213                         {
 214                                 // Select the next button that is *not* a separator
 215                                 while (++pos < items.Length && items [pos].Button.Style == ToolBarButtonStyle.Separator)
 216                                         ;
 217
 218                                 return pos;
 219                         }
 220
 221                         public int GetPrev (int pos)
 222                         {
 223                                 // Select the previous button that is *not* a separator
 224                                 while (--pos > -1 && items [pos].Button.Style == ToolBarButtonStyle.Separator)
 225                                         ;
 226
 227                                 return pos;
 228                         }
 229
 230                         void SelectNextOnParent (bool forward)
 231                         {
 232                                 ContainerControl container = Parent as ContainerControl;
 233                                 if (container != null && container.ActiveControl != null)
 234                                         container.SelectNextControl (container.ActiveControl, forward, true, true, true);
 235                         }
 236
 237                         protected override void OnGotFocus (EventArgs args)
 238                         {
 239                                 base.OnGotFocus (args);
 240
 241                                 // Select either the last one or the first one, depending on the direction
 242                                 CurrentItem = (Control.ModifierKeys & Keys.Shift) != 0 || left_pressed ? GetPrev (items.Length) : 0;
 243                                 left_pressed = false;
 244                         }
 245
 246                         // We need to handle Left/Right for our controls by ourselves, as opposed to
 247                         // Tab
 248                         protected override bool ProcessDialogKey (Keys keyData)
 249                         {
 250                                 switch ((keyData & Keys.KeyCode)) {
 251                                         case Keys.Left:
 252                                                 left_pressed = true; // Simulate Tab+Alt if focus goes to our buttons
 253                                                 SelectNextOnParent (false);
 254                                                 return true;
 255                                         case Keys.Right:
 256                                                 SelectNextOnParent (true);
 257                                                 return true;
 258                                 }
 259
 260                                 return base.ProcessDialogKey (keyData);
 261                         }
 262
 263                         void NavigateItems (Keys key)
 264                         {
 265                                 bool forward = true;
 266                                 switch ((key & Keys.KeyCode)) {
 267                                         case Keys.Left:
 268                                                 forward = false;
 269                                                 break;
 270                                         case Keys.Right:
 271                                                 forward = true;
 272                                                 break;
 273                                         case Keys.Tab:
 274                                                 forward = (Control.ModifierKeys & Keys.Shift) == 0;
 275                                                 break;
 276                                 }
 277
 278                                 int pos = forward ? GetNext (CurrentItem) : GetPrev (CurrentItem);
 279                                 if (pos < 0 || pos >= items.Length) { // go to the prev/next control
 280                                         CurrentItem = -1;
 281                                         SelectNextOnParent (forward);
 282                                         return;
 283                                 }
 284
 285                                 CurrentItem = pos;
 286                         }
 287
 288                         bool OnDropDownButton {
 289                                 get {
 290                                         return CurrentItem != -1 && items [CurrentItem].Button.Style == ToolBarButtonStyle.DropDownButton;
 291                                 }
 292                         }
 293
 294                         internal override bool InternalPreProcessMessage (ref Message msg)
 295                         {
 296                                 Keys key = (Keys)msg.WParam.ToInt32 ();
 297                                 switch (key) {
 298                                         // Up/Down keys are processed only if we are
 299                                         // on a dropdown button, and ignored otherwise.
 300                                         case Keys.Up:
 301                                         case Keys.Down:
 302                                                 if (OnDropDownButton)
 303                                                         break; // process base impl.
 304                                                 return true;
 305                                         case Keys.Left:
 306                                         case Keys.Right:
 307                                         case Keys.Tab:
 308                                                 if (OnDropDownButton)
 309                                                         ((ContextMenu)(items [CurrentItem].Button.DropDownMenu)).Hide ();
 310
 311                                                 NavigateItems (key);
 312                                                 return true;
 313                                 }
 314
 315                                 return base.InternalPreProcessMessage (ref msg);
 316                         }
 317                 }
 318
 319                 void CloseButtonClicked (object sender, EventArgs e)
 320                 {
 321                         Close ();
 322                 }
 323
 324                 void OnPageUpDownValueChanged (object sender, EventArgs e)
 325                 {
 326                         print_preview.StartPage = (int)pageUpDown.Value;
 327                 }
 328
 329                 void OnClickToolBarButton (object sender, ToolBarButtonClickEventArgs e)
 330                 {
 331                         if (e.Button.Tag == null || !(e.Button.Tag is int))
 332                                 return;
 333
 334                         switch ((int)e.Button.Tag)
 335                         {
 336                         case 0:
 337                                 Console.WriteLine ("do print here");
 338                                 break;
 339                         case 1:
 340                                 OnClickPageMagnifierItem (auto_zoom_item, EventArgs.Empty);
 341                                 break;
 342                         case 2:
 343                                 print_preview.Rows = 0;
 344                                 print_preview.Columns = 1;
 345                                 break;
 346                         case 3:
 347                                 print_preview.Rows = 0;
 348                                 print_preview.Columns = 2;
 349                                 break;
 350                         case 4:
 351                                 print_preview.Rows = 0;
 352                                 print_preview.Columns = 3;
 353                                 break;
 354                         case 5:
 355                                 print_preview.Rows = 1;
 356                                 print_preview.Columns = 2;
 357                                 break;
 358                         case 6:
 359                                 print_preview.Rows = 1;
 360                                 print_preview.Columns = 3;
 361                                 break;
 362                         }
 363                 }
 364
 365                 void OnClickPageMagnifierItem (object sender, EventArgs e)
 366                 {
 367                         MenuItem clicked_item = (MenuItem)sender;
 368
 369                         previous_checked_menu_item.Checked = false;
 370
 371                         switch (clicked_item.Index) {
 372                         case 0:
 373                                 print_preview.AutoZoom = true;
 374                                 break;
 375                         case 1:
 376                                 print_preview.AutoZoom = false;
 377                                 print_preview.Zoom = 5.0;
 378                                 break;
 379                         case 2:
 380                                 print_preview.AutoZoom = false;
 381                                 print_preview.Zoom = 2.0;
 382                                 break;
 383                         case 3:
 384                                 print_preview.AutoZoom = false;
 385                                 print_preview.Zoom = 1.5;
 386                                 break;
 387                         case 4:
 388                                 print_preview.AutoZoom = false;
 389                                 print_preview.Zoom = 1.0;
 390                                 break;
 391                         case 5:
 392                                 print_preview.AutoZoom = false;
 393                                 print_preview.Zoom = 0.75;
 394                                 break;
 395                         case 6:
 396                                 print_preview.AutoZoom = false;
 397                                 print_preview.Zoom = 0.50;
 398                                 break;
 399                         case 7:
 400                                 print_preview.AutoZoom = false;
 401                                 print_preview.Zoom = 0.25;
 402                                 break;
 403                         case 8:
 404                                 print_preview.AutoZoom = false;
 405                                 print_preview.Zoom = 0.10;
 406                                 break;
 407                         }
 408
 409                         clicked_item.Checked = true;
 410                         previous_checked_menu_item = clicked_item;
 411                 }
 412
 413                 // new property so we can set EditorBrowsable to never.
 414                 [Browsable(false)]
 415                 [EditorBrowsable(EditorBrowsableState.Never)]
 416                 public new IButtonControl AcceptButton {
 417                         get { return base.AcceptButton; }
 418                         set { base.AcceptButton = value; }
 419                 }
 420
 421                 // new property so we can set EditorBrowsable to never.
 422                 [Browsable(false)]
 423                 [EditorBrowsable(EditorBrowsableState.Never)]
 424                 public new string AccessibleDescription {
 425                         get { return base.AccessibleDescription; }
 426                         set { base.AccessibleDescription = value; }
 427                 }
 428
 429                 // new property so we can set EditorBrowsable to never.
 430                 [Browsable(false)]
 431                 [EditorBrowsable(EditorBrowsableState.Never)]
 432                 public new string AccessibleName {
 433                         get { return base.AccessibleName; }
 434                         set { base.AccessibleName = value; }
 435                 }
 436
 437                 // new property so we can set EditorBrowsable to never.
 438                 [Browsable(false)]
 439                 [EditorBrowsable(EditorBrowsableState.Never)]
 440                 public new AccessibleRole AccessibleRole {
 441                         get { return base.AccessibleRole; }
 442                         set { base.AccessibleRole = value; }
 443                 }
 444
 445                 [Browsable(false)]
 446                 [EditorBrowsable(EditorBrowsableState.Never)]
 447                 public override bool AllowDrop {
 448                         get {
 449                                 return base.AllowDrop;
 450                         }
 451
 452                         set {
 453                                 base.AllowDrop = value;
 454                         }
 455                 }
 456
 457                 [Browsable(false)]
 458                 [EditorBrowsable(EditorBrowsableState.Never)]
 459                 public override AnchorStyles Anchor {
 460                         get {
 461                                 return base.Anchor;
 462                         }
 463
 464                         set {
 465                                 base.Anchor = value;
 466                         }
 467                 }
 468
 469                 // new property so we can set EditorBrowsable to never.
 470                 [Browsable(false)]
 471                 [EditorBrowsable(EditorBrowsableState.Never)]
 472                 public new bool AutoScale {
 473                         get { return base.AutoScale; }
 474                         set { base.AutoScale = value; }
 475                 }
 476
 477                 [Browsable(false)]
 478                 [EditorBrowsable(EditorBrowsableState.Never)]
 479 #if NET_2_0
 480                 [Obsolete ("This property has been deprecated.  Use AutoScaleDimensions instead.")]
 481 #endif
 482                 public override Size AutoScaleBaseSize {
 483                         get {
 484                                 return base.AutoScaleBaseSize;
 485                         }
 486
 487                         set {
 488                                 base.AutoScaleBaseSize = value;
 489                         }
 490                 }
 491
 492                 [Browsable(false)]
 493                 [EditorBrowsable(EditorBrowsableState.Never)]
 494                 public override bool AutoScroll {
 495                         get {
 496                                 return base.AutoScroll;
 497                         }
 498
 499                         set {
 500                                 base.AutoScroll = value;
 501                         }
 502                 }
 503
 504                 // new property so we can set EditorBrowsable to never.
 505                 [Browsable(false)]
 506                 [EditorBrowsable(EditorBrowsableState.Never)]
 507                 public new Size AutoScrollMargin {
 508                         get { return base.AutoScrollMargin; }
 509                         set { base.AutoScrollMargin = value; }
 510                 }
 511
 512                 // new property so we can set EditorBrowsable to never.
 513                 [Browsable(false)]
 514                 [EditorBrowsable(EditorBrowsableState.Never)]
 515                 public new Size AutoScrollMinSize {
 516                         get { return base.AutoScrollMinSize; }
 517                         set { base.AutoScrollMinSize = value; }
 518                 }
 519
 520 #if NET_2_0
 521                 [Browsable (false)]
 522                 [EditorBrowsable (EditorBrowsableState.Never)]
 523                 [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
 524                 public override bool AutoSize {
 525                         get { return base.AutoSize; }
 526                         set { base.AutoSize = value; }
 527                 }
 528
 529                 [Browsable (false)]
 530                 [EditorBrowsable (EditorBrowsableState.Never)]
 531                 public override AutoValidate AutoValidate {
 532                         get { return base.AutoValidate; }
 533                         set { base.AutoValidate = value; }
 534                 }
 535 #endif
 536
 537                 [Browsable(false)]
 538                 [EditorBrowsable(EditorBrowsableState.Never)]
 539                 public override Color BackColor {
 540                         get {
 541                                 return base.BackColor;
 542                         }
 543
 544                         set {
 545                                 base.BackColor = value;
 546                         }
 547                 }
 548
 549                 [Browsable(false)]
 550                 [EditorBrowsable(EditorBrowsableState.Never)]
 551                 public override Image BackgroundImage {
 552                         get {
 553                                 return base.BackgroundImage;
 554                         }
 555
 556                         set {
 557                                 base.BackgroundImage = value;
 558                         }
 559                 }
 560
 561 #if NET_2_0
 562                 [Browsable (false)]
 563                 [EditorBrowsable (EditorBrowsableState.Never)]
 564                 public override ImageLayout BackgroundImageLayout {
 565                         get { return base.BackgroundImageLayout; }
 566                         set { base.BackgroundImageLayout = value; }
 567                 }
 568 #endif
 569
 570                 // new property so we can set EditorBrowsable to never.
 571                 [Browsable(false)]
 572                 [EditorBrowsable(EditorBrowsableState.Never)]
 573                 public new IButtonControl CancelButton {
 574                         get { return base.CancelButton; }
 575                         set { base.CancelButton = value; }
 576                 }
 577
 578                 // new property so we can set EditorBrowsable to never.
 579                 [Browsable(false)]
 580                 [EditorBrowsable(EditorBrowsableState.Never)]
 581                 public new bool CausesValidation {
 582                         get { return base.CausesValidation; }
 583                         set { base.CausesValidation = value; }
 584                 }
 585
 586                 [Browsable(false)]
 587                 [EditorBrowsable(EditorBrowsableState.Never)]
 588                 public override ContextMenu ContextMenu {
 589                         get {
 590                                 return base.ContextMenu;
 591                         }
 592
 593                         set {
 594                                 base.ContextMenu = value;
 595                         }
 596                 }
 597
 598 #if NET_2_0
 599                 [Browsable (false)]
 600                 [EditorBrowsable (EditorBrowsableState.Never)]
 601                 public override ContextMenuStrip ContextMenuStrip {
 602                         get { return base.ContextMenuStrip; }
 603                         set { base.ContextMenuStrip = value; }
 604                 }
 605 #endif
 606
 607                 // new property so we can set EditorBrowsable to never.
 608                 [Browsable(false)]
 609                 [EditorBrowsable(EditorBrowsableState.Never)]
 610                 public new bool ControlBox {
 611                         get { return base.ControlBox; }
 612                         set { base.ControlBox = value; }
 613                 }
 614
 615                 [Browsable(false)]
 616                 [EditorBrowsable(EditorBrowsableState.Never)]
 617                 public override Cursor Cursor {
 618                         get {
 619                                 return base.Cursor;
 620                         }
 621
 622                         set {
 623                                 base.Cursor = value;
 624                         }
 625                 }
 626
 627                 // new property so we can set EditorBrowsable to never.
 628                 [Browsable(false)]
 629                 [EditorBrowsable(EditorBrowsableState.Never)]
 630                 public new ControlBindingsCollection DataBindings {
 631                         get { return base.DataBindings; }
 632                 }
 633
 634 #if NET_2_0
 635                 protected override Size DefaultMinimumSize {
 636                         get { return new Size (370, 300); }
 637                 }
 638 #endif
 639
 640                 [Browsable(false)]
 641                 [EditorBrowsable(EditorBrowsableState.Never)]
 642                 public override DockStyle Dock {
 643                         get {
 644                                 return base.Dock;
 645                         }
 646
 647                         set {
 648                                 base.Dock = value;
 649                         }
 650                 }
 651
 652                 // new property so we can set EditorBrowsable to never.
 653                 [Browsable(false)]
 654                 [EditorBrowsable(EditorBrowsableState.Never)]
 655                 public new DockPaddingEdges DockPadding {
 656                         get { return base.DockPadding; }
 657                 }
 658
 659
 660                 [DefaultValue(null)]
 661                 public PrintDocument Document {
 662                         get { return print_preview.Document; }
 663                         set {
 664                                 print_preview.Document = value;
 665                         }
 666                 }
 667
 668                 // new property so we can set EditorBrowsable to never.
 669                 [Browsable(false)]
 670                 [EditorBrowsable(EditorBrowsableState.Never)]
 671                 public new bool Enabled {
 672                         get { return base.Enabled; }
 673                         set { base.Enabled = value; }
 674                 }
 675
 676                 [Browsable(false)]
 677                 [EditorBrowsable(EditorBrowsableState.Never)]
 678                 public override Font Font {
 679                         get {
 680                                 return base.Font;
 681                         }
 682
 683                         set {
 684                                 base.Font = value;
 685                         }
 686                 }
 687
 688                 [Browsable(false)]
 689                 [EditorBrowsable(EditorBrowsableState.Never)]
 690                 public override Color ForeColor {
 691                         get {
 692                                 return base.ForeColor;
 693                         }
 694
 695                         set {
 696                                 base.ForeColor = value;
 697                         }
 698                 }
 699
 700                 // new property so we can set EditorBrowsable to never.
 701                 [Browsable(false)]
 702                 [EditorBrowsable(EditorBrowsableState.Never)]
 703                 public new FormBorderStyle FormBorderStyle {
 704                         get { return base.FormBorderStyle; }
 705                         set { base.FormBorderStyle = value; }
 706                 }
 707
 708                 // new property so we can set EditorBrowsable to never.
 709                 [Browsable(false)]
 710                 [EditorBrowsable(EditorBrowsableState.Never)]
 711                 public new bool HelpButton {
 712                         get { return base.HelpButton; }
 713                         set { base.HelpButton = value; }
 714                 }
 715
 716                 // new property so we can set EditorBrowsable to never.
 717                 [Browsable(false)]
 718                 [EditorBrowsable(EditorBrowsableState.Never)]
 719                 public new Icon Icon {
 720                         get { return base.Icon; }
 721                         set { base.Icon = value; }
 722                 }
 723
 724                 // new property so we can set EditorBrowsable to never.
 725                 [Browsable(false)]
 726                 [EditorBrowsable(EditorBrowsableState.Never)]
 727                 public new ImeMode ImeMode {
 728                         get { return base.ImeMode; }
 729                         set { base.ImeMode = value; }
 730                 }
 731
 732                 // new property so we can set EditorBrowsable to never.
 733                 [Browsable(false)]
 734                 [EditorBrowsable(EditorBrowsableState.Never)]
 735                 public new bool IsMdiContainer {
 736                         get { return base.IsMdiContainer; }
 737                         set { base.IsMdiContainer = value; }
 738                 }
 739
 740                 // new property so we can set EditorBrowsable to never.
 741                 [Browsable(false)]
 742                 [EditorBrowsable(EditorBrowsableState.Never)]
 743                 public new bool KeyPreview {
 744                         get { return base.KeyPreview; }
 745                         set { base.KeyPreview = value; }
 746                 }
 747
 748                 // new property so we can set EditorBrowsable to never.
 749                 [Browsable(false)]
 750                 [EditorBrowsable(EditorBrowsableState.Never)]
 751 #if NET_2_0
 752                 [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
 753 #endif
 754                 public new Point Location {
 755                         get { return base.Location; }
 756                         set { base.Location = value; }
 757                 }
 758
 759 #if NET_2_0
 760                 [Browsable (false)]
 761                 [EditorBrowsable (EditorBrowsableState.Never)]
 762                 public new Padding Margin {
 763                         get { return base.Margin; }
 764                         set { base.Margin = value; }
 765                 }
 766 #endif
 767
 768                 // new property so we can set EditorBrowsable to never.
 769                 [Browsable(false)]
 770                 [EditorBrowsable(EditorBrowsableState.Never)]
 771                 public new bool MaximizeBox {
 772                         get { return base.MaximizeBox; }
 773                         set { base.MaximizeBox = value; }
 774                 }
 775
 776                 // new property so we can set EditorBrowsable to never.
 777                 [Browsable(false)]
 778                 [EditorBrowsable(EditorBrowsableState.Never)]
 779                 public new Size MaximumSize {
 780                         get { return base.MaximumSize; }
 781                         set { base.MaximumSize = value; }
 782                 }
 783
 784                 // new property so we can set EditorBrowsable to never.
 785                 [Browsable(false)]
 786                 [EditorBrowsable(EditorBrowsableState.Never)]
 787                 public new MainMenu Menu {
 788                         get { return base.Menu; }
 789                         set { base.Menu = value; }
 790                 }
 791
 792                 // new property so we can set EditorBrowsable to never.
 793                 [Browsable(false)]
 794                 [DefaultValue(false)]
 795                 [EditorBrowsable(EditorBrowsableState.Never)]
 796                 public new bool MinimizeBox {
 797                         get { return base.MinimizeBox; }
 798                         set { base.MinimizeBox = value; }
 799                 }
 800
 801                 // new property so we can set EditorBrowsable to never.
 802                 [Browsable(false)]
 803                 [EditorBrowsable(EditorBrowsableState.Never)]
 804 #if NET_2_0
 805                 [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
 806 #endif
 807                 public new Size MinimumSize {
 808                         get { return base.MinimumSize; }
 809                         set { base.MinimumSize = value; }
 810                 }
 811
 812                 // new property so we can set Browsable/EditorBrowsable.
 813                 [Browsable(false)]
 814                 [EditorBrowsable(EditorBrowsableState.Advanced)]
 815                 public new double Opacity {
 816                         get { return base.Opacity; }
 817                         set { base.Opacity = value; }
 818                 }
 819
 820 #if NET_2_0
 821                 [Browsable (false)]
 822                 [EditorBrowsable (EditorBrowsableState.Never)]
 823                 public new Padding Padding {
 824                         get { return base.Padding; }
 825                         set { base.Padding = value; }
 826                 }
 827 #endif
 828
 829                 [Browsable(false)]
 830 #if !NET_2_0
 831                 [EditorBrowsable(EditorBrowsableState.Never)]
 832 #endif
 833                 public PrintPreviewControl PrintPreviewControl {
 834                         get { return print_preview; }
 835                 }
 836
 837                 [Browsable(false)]
 838                 [EditorBrowsable(EditorBrowsableState.Never)]
 839                 public override RightToLeft RightToLeft {
 840                         get {
 841                                 return base.RightToLeft;
 842                         }
 843
 844                         set {
 845                                 base.RightToLeft = value;
 846                         }
 847                 }
 848
 849 #if NET_2_0
 850                 [Browsable (false)]
 851                 [EditorBrowsable (EditorBrowsableState.Never)]
 852                 public override bool RightToLeftLayout {
 853                         get { return base.RightToLeftLayout; }
 854                         set { base.RightToLeftLayout = value; }
 855                 }
 856 #endif
 857
 858                 // new property so we can set Browsable/EditorBrowsable
 859                 [Browsable(false)]
 860                 [DefaultValue(false)]
 861                 [EditorBrowsable(EditorBrowsableState.Never)]
 862                 public new bool ShowInTaskbar {
 863                         get { return base.ShowInTaskbar; }
 864                         set { base.ShowInTaskbar = value; }
 865                 }
 866
 867                 // new property so we can set Browsable/EditorBrowsable
 868                 [Browsable(false)]
 869                 [EditorBrowsable(EditorBrowsableState.Never)]
 870                 public new Size Size {
 871                         get { return base.Size; }
 872                         set { base.Size = value; }
 873                 }
 874
 875                 // new property so we can set Browsable/EditorBrowsable
 876                 [Browsable(false)]
 877                 [DefaultValue(SizeGripStyle.Hide)]
 878                 [EditorBrowsable(EditorBrowsableState.Never)]
 879                 public new SizeGripStyle SizeGripStyle {
 880                         get { return base.SizeGripStyle; }
 881                         set { base.SizeGripStyle = value; }
 882                 }
 883
 884                 // new property so we can set Browsable/EditorBrowsable
 885                 [Browsable(false)]
 886                 [EditorBrowsable(EditorBrowsableState.Never)]
 887                 public new FormStartPosition StartPosition {
 888                         get { return base.StartPosition; }
 889                         set { base.StartPosition = value; }
 890                 }
 891
 892                 // new property so we can set Browsable/EditorBrowsable
 893                 [Browsable(false)]
 894                 [EditorBrowsable(EditorBrowsableState.Never)]
 895                 public new bool TabStop {
 896                         get { return base.TabStop; }
 897                         set { base.TabStop = value; }
 898                 }
 899
 900                 // new property so we can set Browsable/EditorBrowsable
 901                 [Browsable(false)]
 902                 [EditorBrowsable(EditorBrowsableState.Never)]
 903                 public new object Tag {
 904                         get { return base.Tag; }
 905                         set { base.Tag = value; }
 906                 }
 907
 908                 [Browsable(false)]
 909                 [EditorBrowsable(EditorBrowsableState.Never)]
 910                 public override string Text {
 911                         get {
 912                                 return base.Text;
 913                         }
 914
 915                         set {
 916                                 base.Text = value;
 917                         }
 918                 }
 919
 920                 // new property so we can set Browsable/EditorBrowsable
 921                 [Browsable(false)]
 922                 [EditorBrowsable(EditorBrowsableState.Never)]
 923                 public new bool TopMost {
 924                         get { return base.TopMost; }
 925                         set { base.TopMost = value; }
 926                 }
 927
 928                 // new property so we can set Browsable/EditorBrowsable
 929                 [Browsable(false)]
 930                 [EditorBrowsable(EditorBrowsableState.Never)]
 931                 public new Color TransparencyKey {
 932                         get { return base.TransparencyKey; }
 933                         set { base.TransparencyKey = value; }
 934                 }
 935
 936                 [DefaultValue(false)]
 937                 public bool UseAntiAlias {
 938                         get {
 939                                 return print_preview.UseAntiAlias;
 940                         }
 941
 942                         set {
 943                                 print_preview.UseAntiAlias = value;
 944                         }
 945                 }
 946
 947 #if NET_2_0
 948                 [Browsable (false)]
 949                 [EditorBrowsable (EditorBrowsableState.Never)]
 950                 public new bool UseWaitCursor {
 951                         get { return base.UseWaitCursor; }
 952                         set { base.UseWaitCursor = value; }
 953                 }
 954 #endif
 955
 956                 // new property so we can set Browsable/EditorBrowsable
 957                 [Browsable(false)]
 958                 [EditorBrowsable(EditorBrowsableState.Never)]
 959                 public new bool Visible {
 960                         get { return base.Visible; }
 961                         set { base.Visible = value; }
 962                 }
 963
 964                 // new property so we can set Browsable/EditorBrowsable
 965                 [Browsable(false)]
 966                 [EditorBrowsable(EditorBrowsableState.Never)]
 967                 public new FormWindowState WindowState {
 968                         get { return base.WindowState; }
 969                         set { base.WindowState = value; }
 970                 }
 971
 972                 [MonoInternalNote ("Throw InvalidPrinterException")]
 973                 protected override void CreateHandle() {
 974
 975 //                      if (this.Document != null && !this.Document.PrinterSettings.IsValid) {
 976 //                              throw new InvalidPrinterException(this.Document.PrinterSettings);
 977 //                      }
 978                         base.CreateHandle ();
 979                 }
 980
 981                 protected override void OnClosing(CancelEventArgs e) {
 982                         print_preview.InvalidatePreview ();
 983                         base.OnClosing (e);
 984                 }
 985
 986 #if NET_2_0
 987                 protected override bool ProcessDialogKey (Keys keyData)
 988                 {
 989                         switch (keyData) {
 990                                 case Keys.Up:
 991                                 case Keys.Down:
 992                                 case Keys.Right:
 993                                 case Keys.Left:
 994                                         return false;
 995                         }
 996
 997                         return base.ProcessDialogKey (keyData);
 998                 }
 999
1000                 protected override bool ProcessTabKey (bool forward)
1001                 {
1002                         return base.ProcessTabKey (forward);
1003                 }
1004
1005                 [Browsable (false)]
1006                 [EditorBrowsable (EditorBrowsableState.Never)]
1007                 public new event EventHandler AutoSizeChanged {
1008                         add { base.AutoSizeChanged += value; }
1009                         remove { base.AutoSizeChanged -= value; }
1010                 }
1011
1012                 [Browsable (false)]
1013                 [EditorBrowsable (EditorBrowsableState.Never)]
1014                 public new event EventHandler AutoValidateChanged {
1015                         add { base.AutoValidateChanged += value; }
1016                         remove { base.AutoValidateChanged -= value; }
1017                 }
1018 #endif
1019
1020                 // new event so we can set Browsable/EditorBrowsable
1021                 [Browsable(false)]
1022                 [EditorBrowsable(EditorBrowsableState.Never)]
1023                 public new event EventHandler BackColorChanged {
1024                         add { base.BackColorChanged += value; }
1025                         remove { base.BackColorChanged -= value; }
1026                 }
1027
1028                 // new event so we can set Browsable/EditorBrowsable
1029                 [Browsable(false)]
1030                 [EditorBrowsable(EditorBrowsableState.Never)]
1031                 public new event EventHandler BackgroundImageChanged {
1032                         add { base.BackgroundImageChanged += value; }
1033                         remove { base.BackgroundImageChanged -= value; }
1034                 }
1035
1036 #if NET_2_0
1037                 [Browsable (false)]
1038                 [EditorBrowsable (EditorBrowsableState.Never)]
1039                 public new event EventHandler BackgroundImageLayoutChanged {
1040                         add { base.BackgroundImageLayoutChanged += value; }
1041                         remove { base.BackgroundImageLayoutChanged -= value; }
1042                 }
1043 #endif
1044
1045                 // new event so we can set Browsable/EditorBrowsable
1046                 [Browsable(false)]
1047                 [EditorBrowsable(EditorBrowsableState.Never)]
1048                 public new event EventHandler CausesValidationChanged {
1049                         add { base.CausesValidationChanged += value; }
1050                         remove { base.CausesValidationChanged -= value; }
1051                 }
1052
1053                 // new event so we can set Browsable/EditorBrowsable
1054                 [Browsable(false)]
1055                 [EditorBrowsable(EditorBrowsableState.Never)]
1056                 public new event EventHandler ContextMenuChanged {
1057                         add { base.ContextMenuChanged += value; }
1058                         remove { base.ContextMenuChanged -= value; }
1059                 }
1060
1061 #if NET_2_0
1062                 [Browsable (false)]
1063                 [EditorBrowsable (EditorBrowsableState.Never)]
1064                 public new event EventHandler ContextMenuStripChanged {
1065                         add { base.ContextMenuStripChanged += value; }
1066                         remove { base.ContextMenuStripChanged -= value; }
1067                 }
1068 #endif
1069
1070                 // new event so we can set Browsable/EditorBrowsable
1071                 [Browsable(false)]
1072                 [EditorBrowsable(EditorBrowsableState.Never)]
1073                 public new event EventHandler CursorChanged {
1074                         add { base.CursorChanged += value; }
1075                         remove { base.CursorChanged -= value; }
1076                 }
1077
1078                 // new event so we can set Browsable/EditorBrowsable
1079                 [Browsable(false)]
1080                 [EditorBrowsable(EditorBrowsableState.Never)]
1081                 public new event EventHandler DockChanged {
1082                         add { base.DockChanged += value; }
1083                         remove { base.DockChanged -= value; }
1084                 }
1085
1086                 // new event so we can set Browsable/EditorBrowsable
1087                 [Browsable(false)]
1088                 [EditorBrowsable(EditorBrowsableState.Never)]
1089                 public new event EventHandler EnabledChanged {
1090                         add { base.EnabledChanged += value; }
1091                         remove { base.EnabledChanged -= value; }
1092                 }
1093
1094                 // new event so we can set Browsable/EditorBrowsable
1095                 [Browsable(false)]
1096                 [EditorBrowsable(EditorBrowsableState.Never)]
1097                 public new event EventHandler FontChanged {
1098                         add { base.FontChanged += value; }
1099                         remove { base.FontChanged -= value; }
1100                 }
1101
1102                 // new event so we can set Browsable/EditorBrowsable
1103                 [Browsable(false)]
1104                 [EditorBrowsable(EditorBrowsableState.Never)]
1105                 public new event EventHandler ForeColorChanged {
1106                         add { base.ForeColorChanged += value; }
1107                         remove { base.ForeColorChanged -= value; }
1108                 }
1109
1110                 // new event so we can set Browsable/EditorBrowsable
1111                 [Browsable(false)]
1112                 [EditorBrowsable(EditorBrowsableState.Never)]
1113                 public new event EventHandler ImeModeChanged {
1114                         add { base.ImeModeChanged += value; }
1115                         remove { base.ImeModeChanged -= value; }
1116                 }
1117
1118                 // new event so we can set Browsable/EditorBrowsable
1119                 [Browsable(false)]
1120                 [EditorBrowsable(EditorBrowsableState.Never)]
1121                 public new event EventHandler LocationChanged {
1122                         add { base.LocationChanged += value; }
1123                         remove { base.LocationChanged -= value; }
1124                 }
1125
1126 #if NET_2_0
1127                 [Browsable (false)]
1128                 [EditorBrowsable (EditorBrowsableState.Never)]
1129                 public new event EventHandler MarginChanged {
1130                         add { base.MarginChanged += value; }
1131                         remove { base.MarginChanged -= value; }
1132                 }
1133 #endif
1134
1135                 // new event so we can set Browsable/EditorBrowsable
1136                 [Browsable(false)]
1137                 [EditorBrowsable(EditorBrowsableState.Never)]
1138                 public new event EventHandler MaximumSizeChanged {
1139                         add { base.MaximumSizeChanged += value; }
1140                         remove { base.MaximumSizeChanged -= value; }
1141                 }
1142
1143                 // new event so we can set Browsable/EditorBrowsable
1144                 [Browsable(false)]
1145                 [EditorBrowsable(EditorBrowsableState.Never)]
1146                 public new event EventHandler MinimumSizeChanged {
1147                         add { base.MinimumSizeChanged += value; }
1148                         remove { base.MinimumSizeChanged -= value; }
1149                 }
1150
1151 #if NET_2_0
1152                 [Browsable (false)]
1153                 [EditorBrowsable (EditorBrowsableState.Never)]
1154                 public new event EventHandler PaddingChanged {
1155                         add { base.PaddingChanged += value; }
1156                         remove { base.PaddingChanged -= value; }
1157                 }
1158 #endif
1159
1160                 // new event so we can set Browsable/EditorBrowsable
1161                 [Browsable(false)]
1162                 [EditorBrowsable(EditorBrowsableState.Never)]
1163                 public new event EventHandler RightToLeftChanged {
1164                         add { base.RightToLeftChanged += value; }
1165                         remove { base.RightToLeftChanged -= value; }
1166                 }
1167
1168 #if NET_2_0
1169                 [Browsable (false)]
1170                 [EditorBrowsable (EditorBrowsableState.Never)]
1171                 public new event EventHandler RightToLeftLayoutChanged {
1172                         add { base.RightToLeftLayoutChanged += value; }
1173                         remove { base.RightToLeftLayoutChanged -= value; }
1174                 }
1175 #endif
1176
1177                 // new event so we can set Browsable/EditorBrowsable
1178                 [Browsable(false)]
1179                 [EditorBrowsable(EditorBrowsableState.Never)]
1180                 public new event EventHandler SizeChanged {
1181                         add { base.SizeChanged += value; }
1182                         remove { base.SizeChanged -= value; }
1183                 }
1184
1185                 // new event so we can set Browsable/EditorBrowsable
1186                 [Browsable(false)]
1187                 [EditorBrowsable(EditorBrowsableState.Never)]
1188                 public new event EventHandler TabStopChanged {
1189                         add { base.TabStopChanged += value; }
1190                         remove { base.TabStopChanged -= value; }
1191                 }
1192
1193                 // new event so we can set Browsable/EditorBrowsable
1194                 [Browsable(false)]
1195                 [EditorBrowsable(EditorBrowsableState.Never)]
1196                 public new event EventHandler TextChanged {
1197                         add { base.TextChanged += value; }
1198                         remove { base.TextChanged -= value; }
1199                 }
1200
1201                 // new event so we can set Browsable/EditorBrowsable
1202                 [Browsable(false)]
1203                 [EditorBrowsable(EditorBrowsableState.Never)]
1204                 public new event EventHandler VisibleChanged {
1205                         add { base.VisibleChanged += value; }
1206                         remove { base.VisibleChanged -= value; }
1207                 }
1208         }
1209 }