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