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                                         return;
 510                                 foreach (Type tabType in propTabs[0].TabClasses)
 511                                 {
 512                                         this.PropertyTabs.AddTabType(tabType);
 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
 834                 [Browsable(false)]
 835                 [EditorBrowsable(EditorBrowsableState.Never)]
 836                 public new event EventHandler ForeColorChanged;
 837                 #endregion
 838
 839                 #region Com2Interop.IComPropertyBrowser Interface
 840                 [MonoTODO]
 841                 bool ComponentModel.Com2Interop.IComPropertyBrowser.InPropertySet {
 842                         get  {
 843                                 throw new NotImplementedException();
 844                         }
 845                 }
 846
 847                 [MonoTODO]
 848                 void ComponentModel.Com2Interop.IComPropertyBrowser.DropDownDone() {
 849                         throw new NotImplementedException();
 850                 }
 851
 852                 [MonoTODO]
 853                 bool ComponentModel.Com2Interop.IComPropertyBrowser.EnsurePendingChangesCommitted() {
 854                         throw new NotImplementedException();
 855                 }
 856
 857                 [MonoTODO]
 858                 void ComponentModel.Com2Interop.IComPropertyBrowser.HandleF4() {
 859                         throw new NotImplementedException();
 860                 }
 861
 862                 [MonoTODO]
 863                 void ComponentModel.Com2Interop.IComPropertyBrowser.LoadState(Microsoft.Win32.RegistryKey key) {
 864                         throw new NotImplementedException();
 865                 }
 866
 867                 [MonoTODO]
 868                 void ComponentModel.Com2Interop.IComPropertyBrowser.SaveState(Microsoft.Win32.RegistryKey key) {
 869                         throw new NotImplementedException();
 870                 }
 871
 872                 [MonoTODO]
 873                 private event ComponentRenameEventHandler com_component_name_changed;
 874                 event ComponentRenameEventHandler ComponentModel.Com2Interop.IComPropertyBrowser.ComComponentNameChanged {
 875                         add { com_component_name_changed += value; }
 876                         remove { com_component_name_changed -= value; }
 877                 }
 878                 #endregion      // Com2Interop.IComPropertyBrowser Interface
 879
 880                 #region PropertyTabCollection Class
 881                 public class PropertyTabCollection : ICollection, IEnumerable
 882                 {
 883                         System.Collections.ArrayList list;
 884                         #region Private Constructors
 885                         internal PropertyTabCollection() {
 886                                 list = new ArrayList();
 887                         }
 888
 889                         #endregion      // Private Constructors
 890
 891                         public PropertyTab this[int index] {
 892                                 get {
 893                                         return (PropertyTab)list[index];
 894                                 }
 895                         }
 896
 897                         #region ICollection Members
 898                         bool ICollection.IsSynchronized
 899                         {
 900                                 get {
 901                                         return list.IsSynchronized;
 902                                 }
 903                         }
 904
 905                         void ICollection.CopyTo(Array array, int index)
 906                         {
 907                                 list.CopyTo(array, index);
 908                         }
 909
 910                         object ICollection.SyncRoot
 911                         {
 912                                 get {
 913                                         return list.SyncRoot;
 914                                 }
 915                         }
 916
 917                         #endregion
 918
 919                         #region IEnumerable Members
 920                         public IEnumerator GetEnumerator() {
 921                                 return list.GetEnumerator();
 922                         }
 923
 924                         #endregion
 925
 926                         #region ICollection Members
 927                         public int Count {
 928                                 get {
 929                                         return list.Count;
 930                                 }
 931                         }
 932
 933                         #endregion
 934
 935                         #region Public Instance Methods
 936                         public void AddTabType(System.Type propertyTabType)
 937                         {
 938                                 list.Add(Activator.CreateInstance(propertyTabType));
 939                         }
 940                         [MonoTODO]
 941                         public void AddTabType(System.Type propertyTabType,
 942                                 System.ComponentModel.PropertyTabScope tabScope)
 943                         {
 944                                 AddTabType(propertyTabType);
 945                         }
 946                         [MonoTODO]
 947                         public void Clear(System.ComponentModel.PropertyTabScope tabScope)
 948                         {
 949                                 throw new NotImplementedException();
 950                         }
 951                         [MonoTODO]
 952                         public void RemoveTabType(System.Type propertyTabType)
 953                         {
 954                                 throw new NotImplementedException();
 955                         }
 956                         #endregion
 957                 }
 958                 #endregion      // PropertyTabCollection Class
 959
 960                 #region Private Helper Methods
 961
 962                 private void toolbar_ButtonClick (object sender, ToolBarButtonClickEventArgs e)
 963                 {
 964                         if (e.Button == alphabetic_toolbarbutton) {
 965                                 this.PropertySort = PropertySort.Alphabetical;
 966                         }
 967                         else if (e.Button == categorized_toolbarbutton) {
 968                                 this.PropertySort = PropertySort.Categorized;
 969                         }
 970                         UpdateToolBarButtons();
 971                         ReflectObjects();
 972                         Console.WriteLine("toolbar_ButtonClick");
 973                         property_grid_view.Refresh();
 974                 }
 975
 976                 internal void UpdateToolBarButtons ()
 977                 {
 978                         if (PropertySort == PropertySort.Alphabetical) {
 979                                 categorized_toolbarbutton.Pushed = false;
 980                                 alphabetic_toolbarbutton.Pushed = true;
 981                         }
 982                         else if (PropertySort == PropertySort.Categorized) {
 983                                 categorized_toolbarbutton.Pushed = true;
 984                                 alphabetic_toolbarbutton.Pushed = false;
 985                         }
 986                         else {
 987                                 categorized_toolbarbutton.Pushed = false;
 988                                 alphabetic_toolbarbutton.Pushed = false;
 989                         }
 990                 }
 991
 992                 private void OnResetPropertyClick (object sender, EventArgs e)
 993                 {
 994                         ResetSelectedProperty();
 995                 }
 996
 997                 private void OnDescriptionClick (object sender, EventArgs e)
 998                 {
 999                         this.HelpVisible = !this.HelpVisible;
1000                         description_menuitem.Checked = this.HelpVisible;
1001
1002                 }
1003
1004                 private void ReflectObjects ()
1005                 {
1006                         GridItemCollection alphabetical_grid_items = new GridItemCollection();
1007                         GridItemCollection category_grid_items = new GridItemCollection();
1008                         foreach (object obj in selected_objects) {
1009                                 if (obj != null) {
1010                                         PopulateGridItemCollection(obj,alphabetical_grid_items, category_grid_items);
1011                                 }
1012                         }
1013                         if (PropertySort == PropertySort.Alphabetical) {
1014                                 grid_items = alphabetical_grid_items;
1015                         }
1016                         // need to use categories
1017                         else {
1018                                 grid_items = category_grid_items;
1019                         }
1020                 }
1021
1022                 private void PopulateGridItemCollection (object obj, GridItemCollection grid_item_coll, GridItemCollection category_grid_item_coll)
1023                 {
1024                         //TypeConverter converter = TypeDescriptor.GetConverter(obj);
1025                         PropertyDescriptorCollection properties = TypeDescriptor.GetProperties(obj);
1026                         foreach (PropertyDescriptor property in properties) {
1027                                 if (property.IsBrowsable) {
1028                                         GridEntry grid_entry = new GridEntry(obj, property);
1029                                         grid_item_coll.Add(property.Name,grid_entry);
1030
1031                                         string category = property.Category;
1032                                         GridItem cat_item = category_grid_item_coll[category];
1033                                         if (cat_item == null) {
1034                                                 cat_item = new CategoryGridEntry(category);
1035                                                 category_grid_item_coll.Add(category,cat_item);
1036                                         }
1037                                         cat_item.GridItems.Add(property.Name,grid_entry);
1038                                 }
1039                         }
1040                 }
1041
1042                 #endregion      // Private Helper Methods
1043
1044                 private void help_panel_Paint(object sender, PaintEventArgs e)
1045                 {
1046                         e.Graphics.FillRectangle(ThemeEngine.Current.ResPool.GetSolidBrush(help_panel.BackColor), help_panel.ClientRectangle );
1047                         e.Graphics.DrawRectangle(SystemPens.ControlDark, 0,0,help_panel.Width-1,help_panel.Height-1 );
1048                 }
1049         }
1050 }