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

   1 // Permission is hereby granted, free of charge, to any person obtaining
   2 // a copy of this software and associated documentation files (the
   3 // "Software"), to deal in the Software without restriction, including
   4 // without limitation the rights to use, copy, modify, merge, publish,
   5 // distribute, sublicense, and/or sell copies of the Software, and to
   6 // permit persons to whom the Software is furnished to do so, subject to
   7 // the following conditions:
   8 //
   9 // The above copyright notice and this permission notice shall be
  10 // included in all copies or substantial portions of the Software.
  11 //
  12 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  13 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  14 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  15 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  16 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  17 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  18 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  19 //
  20 // Copyright (c) 2004-2005 Novell, Inc.
  21 //
  22 // Authors:
  23 //      Jonathan Chambers (jonathan.chambers@ansys.com)
  24 //
  25
  26 // NOT COMPLETE
  27
  28 using System;
  29 using System.Drawing;
  30 using System.Drawing.Design;
  31 using System.ComponentModel;
  32 using System.Collections;
  33 using System.ComponentModel.Design;
  34 using System.Reflection;
  35 using System.Windows.Forms.Design;
  36 using System.Windows.Forms.PropertyGridInternal;
  37
  38 namespace System.Windows.Forms {
  39         [Designer("System.Windows.Forms.Design.PropertyGridDesigner, " + Consts.AssemblySystem_Design, "System.ComponentModel.Design.IDesigner")]
  40         public class PropertyGrid : System.Windows.Forms.ContainerControl, ComponentModel.Com2Interop.IComPropertyBrowser {
  41                 #region Private Members
  42
  43
  44                 private const int GRID_ITEM_HEIGHT = 16;
  45                 private const int GRID_LEFT_COLUMN_WIDTH = 16;
  46                 private const int DIVIDER_PADDING = 2;
  47
  48                 private AttributeCollection browsable_attributes = null;
  49                 private bool can_show_commands = false;
  50                 private Color commands_back_color;
  51                 private Color commands_fore_color;
  52                 private bool commands_visible;
  53                 private bool commands_visible_if_available;
  54                 private Point context_menu_default_location;
  55                 private bool large_buttons;
  56                 private Color line_color;
  57                 private PropertySort property_sort;
  58                 private PropertyTabCollection property_tabs;
  59                 private GridItem selected_grid_item;
  60                 internal GridItemCollection grid_items;
  61                 private object[] selected_objects;
  62                 private PropertyTab selected_tab;
  63
  64                 private ImageList toolbar_imagelist;
  65                 private ToolBarButton categorized_toolbarbutton;
  66                 private ToolBarButton alphabetic_toolbarbutton;
  67                 private ToolBarButton separator_toolbarbutton;
  68                 private ToolBarButton propertypages_toolbarbutton;
  69
  70                 internal ToolBar toolbar;
  71                 internal PropertyGridView property_grid_view;
  72                 internal Splitter splitter;
  73                 internal Panel help_panel;
  74                 internal Label help_title_label;
  75                 internal Label help_description_label;
  76                 private ContextMenu context_menu;
  77                 private MenuItem reset_menuitem;
  78                 private MenuItem description_menuitem;
  79                 private object current_property_value;
  80
  81                 #endregion      // Private Members
  82
  83                 #region Contructors
  84                 public PropertyGrid() {
  85                         selected_objects = new object[1];
  86                         grid_items = new GridItemCollection();
  87                         property_tabs = new PropertyTabCollection();
  88
  89                         line_color = SystemColors.ScrollBar;
  90                         line_color = SystemColors.ScrollBar;
  91                         browsable_attributes = new AttributeCollection(new Attribute[] {});
  92                         commands_visible_if_available = false;
  93                         property_sort = PropertySort.Categorized;
  94
  95                         property_grid_view = new PropertyGridView(this);
  96
  97                         splitter = new Splitter();
  98                         splitter.Dock = DockStyle.Bottom;
  99
 100                         help_panel = new Panel();
 101                         help_panel.Dock = DockStyle.Bottom;
 102                         //help_panel.DockPadding.All = 3;
 103                         help_panel.Height = 50;
 104                         help_panel.BackColor = SystemColors.Control;
 105
 106
 107                         help_title_label = new Label();
 108                         help_title_label.Anchor = AnchorStyles.Top | AnchorStyles.Left | AnchorStyles.Right;
 109                         help_title_label.Name = "help_title_label";
 110                         help_title_label.Font = new Font(this.Font,FontStyle.Bold);
 111                         help_title_label.Text = "Title";
 112                         help_title_label.Location = new Point(2,2);
 113                         help_title_label.Height = 17;
 114                         help_title_label.Width = help_panel.Width - 4;
 115
 116
 117                         help_description_label = new Label();
 118                         help_description_label.Anchor = AnchorStyles.Top | AnchorStyles.Left | AnchorStyles.Right;
 119                         help_description_label.Name = "help_description_label";
 120                         help_description_label.Font = this.Font;
 121                         help_description_label.Text = "The long important Description";
 122                         help_description_label.Location = new Point(2,help_title_label.Top+help_title_label.Height);
 123                         help_description_label.Width = help_panel.Width - 4;
 124                         help_description_label.Height = 17;
 125
 126                         help_panel.Controls.Add(help_description_label);
 127                         help_panel.Controls.Add(help_title_label);
 128                         help_panel.Paint+=new PaintEventHandler(help_panel_Paint);
 129
 130                         toolbar = new PropertyToolBar();
 131                         toolbar.Dock = DockStyle.Top;
 132                         categorized_toolbarbutton = new ToolBarButton();
 133                         alphabetic_toolbarbutton = new ToolBarButton();
 134                         separator_toolbarbutton = new ToolBarButton();
 135                         propertypages_toolbarbutton = new ToolBarButton();
 136                         context_menu = new ContextMenu();
 137
 138                         toolbar_imagelist = new ImageList();
 139                         toolbar_imagelist.ColorDepth = ColorDepth.Depth32Bit;
 140                         toolbar_imagelist.ImageSize = new System.Drawing.Size(16, 16);
 141                         toolbar_imagelist.TransparentColor = System.Drawing.Color.Transparent;
 142                         toolbar_imagelist.Images.Add( (Image)Locale.GetResource( "propertygrid_sort_category") );
 143                         toolbar_imagelist.Images.Add( (Image)Locale.GetResource( "propertygrid_sort_alphabetical") );
 144                         toolbar_imagelist.Images.Add( (Image)Locale.GetResource( "propertygrid_tab_properties") );
 145
 146                         toolbar.Appearance = ToolBarAppearance.Flat;
 147                         toolbar.AutoSize = false;
 148                         toolbar.Buttons.AddRange(new ToolBarButton[] {
 149                                                                                                                          categorized_toolbarbutton,
 150                                                                                                                          alphabetic_toolbarbutton,
 151                                                                                                                          separator_toolbarbutton,
 152                                                                                                                          propertypages_toolbarbutton});
 153
 154                         toolbar.ButtonSize = new System.Drawing.Size(20, 20);
 155                         toolbar.ImageList = toolbar_imagelist;
 156                         toolbar.Location = new System.Drawing.Point(0, 0);
 157                         toolbar.ShowToolTips = true;
 158                         toolbar.Size = new System.Drawing.Size(256, 27);
 159                         toolbar.TabIndex = 0;
 160                         toolbar.ButtonClick += new ToolBarButtonClickEventHandler(toolbar_ButtonClick);
 161
 162                         categorized_toolbarbutton.ImageIndex = 0;
 163                         categorized_toolbarbutton.Style = ToolBarButtonStyle.ToggleButton;
 164                         categorized_toolbarbutton.ToolTipText = (string)Locale.GetResource( "Categorized");
 165
 166                         alphabetic_toolbarbutton.ImageIndex = 1;
 167                         alphabetic_toolbarbutton.Style = ToolBarButtonStyle.ToggleButton;
 168                         alphabetic_toolbarbutton.ToolTipText = (string)Locale.GetResource( "Alphabetic");
 169
 170                         separator_toolbarbutton.Style = ToolBarButtonStyle.Separator;
 171
 172                         propertypages_toolbarbutton.Enabled = false;
 173                         propertypages_toolbarbutton.ImageIndex = 2;
 174                         propertypages_toolbarbutton.Style = ToolBarButtonStyle.ToggleButton;
 175                         propertypages_toolbarbutton.ToolTipText = "Property Pages";
 176
 177
 178                         reset_menuitem = context_menu.MenuItems.Add("Reset");
 179                         reset_menuitem.Click +=new EventHandler(OnResetPropertyClick);
 180                         context_menu.MenuItems.Add("-");
 181                         description_menuitem = context_menu.MenuItems.Add("Description");
 182                         description_menuitem.Click += new EventHandler(OnDescriptionClick);
 183                         description_menuitem.Checked = this.HelpVisible;
 184                         this.ContextMenu = context_menu;
 185                         toolbar.ContextMenu = context_menu;
 186
 187                         BorderHelperControl helper = new BorderHelperControl ();
 188                         helper.Dock = DockStyle.Fill;
 189                         helper.Controls.Add (property_grid_view);
 190
 191                         this.Controls.Add(helper);
 192                         this.Controls.Add(toolbar);
 193                         this.Controls.Add(splitter);
 194                         this.Controls.Add(help_panel);
 195                         this.Name = "PropertyGrid";
 196                         this.Size = new System.Drawing.Size(256, 400);
 197
 198                         UpdateToolBarButtons();
 199                 }
 200                 #endregion      // Constructors
 201
 202                 #region Public Instance Properties
 203
 204                 [BrowsableAttribute(false)]
 205                 [EditorBrowsableAttribute(EditorBrowsableState.Advanced)]
 206                 [DesignerSerializationVisibilityAttribute(DesignerSerializationVisibility.Hidden)]
 207                 public AttributeCollection BrowsableAttributes {
 208                         get {
 209                                 return browsable_attributes;
 210                         }
 211
 212                         set {
 213                                 if (browsable_attributes == value) {
 214                                         return;
 215                                 }
 216
 217                                 browsable_attributes = value;
 218                         }
 219                 }
 220
 221                 [Browsable(false)]
 222                 [EditorBrowsable(EditorBrowsableState.Never)]
 223                 public override bool AutoScroll {
 224                         get {
 225                                 return base.AutoScroll;
 226                         }
 227                         set {
 228                                 base.AutoScroll = value;
 229                         }
 230                 }
 231
 232                 public override Color BackColor {
 233                         get {
 234                                 return base.BackColor;
 235                         }
 236
 237                         set {
 238                                 base.BackColor = value;
 239                                 toolbar.BackColor = value;
 240                                 Refresh ();
 241                         }
 242                 }
 243
 244                 [Browsable(false)]
 245                 [EditorBrowsable(EditorBrowsableState.Never)]
 246                 public override Image BackgroundImage {
 247                         get {
 248                                 return base.BackgroundImage;
 249                         }
 250                         set {
 251                                 base.BackgroundImage = value;
 252                         }
 253                 }
 254
 255
 256                 [BrowsableAttribute(false)]
 257                 [EditorBrowsableAttribute(EditorBrowsableState.Advanced)]
 258                 public virtual bool CanShowCommands {
 259                         get {
 260                                 return can_show_commands;
 261                         }
 262                 }
 263
 264                 public Color CommandsBackColor {
 265                         get {
 266                                 return commands_back_color;
 267                         }
 268
 269                         set {
 270                                 if (commands_back_color == value) {
 271                                         return;
 272                                 }
 273                                 commands_back_color = value;
 274                         }
 275                 }
 276
 277                 public Color CommandsForeColor {
 278                         get {
 279                                 return commands_fore_color;
 280                         }
 281
 282                         set {
 283                                 if (commands_fore_color == value) {
 284                                         return;
 285                                 }
 286                                 commands_fore_color = value;
 287                         }
 288                 }
 289
 290                 [BrowsableAttribute(false)]
 291                 [EditorBrowsableAttribute(EditorBrowsableState.Advanced)]
 292                 public virtual bool CommandsVisible {
 293                         get {
 294                                 return commands_visible;
 295                         }
 296                 }
 297
 298                 [DefaultValue(false)]
 299                 public virtual bool CommandsVisibleIfAvailable {
 300                         get {
 301                                 return commands_visible_if_available;
 302                         }
 303
 304                         set {
 305                                 if (commands_visible_if_available == value) {
 306                                         return;
 307                                 }
 308                                 commands_visible_if_available = value;
 309                         }
 310                 }
 311
 312                 [BrowsableAttribute(false)]
 313                 [EditorBrowsableAttribute(EditorBrowsableState.Advanced)]
 314                 [DesignerSerializationVisibilityAttribute(DesignerSerializationVisibility.Hidden)]
 315                 public Point ContextMenuDefaultLocation {
 316                         get {
 317                                 return context_menu_default_location;
 318                         }
 319                 }
 320
 321                 [Browsable(false)]
 322                 [EditorBrowsable(EditorBrowsableState.Never)]
 323                 [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
 324                 public new Control.ControlCollection Controls {
 325                         get {
 326                                 return base.Controls;
 327                         }
 328                 }
 329
 330                 [Browsable(false)]
 331                 [EditorBrowsable(EditorBrowsableState.Never)]
 332                 public override Color ForeColor {
 333                         get {
 334                                 return base.ForeColor;
 335                         }
 336                         set {
 337                                 base.ForeColor = value;
 338                         }
 339                 }
 340
 341                 public Color HelpBackColor {
 342                         get {
 343                                 return help_panel.BackColor;
 344                         }
 345                         set {
 346                                 if (help_panel.BackColor == value) {
 347                                         return;
 348                                 }
 349
 350                                 help_panel.BackColor = value;
 351                         }
 352                 }
 353
 354                 public Color HelpForeColor {
 355                         get {
 356                                 return help_panel.ForeColor;
 357                         }
 358
 359                         set {
 360                                 if (help_panel.ForeColor == value) {
 361                                         return;
 362                                 }
 363
 364                                 help_panel.ForeColor = value;
 365                         }
 366                 }
 367
 368                 [DefaultValue(true)]
 369                 [Localizable(true)]
 370                 public virtual bool HelpVisible {
 371                         get {
 372                                 return help_panel.Visible;
 373                         }
 374
 375                         set {
 376                                 if (help_panel.Visible == value) {
 377                                         return;
 378                                 }
 379
 380                                 help_panel.Visible = value;
 381                         }
 382                 }
 383
 384                 public bool LargeButtons {
 385                         get {
 386                                 return large_buttons;
 387                         }
 388
 389                         set {
 390                                 if (large_buttons == value) {
 391                                         return;
 392                                 }
 393
 394                                 large_buttons = value;
 395                         }
 396                 }
 397
 398                 public Color LineColor {
 399                         get {
 400                                 return line_color;
 401                         }
 402
 403                         set {
 404                                 if (line_color == value) {
 405                                         return;
 406                                 }
 407
 408                                 line_color = value;
 409                         }
 410                 }
 411
 412                 [DefaultValue(PropertySort.CategorizedAlphabetical)]
 413                 public PropertySort PropertySort {
 414                         get {
 415                                 return property_sort;
 416                         }
 417
 418                         set {
 419                                 if (!Enum.IsDefined (typeof (PropertySort), value)) {
 420                                         throw new InvalidEnumArgumentException (string.Format("Enum argument value '{0}' is not valid for PropertySort", value));
 421                                 }
 422
 423                                 if (property_sort == value) {
 424                                         return;
 425                                 }
 426
 427                                 property_sort = value;
 428
 429                                 ReflectObjects();
 430                                 property_grid_view.Refresh();
 431
 432                                 if (PropertySortChanged != null) {
 433                                         PropertySortChanged(this, EventArgs.Empty);
 434                                 }
 435                         }
 436                 }
 437
 438                 [BrowsableAttribute(false)]
 439                 [EditorBrowsableAttribute(EditorBrowsableState.Advanced)]
 440                 [DesignerSerializationVisibilityAttribute(DesignerSerializationVisibility.Hidden)]
 441                 public PropertyTabCollection PropertyTabs {
 442                         get {
 443                                 return property_tabs;
 444                         }
 445                 }
 446
 447                 [BrowsableAttribute(false)]
 448                 [EditorBrowsableAttribute(EditorBrowsableState.Advanced)]
 449                 [DesignerSerializationVisibilityAttribute(DesignerSerializationVisibility.Hidden)]
 450                 public GridItem SelectedGridItem {
 451                         get {
 452                                 return selected_grid_item;
 453                         }
 454
 455                         set {
 456                                 if (selected_grid_item == value) {
 457                                         return;
 458                                 }
 459
 460                                 GridItem oldItem = selected_grid_item;
 461                                 selected_grid_item = value;
 462                                 this.help_title_label.Text = selected_grid_item.Label;
 463                                 if (selected_grid_item.PropertyDescriptor != null)
 464                                         this.help_description_label.Text = selected_grid_item.PropertyDescriptor.Description;
 465
 466                                 current_property_value = value.Value;
 467                                 if (oldItem != null && oldItem.PropertyDescriptor != null)
 468                                         oldItem.PropertyDescriptor.RemoveValueChanged(SelectedObject, new EventHandler(HandlePropertyValueChanged));
 469                                 if (selected_grid_item.PropertyDescriptor != null)
 470                                         selected_grid_item.PropertyDescriptor.AddValueChanged(SelectedObject, new EventHandler(HandlePropertyValueChanged));
 471                                 OnSelectedGridItemChanged(new SelectedGridItemChangedEventArgs( oldItem, selected_grid_item));
 472
 473                         }
 474                 }
 475
 476                 private void HandlePropertyValueChanged(object sender, EventArgs e) {
 477                         OnPropertyValueChanged(new PropertyValueChangedEventArgs( selected_grid_item, current_property_value));
 478                 }
 479
 480                 [DefaultValue(null)]
 481                 [TypeConverter("System.Windows.Forms.PropertyGrid+SelectedObjectConverter, " + Consts.AssemblySystem_Windows_Forms)]
 482                 public object SelectedObject {
 483                         get {
 484                                 return selected_objects[0];
 485                         }
 486
 487                         set {
 488                                 selected_objects = new object[] {value};
 489                                 if (this.SelectedObject == null)
 490                                         return;
 491                                 PropertyTabAttribute[] propTabs = (PropertyTabAttribute[])this.SelectedObject.GetType().GetCustomAttributes(typeof(PropertyTabAttribute),true);
 492                                 if (propTabs.Length > 0) {
 493                                         foreach (Type tabType in propTabs[0].TabClasses) {
 494                                                 this.PropertyTabs.AddTabType(tabType);
 495                                         }
 496                                 }
 497                                 RefreshTabs(PropertyTabScope.Component);
 498                                 ReflectObjects();
 499                                 property_grid_view.Refresh();
 500                         }
 501                 }
 502
 503                 [BrowsableAttribute(false)]
 504                 [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
 505                 public object[] SelectedObjects {
 506                         get {
 507                                 return selected_objects;
 508                         }
 509
 510                         set {
 511                                 selected_objects = value;
 512                                 ReflectObjects();
 513                         }
 514                 }
 515
 516                 [BrowsableAttribute(false)]
 517                 [EditorBrowsable(EditorBrowsableState.Advanced)]
 518                 [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
 519                 public PropertyTab SelectedTab {
 520                         get {
 521                                 return selected_tab;
 522                         }
 523                 }
 524
 525                 public override ISite Site {
 526                         get {
 527                                 return base.Site;
 528                         }
 529
 530                         set {
 531                                 base.Site = value;
 532                         }
 533                 }
 534
 535
 536                 [DefaultValue(true)]
 537                 public virtual bool ToolbarVisible {
 538                         get {
 539                                 return toolbar.Visible;
 540                         }
 541
 542                         set {
 543                                 if (toolbar.Visible == value) {
 544                                         return;
 545                                 }
 546
 547                                 toolbar.Visible = value;
 548                         }
 549                 }
 550
 551                 public Color ViewBackColor {
 552                         get {
 553                                 return property_grid_view.BackColor;
 554                         }
 555
 556                         set {
 557                                 if (property_grid_view.BackColor == value) {
 558                                         return;
 559                                 }
 560
 561                                 property_grid_view.BackColor = value;
 562                         }
 563                 }
 564
 565                 public Color ViewForeColor {
 566                         get {
 567                                 return property_grid_view.ForeColor;
 568                         }
 569
 570                         set {
 571                                 if (property_grid_view.ForeColor == value) {
 572                                         return;
 573                                 }
 574
 575                                 property_grid_view.ForeColor = value;
 576                         }
 577                 }
 578
 579                 #endregion      // Public Instance Properties
 580
 581                 #region Protected Instance Properties
 582
 583                 protected override Size DefaultSize {
 584                         get {
 585                                 return base.DefaultSize;
 586                         }
 587                 }
 588
 589
 590                 [Browsable(false)]
 591                 [EditorBrowsable(EditorBrowsableState.Advanced)]
 592                 [DesignerSerializationVisibilityAttribute(DesignerSerializationVisibility.Hidden)]
 593                 protected virtual Type DefaultTabType {
 594                         get {
 595                                 return typeof(PropertiesTab);
 596                         }
 597                 }
 598
 599                 protected bool DrawFlatToolbar {
 600                         get {
 601                                 return (toolbar.Appearance == ToolBarAppearance.Flat);
 602                         }
 603                         set {
 604                                 if (value)
 605                                         toolbar.Appearance = ToolBarAppearance.Flat;
 606                                 else
 607                                         toolbar.Appearance = ToolBarAppearance.Normal;
 608                         }
 609                 }
 610
 611                 protected override bool ShowFocusCues {
 612                         get {
 613                                 return base.ShowFocusCues;
 614                         }
 615                 }
 616
 617                 #endregion      // Protected Instance Properties
 618
 619                 #region Public Instance Methods
 620
 621                 protected override void Dispose(bool val) {
 622                         base.Dispose(val);
 623                 }
 624
 625                 public void CollapseAllGridItems () {
 626                         foreach (GridItem item in this.grid_items) {
 627                                 item.Expanded = false;
 628                         }
 629                 }
 630
 631                 public void ExpandAllGridItems () {
 632                         foreach (GridItem item in this.grid_items) {
 633                                 item.Expanded = true;
 634                         }
 635                 }
 636
 637                 public override void Refresh () {
 638                         base.Refresh ();
 639                 }
 640
 641                 public void RefreshTabs (PropertyTabScope tabScope) {
 642
 643                         /*button = new ToolBarButton("C");
 644                         button.ImageIndex = 0;
 645                         this.toolbar.Buttons.Add(button);
 646                         button = new ToolBarButton();
 647                         button.ImageIndex = 0;
 648                         button.Style = ToolBarButtonStyle.Separator;
 649                         this.toolbar.Buttons.Add(button);
 650                         foreach (PropertyTab tab in this.PropertyTabs)
 651                         {
 652
 653                                 int index = toolbar.ImageList.Images.Count;
 654                                 this.toolbar.ImageList.Images.Add(tab.Bitmap);
 655                                 button = new ToolBarButton();
 656                                 button.ImageIndex = index;
 657                                 this.toolbar.Buttons.Add(button);
 658                         }*/
 659
 660                 }
 661
 662                 public void ResetSelectedProperty() {
 663                         if (selected_grid_item == null || selected_grid_item.PropertyDescriptor == null)
 664                                 return;
 665
 666                         selected_grid_item.PropertyDescriptor.ResetValue(SelectedObject);
 667                 }
 668                 #endregion      // Public Instance Methods
 669
 670                 #region Protected Instance Methods
 671
 672                 protected virtual PropertyTab CreatePropertyTab(Type tabType) {
 673                         return (PropertyTab)Activator.CreateInstance(tabType);
 674                 }
 675
 676                 [MonoTODO]
 677                 protected void OnComComponentNameChanged(ComponentRenameEventArgs e) {
 678                         throw new NotImplementedException();
 679                 }
 680
 681                 protected override void OnFontChanged(EventArgs e) {
 682                         base.OnFontChanged (e);
 683                 }
 684
 685                 protected override void OnGotFocus(EventArgs e) {
 686                         base.OnGotFocus(e);
 687                 }
 688
 689                 protected override void OnHandleCreated (EventArgs e) {
 690                         base.OnHandleCreated (e);
 691                 }
 692
 693                 protected override void OnHandleDestroyed (EventArgs e) {
 694                         base.OnHandleDestroyed (e);
 695                 }
 696
 697                 protected override void OnMouseDown (MouseEventArgs e) {
 698                         base.OnMouseDown (e);
 699                 }
 700
 701                 protected override void OnMouseMove (MouseEventArgs e) {
 702                         base.OnMouseMove (e);
 703                 }
 704
 705                 protected override void OnMouseUp (MouseEventArgs e) {
 706                         base.OnMouseUp (e);
 707                 }
 708
 709                 [MonoTODO]
 710                 protected void OnNotifyPropertyValueUIItemsChanged(object sender, EventArgs e) {
 711                 }
 712
 713                 protected override void OnPaint (PaintEventArgs pevent) {
 714                         pevent.Graphics.FillRectangle(ThemeEngine.Current.ResPool.GetSolidBrush(BackColor), pevent.ClipRectangle);
 715                         base.OnPaint (pevent);
 716                 }
 717
 718                 [MonoTODO]
 719                 protected virtual void OnPropertyTabChanged (PropertyTabChangedEventArgs e) {
 720                         throw new NotImplementedException();
 721                 }
 722
 723                 protected virtual void OnPropertyValueChanged (PropertyValueChangedEventArgs e) {
 724                         if (PropertyValueChanged != null) {
 725                                 PropertyValueChanged(this, e);
 726                                 current_property_value = selected_grid_item.Value;
 727                         }
 728                 }
 729
 730                 protected override void OnResize (EventArgs e) {
 731                         base.OnResize (e);
 732                 }
 733
 734                 protected virtual void OnSelectedGridItemChanged (SelectedGridItemChangedEventArgs e) {
 735                         if (SelectedGridItemChanged != null) {
 736                                 SelectedGridItemChanged(this, e);
 737                         }
 738                 }
 739
 740                 protected virtual void OnSelectedObjectsChanged (EventArgs e) {
 741                         if (SelectedObjectsChanged != null) {
 742                                 SelectedObjectsChanged(this, e);
 743                         }
 744                 }
 745
 746                 protected override void OnSystemColorsChanged (EventArgs e) {
 747                         base.OnSystemColorsChanged (e);
 748                 }
 749
 750                 protected override void OnVisibleChanged (EventArgs e) {
 751                         base.OnVisibleChanged (e);
 752                 }
 753
 754                 protected override bool ProcessDialogKey (Keys keyData) {
 755                         return base.ProcessDialogKey (keyData);
 756                 }
 757
 758                 protected override void ScaleCore (float dx, float dy) {
 759                         base.ScaleCore (dx, dy);
 760                 }
 761
 762                 [MonoTODO]
 763                 protected void ShowEventsButton(bool value) {
 764                         throw new NotImplementedException();
 765                 }
 766
 767                 protected override void WndProc (ref Message m) {
 768                         base.WndProc (ref m);
 769                 }
 770                 #endregion
 771
 772                 #region Events
 773                 public event EventHandler PropertySortChanged;
 774                 public event PropertyTabChangedEventHandler PropertyTabChanged;
 775                 public event PropertyValueChangedEventHandler PropertyValueChanged;
 776                 public event SelectedGridItemChangedEventHandler SelectedGridItemChanged;
 777                 public event EventHandler SelectedObjectsChanged;
 778
 779                 [Browsable(false)]
 780                 [EditorBrowsable(EditorBrowsableState.Never)]
 781                 public new event EventHandler BackgroundImageChanged {
 782                         add { base.BackgroundImageChanged += value; }
 783                         remove { base.BackgroundImageChanged -= value; }
 784                 }
 785
 786                 [Browsable(false)]
 787                 [EditorBrowsable(EditorBrowsableState.Never)]
 788                 public new event EventHandler ForeColorChanged {
 789                         add { base.ForeColorChanged += value; }
 790                         remove { base.ForeColorChanged -= value; }
 791                 }
 792                 #endregion
 793
 794                 #region Com2Interop.IComPropertyBrowser Interface
 795                 [MonoTODO]
 796                 bool ComponentModel.Com2Interop.IComPropertyBrowser.InPropertySet {
 797                         get  {
 798                                 throw new NotImplementedException();
 799                         }
 800                 }
 801
 802                 [MonoTODO]
 803                 void ComponentModel.Com2Interop.IComPropertyBrowser.DropDownDone() {
 804                         throw new NotImplementedException();
 805                 }
 806
 807                 [MonoTODO]
 808                 bool ComponentModel.Com2Interop.IComPropertyBrowser.EnsurePendingChangesCommitted() {
 809                         throw new NotImplementedException();
 810                 }
 811
 812                 [MonoTODO]
 813                 void ComponentModel.Com2Interop.IComPropertyBrowser.HandleF4() {
 814                         throw new NotImplementedException();
 815                 }
 816
 817                 [MonoTODO]
 818                 void ComponentModel.Com2Interop.IComPropertyBrowser.LoadState(Microsoft.Win32.RegistryKey key) {
 819                         throw new NotImplementedException();
 820                 }
 821
 822                 [MonoTODO]
 823                 void ComponentModel.Com2Interop.IComPropertyBrowser.SaveState(Microsoft.Win32.RegistryKey key) {
 824                         throw new NotImplementedException();
 825                 }
 826
 827                 [MonoTODO]
 828                 private event ComponentRenameEventHandler com_component_name_changed;
 829                 event ComponentRenameEventHandler ComponentModel.Com2Interop.IComPropertyBrowser.ComComponentNameChanged {
 830                         add { com_component_name_changed += value; }
 831                         remove { com_component_name_changed -= value; }
 832                 }
 833                 #endregion      // Com2Interop.IComPropertyBrowser Interface
 834
 835                 #region PropertyTabCollection Class
 836                 public class PropertyTabCollection : ICollection, IEnumerable {
 837                         System.Collections.ArrayList list;
 838                         #region Private Constructors
 839                         internal PropertyTabCollection() {
 840                                 list = new ArrayList();
 841                         }
 842
 843                         #endregion      // Private Constructors
 844
 845                         public PropertyTab this[int index] {
 846                                 get {
 847                                         return (PropertyTab)list[index];
 848                                 }
 849                         }
 850
 851                         #region ICollection Members
 852                         bool ICollection.IsSynchronized {
 853                                 get {
 854                                         return list.IsSynchronized;
 855                                 }
 856                         }
 857
 858                         void ICollection.CopyTo(Array array, int index) {
 859                                 list.CopyTo(array, index);
 860                         }
 861
 862                         object ICollection.SyncRoot {
 863                                 get {
 864                                         return list.SyncRoot;
 865                                 }
 866                         }
 867
 868                         #endregion
 869
 870                         #region IEnumerable Members
 871                         public IEnumerator GetEnumerator() {
 872                                 return list.GetEnumerator();
 873                         }
 874
 875                         #endregion
 876
 877                         #region ICollection Members
 878                         public int Count {
 879                                 get {
 880                                         return list.Count;
 881                                 }
 882                         }
 883
 884                         #endregion
 885
 886                         #region Public Instance Methods
 887                         public void AddTabType(System.Type propertyTabType) {
 888                                 list.Add(Activator.CreateInstance(propertyTabType));
 889                         }
 890                         [MonoTODO]
 891                         public void AddTabType(System.Type propertyTabType,
 892                                 System.ComponentModel.PropertyTabScope tabScope) {
 893                                 AddTabType(propertyTabType);
 894                         }
 895                         [MonoTODO]
 896                         public void Clear(System.ComponentModel.PropertyTabScope tabScope) {
 897                                 throw new NotImplementedException();
 898                         }
 899                         [MonoTODO]
 900                         public void RemoveTabType(System.Type propertyTabType) {
 901                                 throw new NotImplementedException();
 902                         }
 903                         #endregion
 904                 }
 905                 #endregion      // PropertyTabCollection Class
 906
 907                 #region Private Helper Methods
 908
 909                 private void toolbar_ButtonClick (object sender, ToolBarButtonClickEventArgs e) {
 910                         if (e.Button == alphabetic_toolbarbutton) {
 911                                 this.PropertySort = PropertySort.Alphabetical;
 912                         }
 913                         else if (e.Button == categorized_toolbarbutton) {
 914                                 this.PropertySort = PropertySort.Categorized;
 915                         }
 916                         UpdateToolBarButtons();
 917                         ReflectObjects();
 918                         property_grid_view.Refresh();
 919                 }
 920
 921                 internal void UpdateToolBarButtons () {
 922                         if (PropertySort == PropertySort.Alphabetical) {
 923                                 categorized_toolbarbutton.Pushed = false;
 924                                 alphabetic_toolbarbutton.Pushed = true;
 925                         }
 926                         else if (PropertySort == PropertySort.Categorized) {
 927                                 categorized_toolbarbutton.Pushed = true;
 928                                 alphabetic_toolbarbutton.Pushed = false;
 929                         }
 930                         else {
 931                                 categorized_toolbarbutton.Pushed = false;
 932                                 alphabetic_toolbarbutton.Pushed = false;
 933                         }
 934                 }
 935
 936                 private void OnResetPropertyClick (object sender, EventArgs e) {
 937                         ResetSelectedProperty();
 938                 }
 939
 940                 private void OnDescriptionClick (object sender, EventArgs e) {
 941                         this.HelpVisible = !this.HelpVisible;
 942                         description_menuitem.Checked = this.HelpVisible;
 943
 944                 }
 945
 946                 private void ReflectObjects () {
 947                         grid_items = new GridItemCollection();
 948                         foreach (object obj in selected_objects) {
 949                                 if (obj != null) {
 950                                         PopulateGridItemCollection(obj,grid_items, true);
 951                                 }
 952                         }
 953                 }
 954
 955                 private void PopulateGridItemCollection (object obj, GridItemCollection grid_item_coll, bool recurse) {
 956                         if (!recurse && !TypeDescriptor.GetConverter(obj).GetPropertiesSupported())
 957                                 return;
 958                         PropertyDescriptorCollection properties = TypeDescriptor.GetProperties(obj);
 959                         foreach (PropertyDescriptor property in properties) {
 960                                 if (property.IsBrowsable) {
 961                                         GridEntry grid_entry = new GridEntry(obj, property);
 962                                         if (property_sort == PropertySort.Alphabetical || !recurse) {
 963                                                 if (grid_item_coll[property.Name] == null)
 964                                                         grid_item_coll.Add(property.Name,grid_entry);
 965                                         }
 966                                         else if (property_sort == PropertySort.Categorized || property_sort == PropertySort.CategorizedAlphabetical) {
 967
 968                                                 string category = property.Category;
 969                                                 GridItem cat_item = grid_item_coll[category];
 970                                                 if (cat_item == null) {
 971                                                         cat_item = new CategoryGridEntry(category);
 972                                                         grid_item_coll.Add(category,cat_item);
 973                                                 }
 974                                                 cat_item.GridItems.Add(property.Name,grid_entry);
 975                                         }
 976                                         if (recurse) {
 977                                                 object propObj = property.GetValue(obj);
 978                                                 if (propObj != null)
 979                                                         PopulateGridItemCollection(propObj,grid_entry.GridItems, false);
 980                                         }
 981                                         grid_entry.Expanded = false;
 982                                 }
 983                         }
 984                 }
 985
 986                 private void help_panel_Paint(object sender, PaintEventArgs e) {
 987                         e.Graphics.FillRectangle(ThemeEngine.Current.ResPool.GetSolidBrush(help_panel.BackColor), help_panel.ClientRectangle );
 988                         e.Graphics.DrawRectangle(SystemPens.ControlDark, 0,0,help_panel.Width-1,help_panel.Height-1 );
 989                 }
 990
 991                 #endregion      // Private Helper Methods
 992
 993
 994 #if NET_2_0
 995
 996                 public bool UseCompatibleTextRendering {
 997                         get {
 998                                 return use_compatible_text_rendering;
 999                         }
1000
1001                         set {
1002                                 use_compatible_text_rendering = value;
1003                         }
1004                 }
1005 #endif
1006
1007                 // as we can not change the color for BorderStyle.FixedSingle and we need the correct
1008                 // ClientRectangle so that the ScrollBar doesn't draw over the border we need this class
1009                 internal class BorderHelperControl : Control {
1010
1011                         protected override void OnPaint (PaintEventArgs e)
1012                         {
1013                                 e.Graphics.DrawRectangle (SystemPens.ControlDark, 0 , 0 , Width - 1, Height - 1);
1014                                 base.OnPaint (e);
1015                         }
1016
1017                         protected override void OnSizeChanged (EventArgs e)
1018                         {
1019                                 if (Controls.Count == 1) {
1020                                         Control control = Controls [0];
1021
1022                                         if (control.Location.X != 1 || control.Location.Y != 1)
1023                                                 control.Location = new Point (1, 1);
1024
1025                                         control.Width = ClientRectangle.Width - 2;
1026                                         control.Height = ClientRectangle.Height - 2;
1027
1028                                         Refresh ();
1029                                 }
1030                                 base.OnSizeChanged (e);
1031                         }
1032                 }
1033
1034                 // needed! this little helper makes it possible to draw a different toolbar border
1035                 // and toolbar backcolor in ThemeWin32Classic
1036                 internal class PropertyToolBar : ToolBar {}
1037         }
1038 }