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