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