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

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