wxruby3 0.9.0.pre.beta.2-x64-mingw-ucrt-3.2-3.2.2

data/samples/propgrid/propgrid.rb

@@ -0,0 +1,2707 @@
+###
+# PropertyGrid extended sample
+# Copyright (c) M.J.N. Corino, The Netherlands
+###
+
+require 'wx'
+
+require_relative './propgrid_minimal'
+
+# -----------------------------------------------------------------------
+# WxSampleMultiButtonEditor
+#   A sample editor class that has multiple buttons.
+# -----------------------------------------------------------------------
+
+class WxSampleMultiButtonEditor < Wx::PG::PGTextCtrlEditor
+
+  def initialize
+    super
+  end
+
+  def create_controls(propGrid, property, pos, sz)
+    # Create and populate buttons-subwindow
+    buttons = Wx::PG::PGMultiButton.new(propGrid, sz)
+
+    # Add two regular buttons
+    buttons.add('...')
+    buttons.add('A')
+    # Add a bitmap button
+    buttons.add(Wx::ArtProvider::get_bitmap(Wx::ART_FOLDER))
+
+    # Create the 'primary' editor control (textctrl in this case)
+    primary, _ = super(propGrid, property, pos, buttons.primary_size)
+
+    # Finally, move buttons-subwindow to correct position and make sure
+    # returned Wx::PG::PGWindowList contains our custom button list.
+    buttons.finalize(propGrid, pos)
+
+    [primary, buttons]
+  end
+
+  def on_event(propGrid, property, ctrl, event)
+    if event.event_type == Wx::EVT_BUTTON
+      buttons = propGrid.get_editor_control_secondary
+
+      if event.id == buttons.button_id(0)
+
+        # Do something when the first button is pressed
+        Wx::log_info('First button pressed')
+        return false # Return false since value did not change
+      end
+      if event.id == buttons.get_button_id(1)
+
+        # Do something when the second button is pressed
+        Wx.message_box('Second button pressed')
+        return false # Return false since value did not change
+      end
+      if event.id == buttons.button_id(2)
+        # Do something when the third button is pressed
+        Wx.message_box('Third button pressed')
+        return false # Return false since value did not change
+      end
+    end
+    super(propGrid, property, ctrl, event)
+  end
+
+end # class WxSampleMultiButtonEditor
+
+if Wx.has_feature?(:USE_VALIDATORS)
+
+  class WxInvalidWordValidator < Wx::Validator
+
+    def initialize(invalidWord)
+      super()
+      @invalidWord = invalidWord
+    end
+
+    def clone
+      return WxInvalidWordValidator.new(@invalidWord)
+    end
+
+    def validate(parent_)
+      tc = get_window
+      raise 'validator window must be wxTextCtrl' unless Wx::TextCtrl === tc
+
+      val = tc.value
+
+      return true unless val.index(@invalidWord)
+
+      Wx.message_box("%s is not allowed word" % @invalidWord,
+                     "Validation Failure")
+      false
+    end
+
+  end # class WxInvalidWordValidator
+
+end
+
+# -----------------------------------------------------------------------
+# WxVectorProperty
+# -----------------------------------------------------------------------
+
+class WxVectorProperty < Wx::PG::PGProperty
+
+  WxVector3f = Struct.new(:x, :y, :z) do |klass|
+    def initialize
+      self.x = self.y = self.z = 0.0
+    end
+  end
+
+  def initialize(label = Wx::PG::PG_LABEL, name = Wx::PG::PG_LABEL, value = WxVector3f.new)
+    super(label, name)
+    self.value = value
+    add_private_child(Wx::PG::FloatProperty.new("X",Wx::PG::PG_LABEL, value.x))
+    add_private_child(Wx::PG::FloatProperty.new("Y",Wx::PG::PG_LABEL, value.y))
+    add_private_child(Wx::PG::FloatProperty.new("Z",Wx::PG::PG_LABEL, value.z))
+  end
+
+  def child_changed(thisValue, childIndex, childValue)
+    vector = thisValue.object;
+    case childIndex
+    when 0
+      vector.x = childValue.to_f
+    when 1
+      vector.y = childValue.to_f
+    when 2
+      vector.z = childValue.to_f
+    end
+    Wx::Variant.new(vector)
+  end
+
+  def refresh_children
+    return if get_child_count == 0
+    vector = self.value_.object
+    item(0).value = vector.x
+    item(1).value = vector.y
+    item(2).value = vector.z
+  end
+
+end # class WxVectorProperty
+
+# -----------------------------------------------------------------------
+# Wx::PG::TriangleProperty
+# -----------------------------------------------------------------------
+
+class WxTriangleProperty < Wx::PG::PGProperty
+
+  WxTriangle = Struct.new(:a, :b, :c) do |klass|
+    def initialize
+      self.a = WxVectorProperty::WxVector3f.new
+      self.b = WxVectorProperty::WxVector3f.new
+      self.c = WxVectorProperty::WxVector3f.new
+    end
+  end
+
+  def initialize(label = Wx::PG::PG_LABEL, name = Wx::PG::PG_LABEL, value = WxTriangle.new)
+    super(label, name)
+    self.value = value
+    add_private_child(WxVectorProperty.new("A", Wx::PG::PG_LABEL, value.a.dup))
+    add_private_child(WxVectorProperty.new("B", Wx::PG::PG_LABEL, value.b.dup))
+    add_private_child(WxVectorProperty.new("C", Wx::PG::PG_LABEL, value.c.dup))
+  end
+
+  def child_changed(thisValue, childIndex, childValue)
+    triangle = thisValue.object.dup
+    vector = childValue.object.dup
+    case childIndex
+    when 0
+      triangle.a = vector
+    when 1
+      triangle.b = vector
+    when 2
+      triangle.c = vector
+    end
+    Wx::Variant.new(triangle)
+  end
+
+  def refresh_children
+    return if get_child_count == 0
+    triangle = self.value_.object
+    item(0).value = triangle.a
+    item(1).value = triangle.b
+    item(2).value = triangle.c
+  end
+
+end # class WxTriangleProperty
+
+
+# -----------------------------------------------------------------------
+# wxSingleChoiceDialogAdapter (Wx::PG::PGEditorDialogAdapter sample)
+# -----------------------------------------------------------------------
+
+class WxSingleChoiceDialogAdapter < Wx::PG::PGEditorDialogAdapter
+
+  def initialize(choices)
+    super()
+    @choices = choices
+  end
+
+  def do_show_dialog(propGrid_, property_)
+    s = Wx.get_single_choice("Message",
+                             "Caption",
+                             @choices.labels)
+    unless s.empty?
+      value = s
+      return true
+    end
+
+    return false
+  end
+
+end # class WxSingleChoiceDialogAdapter
+
+class WxSingleChoiceProperty < Wx::PG::StringProperty
+
+  def initialize(label, name = Wx::PG::PG_LABEL, value = '')
+    super(label, name, value)
+    # Prepare choices
+    @choices = Wx::PG::PGChoices.new
+    @choices.add("Cat")
+    @choices.add("Dog")
+    @choices.add("Gibbon")
+    @choices.add("Otter")
+  end
+
+  # Set editor to have button
+  def do_get_editor_class
+    Wx::PG::PG_EDITOR_TEXT_CTRL_AND_BUTTON
+  end
+
+  # Set what happens on button click
+  def get_editor_dialog
+    WxSingleChoiceDialogAdapter.new(@choices)
+  end
+
+end # class SingleChoiceProperty
+
+#
+# Test customizing wxColourProperty via subclassing
+#
+# * Includes custom colour entry.
+# * Includes extra custom entry.
+#
+class MyColourProperty < Wx::PG::ColourProperty
+
+  def initialize(label = Wx::PG::PG_LABEL,
+                 name = Wx::PG::PG_LABEL,
+                 value = Wx::WHITE )
+    super(label, name, value)
+    self.choices = Wx::PG::PGChoices.new(%w[White Black Red Green Blue Custom None])
+    set_index(0)
+    self.value = value
+  end
+
+  def get_colour(index)
+    case index
+    when 0
+      return Wx::WHITE
+    when 1
+      return Wx::BLACK
+    when 2
+      return Wx::RED
+    when 3
+      return Wx::GREEN
+    when 4
+      return Wx::BLUE
+    when 5
+      # Return current colour for the custom entry
+      if get_index == get_custom_colour_index
+        return self.value_.colour unless self.value_.null?
+      else
+        return Wx::WHITE
+      end
+    end
+    Wx::Colour.new
+  end
+
+  def colour_to_string(col, index, argFlags = 0)
+    return '' if index == (self.choices.get_count-1)
+
+    super(col, index, argFlags)
+  end
+
+  def get_custom_colour_index
+    self.choices.get_count-2
+  end
+end
+
+module ID
+  %i[
+    PGID
+    ABOUT
+    QUIT
+    APPENDPROP
+    APPENDCAT
+    INSERTPROP
+    INSERTCAT
+    ENABLE
+    SETREADONLY
+    HIDE
+    BOOL_CHECKBOX
+    DELETE
+    DELETER
+    DELETEALL
+    UNSPECIFY
+    ITERATE1
+    ITERATE2
+    ITERATE3
+    ITERATE4
+    CLEARMODIF
+    FREEZE
+    DUMPLIST
+    COLOURSCHEME1
+    COLOURSCHEME2
+    COLOURSCHEME3
+    CATCOLOURS
+    SETBGCOLOUR
+    SETBGCOLOURRECUR
+    STATICLAYOUT
+    POPULATE1
+    POPULATE2
+    COLLAPSE
+    COLLAPSEALL
+    GETVALUES
+    SETVALUES
+    SETVALUES2
+    RUNTESTFULL
+    RUNTESTPARTIAL
+    FITCOLUMNS
+    CHANGEFLAGSITEMS
+    TESTINSERTCHOICE
+    TESTDELETECHOICE
+    INSERTPAGE
+    REMOVEPAGE
+    SETSPINCTRLEDITOR
+    SETPROPERTYVALUE
+    TESTREPLACE
+    SETCOLUMNS
+    SETVIRTWIDTH
+    SETPGDISABLED
+    TESTXRC
+    ENABLECOMMONVALUES
+    SELECTSTYLE
+    SAVESTATE
+    RESTORESTATE
+    RUNMINIMAL
+    ENABLELABELEDITING
+    VETOCOLDRAG
+    ONEXTENDEDKEYNAV
+    SHOWPOPUP
+    POPUPGRID
+  ].each_with_index { |sym, ix| self.const_set(sym, ix+1) }
+
+  if Wx.has_feature?(:USE_HEADERCTRL)
+    SHOWHEADER = POPUPGRID+1
+  end
+
+  COLOURSCHEME4 = 100
+end
+
+#
+# Handle events of the third page here.
+class WxMyPropertyGridPage < Wx::PG::PropertyGridPage
+
+  def initialize
+    super
+    evt_pg_selected(Wx::ID_ANY, :on_property_select)
+    evt_pg_changing(Wx::ID_ANY, :on_property_changing)
+    evt_pg_changed(Wx::ID_ANY, :on_property_change)
+    evt_pg_page_changed(Wx::ID_ANY, :on_page_change)
+  end
+
+  # Return false here to indicate unhandled events should be
+  # propagated to manager's parent, as normal.
+  def is_handling_all_events; false; end
+
+  def do_insert(parent, index, property)
+    super(parent,index,property)
+  end
+
+  def on_property_select(event)
+    Wx.log_debug("WxMyPropertyGridPage#on_property_select('%s' is %s",
+                 event.property.get_name,
+                 (property_selected?(event.property) ? "selected": "unselected"))
+  end
+  def on_property_changing(event)
+    Wx.log_verbose("WxMyPropertyGridPage#on_property_change('%s', to value '%s')",
+                   event.property.get_name,
+                   event.property.get_displayed_string)
+  end
+  def on_property_change(event)
+    Wx.log_verbose("WxMyPropertyGridPage#on_property_changing('%s', to value '%s')",
+                   event.property.get_name,
+                   event.value.to_s)
+  end
+  def on_page_change(event)
+    Wx.log_debug("WxMyPropertyGridPage#on_page_change()")
+  end
+
+end # class WxMyPropertyGridPage
+
+
+class WxPGKeyHandler < Wx::EvtHandler
+
+  def initialize
+    super
+    evt_key_down :on_key_event
+  end
+
+  def on_key_event(event)
+    Wx.message_box("%i" % event.get_key_code)
+    event.skip
+  end
+
+end
+
+class PropertyGridPopup < Wx::PopupWindow
+
+  private def get_real_root(grid)
+    property = grid.root
+    property ? grid.get_first_child(property) : nil
+  end
+
+  private def get_column_widths(grid, root)
+    state = grid.get_state
+
+    width = [0,0,0]
+    minWidths = [ state.get_column_min_width(0),
+                  state.get_column_min_width(1),
+                  state.get_column_min_width(2) ]
+    root.child_count.times do |ii|
+      p = root.item(ii)
+
+      width[0] = [width[0], state.get_column_full_width(p, 0)].max
+      width[1] = [width[1], state.get_column_full_width(p, 1)].max
+      width[2] = [width[2], state.get_column_full_width(p, 2)].max
+    end
+    root.child_count.times do |ii|
+      p = root.item(ii)
+      if p.is_expanded
+        w = get_column_widths(grid, p)
+        width[0] = [width[0], w[0]].max
+        width[1] = [width[1], w[1]].max
+        width[2] = [width[2], w[2]].max
+      end
+    end
+
+    width[0] = [width[0], minWidths[0]].max
+    width[1] = [width[1], minWidths[1]].max
+    width[2] = [width[2], minWidths[2]].max
+    width
+  end
+
+  private def set_popup_min_size(grid)
+    p = get_real_root(grid)
+    first = grid.get_first(Wx::PG::PG_ITERATE_ALL)
+    last = grid.get_last_item(Wx::PG::PG_ITERATE_DEFAULT)
+    rect = grid.get_property_rect(first, last)
+    height = rect.height + 2 * grid.get_vertical_spacing
+
+    # add some height when the root item is collapsed,
+    # this is needed to prevent the vertical scroll from showing
+    unless grid.is_property_expanded(p)
+      height += 2 * grid.get_vertical_spacing
+    end
+
+    width = get_column_widths(grid, grid.root)
+    rect.width = width.sum
+
+    minWidth = (Wx::SystemSettings.get_metric(Wx::SYS_SCREEN_X, grid.get_parent)*3)/2
+    minHeight = (Wx::SystemSettings.get_metric(Wx::SYS_SCREEN_Y, grid.get_parent)*3)/2
+
+    size = [[minWidth, rect.width + grid.get_margin_width].min, [minHeight, height].min]
+    grid.set_min_size(size)
+
+    proportions = [ (100.0*width[0]/size[0]).round,
+                    (100.0*width[1]/size[0]).round ]
+    proportions << [100 - proportions[0] - proportions[1], 0].max
+    grid.set_column_proportion(0, proportions[0])
+    grid.set_column_proportion(1, proportions[1])
+    grid.set_column_proportion(2, proportions[2])
+    grid.reset_column_sizes(true)
+  end
+
+  def initialize(parent)
+    super(parent, Wx::BORDER_NONE|Wx::WANTS_CHARS|Wx::PU_CONTAINS_CONTROLS)
+    @panel = Wx::ScrolledWindow.new(self, Wx::ID_ANY, size: Wx::Size.new(200, 200))
+    @grid = Wx::PG::PropertyGrid.new(@panel, ID::POPUPGRID, size: [400,400], style: Wx::PG::PG_SPLITTER_AUTO_CENTER)
+    @grid.set_column_count(3)
+
+    prop = @grid.append(Wx::PG::StringProperty.new("test_name", Wx::PG::PG_LABEL, "test_value"))
+    @grid.set_property_attribute(prop, Wx::PG::PG_ATTR_UNITS, "type")
+    prop1 = @grid.append_in(prop, Wx::PG::StringProperty.new("sub_name1", Wx::PG::PG_LABEL, "sub_value1"))
+
+    @grid.append_in(prop1, Wx::PG::SystemColourProperty.new("Cell Colour", Wx::PG::PG_LABEL, @grid.grid.get_cell_background_colour))
+    prop2 = @grid.append_in(prop, Wx::PG::StringProperty.new("sub_name2", Wx::PG::PG_LABEL, "sub_value2"))
+    @grid.append_in(prop2, Wx::PG::StringProperty.new("sub_name21", Wx::PG::PG_LABEL, "sub_value21"))
+
+    arrdbl = [-1.0, -0.5, 0.0, 0.5, 1.0]
+    @grid.append_in(prop, WxArrayDoubleProperty.new("ArrayDoubleProperty", Wx::PG::PG_LABEL, arrdbl))
+    @grid.append_in(prop, Wx::PG::FontProperty.new("Font", Wx::PG::PG_LABEL))
+    @grid.append_in(prop2, Wx::PG::StringProperty.new("sub_name22", Wx::PG::PG_LABEL, "sub_value22"))
+    @grid.append_in(prop2, Wx::PG::StringProperty.new("sub_name23", Wx::PG::PG_LABEL, "sub_value23"))
+    prop2.set_expanded(false)
+
+    set_popup_min_size(@grid)
+
+    @sizer = Wx::BoxSizer.new(Wx::VERTICAL)
+    @sizer.add(@grid, Wx::SizerFlags.new(0).expand.border(Wx::ALL, 0))
+    @panel.set_auto_layout(true)
+    @panel.set_sizer(@sizer)
+    @sizer.fit(@panel)
+    @sizer.fit(self)
+    
+    evt_pg_item_collapsed ID::POPUPGRID, :on_collapse
+    evt_pg_item_expanded ID::POPUPGRID, :on_expand
+  end
+
+  def on_collapse(event)
+    Wx.log_message("OnCollapse")
+    fit
+  end
+
+  def on_expand(event)
+    Wx.log_message("OnExpand")
+    fit
+  end
+
+  def fit
+    set_popup_min_size(@grid)
+    @sizer.fit(@panel)
+    pos = get_screen_position
+    size = @panel.get_screen_rect.size
+    set_size(pos.x, pos.y, size.width, size.height)
+  end
+
+end
+
+class FormMain < Wx::Frame
+
+  FS_WINDOWSTYLE_LABELS = %w[
+    wxSIMPLE_BORDER wxDOUBLE_BORDER wxSUNKEN_BORDER wxRAISED_BORDER wxNO_BORDER 
+    wxTRANSPARENT_WINDOW wxTAB_TRAVERSAL wxWANTS_CHARS wxVSCROLL wxALWAYS_SHOW_SB 
+    wxCLIP_CHILDREN wxFULL_REPAINT_ON_RESIZE]
+
+  FS_WINDOWSTYLE_VALUES = [
+    Wx::SIMPLE_BORDER,
+    Wx::DOUBLE_BORDER,
+    Wx::SUNKEN_BORDER,
+    Wx::RAISED_BORDER,
+    Wx::NO_BORDER,
+    Wx::TRANSPARENT_WINDOW,
+    Wx::TAB_TRAVERSAL,
+    Wx::WANTS_CHARS,
+    Wx::VSCROLL,
+    Wx::ALWAYS_SHOW_SB,
+    Wx::CLIP_CHILDREN,
+    Wx::FULL_REPAINT_ON_RESIZE
+  ]
+
+  FS_FRAMESTYLE_LABELS = %w[
+    wxCAPTION wxMINIMIZE wxMAXIMIZE wxCLOSE_BOX wxSTAY_ON_TOP wxSYSTEM_MENU
+    wxRESIZE_BORDER wxFRAME_TOOL_WINDOW wxFRAME_NO_TASKBAR
+    wxFRAME_FLOAT_ON_PARENT wxFRAME_SHAPED]
+
+  FS_FRAMESTYLE_VALUES = [
+    Wx::CAPTION,
+    Wx::MINIMIZE,
+    Wx::MAXIMIZE,
+    Wx::CLOSE_BOX,
+    Wx::STAY_ON_TOP,
+    Wx::SYSTEM_MENU,
+    Wx::RESIZE_BORDER,
+    Wx::FRAME_TOOL_WINDOW,
+    Wx::FRAME_NO_TASKBAR,
+    Wx::FRAME_FLOAT_ON_PARENT,
+    Wx::FRAME_SHAPED
+  ]
+  
+  def initialize(title, pos, size)
+    super(nil, title: title, pos: pos, size: size,
+          style: (Wx::MINIMIZE_BOX|Wx::MAXIMIZE_BOX|Wx::RESIZE_BORDER|Wx::SYSTEM_MENU|
+                  Wx::CAPTION|Wx::TAB_TRAVERSAL|Wx::CLOSE_BOX))
+    @propGridManager = nil
+    @propGrid = nil
+    @hasHeader = false
+    @labelEditingEnabled = false
+    @combinedFlags = Wx::PG::PGChoices.new
+
+    self.icon = Wx::Icon.new(local_icon_file('../sample.xpm'))
+    centre
+
+    # This is default in wxRuby
+    # if Wx.has_feature?(:USE_IMAGE)
+    #   # This is here to really test the Wx::PG::ImageFileProperty.
+    #   wxInitAllImageHandlers()
+    # end
+
+    # Create menu bar
+    menuFile = Wx::Menu.new('', Wx::MENU_TEAROFF)
+    menuTry = Wx::Menu.new
+    menuTools1 = Wx::Menu.new
+    menuTools2 = Wx::Menu.new
+    menuHelp = Wx::Menu.new
+
+    menuHelp.append(ID::ABOUT, '&About', 'Show about dialog')
+
+    menuTools1.append(ID::APPENDPROP, 'Append New Property')
+    menuTools1.append(ID::APPENDCAT, "Append New Category\tCtrl-S")
+    menuTools1.append_separator
+    menuTools1.append(ID::INSERTPROP, "Insert New Property\tCtrl-I")
+    menuTools1.append(ID::INSERTCAT, "Insert New Category\tCtrl-W")
+    menuTools1.append_separator
+    menuTools1.append(ID::DELETE, 'Delete Selected')
+    menuTools1.append(ID::DELETER, 'Delete Random')
+    menuTools1.append(ID::DELETEALL, 'Delete All')
+    menuTools1.append_separator
+    menuTools1.append(ID::POPULATE1, 'Populate with Standard Items')
+    menuTools1.append(ID::POPULATE2, 'Populate with Library Configuration')
+    menuTools1.append_separator
+    menuTools1.append(ID::SETBGCOLOUR, 'Set Bg Colour')
+    menuTools1.append(ID::SETBGCOLOURRECUR, 'Set Bg Colour (Recursively)')
+    menuTools1.append(ID::UNSPECIFY, 'Set Value to Unspecified')
+    menuTools1.append_separator
+    @itemEnable = menuTools1.append(ID::ENABLE, 'Enable',
+                                      'Toggles item\'s enabled state.')
+    @itemEnable.enable(false)
+    menuTools1.append(ID::HIDE, 'Hide', 'Hides a property')
+    menuTools1.append(ID::SETREADONLY, 'Set as Read-Only',
+                       'Set property as read-only')
+
+    menuTools2.append(ID::ITERATE1, 'Iterate Over Properties')
+    menuTools2.append(ID::ITERATE2, 'Iterate Over Visible Items')
+    menuTools2.append(ID::ITERATE3, 'Reverse Iterate Over Properties')
+    menuTools2.append(ID::ITERATE4, 'Iterate Over Categories')
+    menuTools2.append_separator
+    menuTools2.append(ID::ONEXTENDEDKEYNAV, 'Extend Keyboard Navigation',
+                       'This will set Enter to navigate to next property, '+
+                       'and allows arrow keys to navigate even when in '+
+                       'editor control.')
+    menuTools2.append_separator
+    menuTools2.append(ID::SETPROPERTYVALUE, 'Set Property Value')
+    menuTools2.append(ID::CLEARMODIF, 'Clear Modified Status', 'Clears Wx::PG::PG_MODIFIED flag from all properties.')
+    menuTools2.append_separator
+    @itemFreeze = menuTools2.append_check_item(ID::FREEZE, 'Freeze',
+                                               'Disables painting, auto-sorting, etc.')
+    menuTools2.append_separator
+    menuTools2.append(ID::DUMPLIST, 'Display Values as wxVariant List', 'Tests GetAllValues method and wxVariant conversion.')
+    menuTools2.append_separator
+    menuTools2.append(ID::GETVALUES, 'Get Property Values', 'Stores all property values.')
+    menuTools2.append(ID::SETVALUES, 'Set Property Values', 'Reverts property values to those last stored.')
+    menuTools2.append(ID::SETVALUES2, 'Set Property Values 2', 'Adds property values that should not initially be as items (so new items are created).')
+    menuTools2.append_separator
+    menuTools2.append(ID::SAVESTATE, 'Save Editable State')
+    menuTools2.append(ID::RESTORESTATE, 'Restore Editable State')
+    menuTools2.append_separator
+    menuTools2.append(ID::ENABLECOMMONVALUES, 'Enable Common Value',
+                       'Enable values that are common to all properties, for selected property.')
+    menuTools2.append_separator
+    menuTools2.append(ID::COLLAPSE, 'Collapse Selected')
+    menuTools2.append(ID::COLLAPSEALL, 'Collapse All')
+    menuTools2.append_separator
+    menuTools2.append(ID::INSERTPAGE, 'Add Page')
+    menuTools2.append(ID::REMOVEPAGE, 'Remove Page')
+    menuTools2.append_separator
+    menuTools2.append(ID::FITCOLUMNS, 'Fit Columns')
+    @itemVetoDragging =
+      menuTools2.append_check_item(ID::VETOCOLDRAG,
+                                  'Veto Column Dragging')
+    menuTools2.append_separator
+    menuTools2.append(ID::CHANGEFLAGSITEMS, 'Change Children of FlagsProp')
+    menuTools2.append_separator
+    menuTools2.append(ID::TESTINSERTCHOICE, 'Test InsertPropertyChoice')
+    menuTools2.append(ID::TESTDELETECHOICE, 'Test DeletePropertyChoice')
+    menuTools2.append_separator
+    menuTools2.append(ID::SETSPINCTRLEDITOR, 'Use SpinCtrl Editor')
+    menuTools2.append(ID::TESTREPLACE, 'Test ReplaceProperty')
+
+    menuTry.append(ID::SELECTSTYLE, 'Set Window Style',
+                    'Select window style flags used by the grid.')
+    menuTry.append_check_item(ID::ENABLELABELEDITING, 'Enable label editing',
+                             'This calls wxPropertyGrid::MakeColumnEditable(0)')
+    menuTry.check(ID::ENABLELABELEDITING, @labelEditingEnabled)
+    if Wx.has_feature?(:USE_HEADERCTRL)
+      menuTry.append_check_item(ID::SHOWHEADER,
+                               'Enable header',
+                               'This calls wxPropertyGridManager::ShowHeader()')
+      menuTry.check(ID::SHOWHEADER, @hasHeader)
+    end # USE_HEADERCTRL
+    menuTry.append_separator
+    menuTry.append_radio_item(ID::COLOURSCHEME1, 'Standard Colour Scheme')
+    menuTry.append_radio_item(ID::COLOURSCHEME2, 'White Colour Scheme')
+    menuTry.append_radio_item(ID::COLOURSCHEME3, '.NET Colour Scheme')
+    menuTry.append_radio_item(ID::COLOURSCHEME4, 'Cream Colour Scheme')
+    menuTry.append_separator
+    @itemCatColours = menuTry.append_check_item(ID::CATCOLOURS, 'Category Specific Colours',
+                                                'Switches between category-specific cell colours and default scheme (actually done using SetPropertyTextColour and SetPropertyBackgroundColour).')
+    menuTry.append_separator
+    menuTry.append_check_item(ID::STATICLAYOUT, 'Static Layout',
+                             'Switches between user-modifiable and static layouts.')
+    menuTry.append_check_item(ID::BOOL_CHECKBOX, 'Render Boolean values as checkboxes',
+                             'Renders Boolean values as checkboxes')
+    menuTry.append(ID::SETCOLUMNS, 'Set Number of Columns')
+    menuTry.append(ID::SETVIRTWIDTH, 'Set Virtual Width')
+    menuTry.append_check_item(ID::SETPGDISABLED, 'Disable Grid')
+    menuTry.append_separator
+    menuTry.append(ID::TESTXRC, 'Display XRC sample')
+
+    menuFile.append(ID::RUNMINIMAL, 'Run Minimal Sample')
+    menuFile.append_separator
+    menuFile.append(ID::RUNTESTFULL, 'Run Tests (full)')
+    menuFile.append(ID::RUNTESTPARTIAL, 'Run Tests (fast)')
+    menuFile.append_separator
+    menuFile.append(ID::QUIT, "E&xit\tAlt-X", 'Quit this program')
+
+    # Now append the freshly created menu to the menu bar...
+    menuBar = Wx::MenuBar.new
+    menuBar.append(menuFile, '&File')
+    menuBar.append(menuTry, '&Try These!')
+    menuBar.append(menuTools1, '&Basic')
+    menuBar.append(menuTools2, '&Advanced')
+    menuBar.append(menuHelp, '&Help')
+
+    # ... and attach this menu bar to the frame
+    self.menu_bar = menuBar
+
+    if Wx.has_feature?(:USE_STATUSBAR)
+      # create a status bar
+      create_status_bar(1)
+      set_status_text('')
+    end # USE_STATUSBAR
+
+    # this is default with wxRuby
+    # Register all editors (SpinCtrl etc.)
+    # wxPropertyGridInterface::RegisterAdditionalEditors()
+
+    # Register our sample custom editors
+    @sampleMultiButtonEditor =
+      Wx::PG::PropertyGrid.register_editor_class(WxSampleMultiButtonEditor.new)
+
+    @panel = Wx::Panel.new(self, Wx::ID_ANY, Wx::DEFAULT_POSITION, Wx::DEFAULT_SIZE, Wx::TAB_TRAVERSAL)
+
+    style = Wx::PG::PG_BOLD_MODIFIED |
+      Wx::PG::PG_SPLITTER_AUTO_CENTER |
+      Wx::PG::PG_AUTO_SORT |
+      #Wx::PG::PG_HIDE_MARGIN|Wx::PG::PG_STATIC_SPLITTER |
+      #Wx::PG::PG_TOOLTIPS |
+      #Wx::PG::PG_HIDE_CATEGORIES |
+      #Wx::PG::PG_LIMITED_EDITING |
+      Wx::PG::PG_TOOLBAR |
+      Wx::PG::PG_DESCRIPTION
+    # extra style
+    xtra_style = Wx::PG::PG_EX_MODE_BUTTONS |
+      Wx::PG::PG_EX_MULTIPLE_SELECTION
+      #| Wx::PG::PG_EX_AUTO_UNSPECIFIED_VALUES
+      #| Wx::PG::PG_EX_GREY_LABEL_WHEN_DISABLED
+      #| Wx::PG::PG_EX_HELP_AS_TOOLTIPS
+    if Wx.has_feature?(:ALWAYS_NATIVE_DOUBLE_BUFFER)
+      xtra_style |= Wx::PG::PG_EX_NATIVE_DOUBLE_BUFFERING
+    end # ALWAYS_NATIVE_DOUBLE_BUFFER
+
+    create_grid(style, xtra_style)
+    
+    @topSizer = Wx::BoxSizer.new(Wx::VERTICAL)
+
+    @topSizer.add(@propGridManager, Wx::SizerFlags.new(1).expand)
+
+    # Button for tab traversal testing
+    btnSizer = Wx::BoxSizer.new(Wx::HORIZONTAL)
+    btnSizer.add(Wx::Button.new(@panel, Wx::ID_ANY,
+                               'Should be able to move here with Tab'),
+                 Wx::SizerFlags.new(1).border(Wx::ALL, 10))
+    btnSizer.add(Wx::Button.new(@panel, ID::SHOWPOPUP,
+                               'Show Popup'),
+                 Wx::SizerFlags.new(1).border(Wx::ALL, 10))
+    @topSizer.add(btnSizer, Wx::SizerFlags.new(0).border(Wx::ALL, 5).expand)
+
+    @panel.set_sizer(@topSizer)
+    @topSizer.set_size_hints(@panel)
+
+    @panel.layout
+
+    if Wx.has_feature?(:USE_LOGWINDOW)
+      # Create log window
+      @logWindow = Wx::LogWindow.new(self, 'Log Messages', false)
+      @logWindow.frame.move(position.x + size.width + 10,
+                            position.y)
+      @logWindow.show
+    end
+
+    evt_idle :on_idle
+    evt_move :on_move
+    evt_size :on_resize
+
+    # This occurs when a property is selected
+    evt_pg_selected ID::PGID, :on_property_grid_select
+    # This occurs when a property value changes
+    evt_pg_changed ID::PGID, :on_property_grid_change
+    # This occurs just prior a property value is changed
+    evt_pg_changing ID::PGID, :on_property_grid_changing
+    # This occurs when a mouse moves over another property
+    evt_pg_highlighted ID::PGID, :on_property_grid_highlight
+    # This occurs when mouse is right-clicked.
+    evt_pg_right_click ID::PGID, :on_property_grid_item_right_click
+    # This occurs when mouse is double-clicked.
+    evt_pg_double_click ID::PGID, :on_property_grid_item_double_click
+    # This occurs when propgridmanager's page changes.
+    evt_pg_page_changed ID::PGID, :on_property_grid_page_change
+    # This occurs when user starts editing a property label
+    evt_pg_label_edit_begin ID::PGID, :on_property_grid_label_edit_begin
+    # This occurs when user stops editing a property label
+    evt_pg_label_edit_ending ID::PGID, :on_property_grid_label_edit_ending
+    # This occurs when property's editor button (if any) is clicked.
+    evt_button ID::PGID, :on_property_grid_button_click
+
+    evt_pg_item_collapsed ID::PGID, :on_property_grid_item_collapse
+    evt_pg_item_expanded ID::PGID, :on_property_grid_item_expand
+
+    evt_pg_col_begin_drag ID::PGID, :on_property_grid_col_begin_drag
+    evt_pg_col_dragging ID::PGID, :on_property_grid_col_dragging
+    evt_pg_col_end_drag ID::PGID, :on_property_grid_col_end_drag
+
+    evt_text ID::PGID, :on_property_grid_text_update
+
+    #
+    # Rest of the events are not property grid specific
+    evt_key_down :on_property_grid_key_event
+    evt_key_up :on_property_grid_key_event
+
+    evt_menu ID::APPENDPROP, :on_append_prop_click
+    evt_menu ID::APPENDCAT, :on_append_cat_click
+    evt_menu ID::INSERTPROP, :on_insert_prop_click
+    evt_menu ID::INSERTCAT, :on_insert_cat_click
+    evt_menu ID::DELETE, :on_del_prop_click
+    evt_menu ID::DELETER, :on_del_prop_r_click
+    evt_menu ID::UNSPECIFY, :on_misc
+    evt_menu ID::DELETEALL, :on_clear_click
+    evt_menu ID::ENABLE, :on_enable_disable
+    evt_menu ID::SETREADONLY, :on_set_read_only
+    evt_menu ID::HIDE, :on_hide
+    evt_menu ID::BOOL_CHECKBOX, :on_bool_checkbox
+
+    evt_menu ID::ITERATE1, :on_iterate1_click
+    evt_menu ID::ITERATE2, :on_iterate2_click
+    evt_menu ID::ITERATE3, :on_iterate3_click
+    evt_menu ID::ITERATE4, :on_iterate4_click
+    evt_menu ID::ONEXTENDEDKEYNAV, :on_extended_key_nav
+    evt_menu ID::SETBGCOLOUR, :on_set_background_colour
+    evt_menu ID::SETBGCOLOURRECUR, :on_set_background_colour
+    evt_menu ID::CLEARMODIF, :on_clear_modify_status_click
+    evt_menu ID::FREEZE, :on_freeze_click
+    evt_menu ID::ENABLELABELEDITING, :on_enable_label_editing
+    if Wx.has_feature? :USE_HEADERCTRL
+      evt_menu ID::SHOWHEADER, :on_show_header
+    end
+    evt_menu ID::DUMPLIST, :on_dump_list
+
+    evt_menu ID::COLOURSCHEME1, :on_colour_scheme
+    evt_menu ID::COLOURSCHEME2, :on_colour_scheme
+    evt_menu ID::COLOURSCHEME3, :on_colour_scheme
+    evt_menu ID::COLOURSCHEME4, :on_colour_scheme
+
+    evt_menu ID::ABOUT, :on_about
+    evt_menu ID::QUIT, :on_close_click
+
+    evt_menu ID::CATCOLOURS, :on_cat_colours
+    evt_menu ID::SETCOLUMNS, :on_set_columns
+    evt_menu ID::SETVIRTWIDTH, :on_set_virtual_width
+    evt_menu ID::SETPGDISABLED, :on_set_grid_disabled
+    evt_menu ID::TESTXRC, :on_test_xrc
+    evt_menu ID::ENABLECOMMONVALUES, :on_enable_common_values
+    evt_menu ID::SELECTSTYLE, :on_select_style
+
+    evt_menu ID::STATICLAYOUT, :on_misc
+    evt_menu ID::COLLAPSE, :on_misc
+    evt_menu ID::COLLAPSEALL, :on_misc
+
+    evt_menu ID::POPULATE1, :on_populate_click
+    evt_menu ID::POPULATE2, :on_populate_click
+
+    evt_menu ID::GETVALUES, :on_misc
+    evt_menu ID::SETVALUES, :on_misc
+    evt_menu ID::SETVALUES2, :on_misc
+
+    evt_menu ID::FITCOLUMNS, :on_fit_columns_click
+
+    evt_menu ID::CHANGEFLAGSITEMS, :on_change_flags_prop_items_click
+
+    evt_menu ID::RUNTESTFULL, :on_misc
+    evt_menu ID::RUNTESTPARTIAL, :on_misc
+
+    evt_menu ID::TESTINSERTCHOICE, :on_insert_choice
+    evt_menu ID::TESTDELETECHOICE, :on_delete_choice
+
+    evt_menu ID::INSERTPAGE, :on_insert_page
+    evt_menu ID::REMOVEPAGE, :on_remove_page
+
+    evt_menu ID::SAVESTATE, :on_save_state
+    evt_menu ID::RESTORESTATE, :on_restore_state
+
+    evt_menu ID::SETSPINCTRLEDITOR, :on_set_spin_ctrl_editor_click
+    evt_menu ID::TESTREPLACE, :on_test_replace_click
+    evt_menu ID::SETPROPERTYVALUE, :on_set_property_value
+
+    evt_menu ID::RUNMINIMAL, :on_run_minimal_click
+
+    evt_update_ui ID::CATCOLOURS, :on_cat_colours_update_ui
+
+    evt_context_menu :on_context_menu
+    evt_button ID::SHOWPOPUP, :on_show_popup
+
+  end
+
+  #
+  # Normally, wxPropertyGrid does not check whether item with identical
+  # label already exists. However, since in this sample we use labels for
+  # identifying properties, we have to be sure not to generate identical
+  # labels.
+  #
+  def self.generate_unique_property_label(pg, base_label)
+    count = -1;
+
+    if pg.get_property_by_label(base_label)
+      while true
+        count += 1
+        new_label = "%s %i" % [base_label,count]
+        break unless pg.get_property_by_label(new_label)
+      end
+    end
+
+    base_label = new_label if count >= 0
+
+    base_label
+  end
+
+  # utility function to find an icon relative to this ruby script
+  def local_icon_file(icon_name)
+    File.join(File.dirname(__FILE__), icon_name)
+  end
+
+  def create_grid(style, extraStyle)
+    #
+    # This function (re)creates the property grid in our sample
+    #
+
+    if style == -1
+      # default style
+      style =  Wx::PG::PG_BOLD_MODIFIED |
+        Wx::PG::PG_SPLITTER_AUTO_CENTER |
+        Wx::PG::PG_AUTO_SORT |
+        #Wx::PG::PG_HIDE_MARGIN|Wx::PG::PG_STATIC_SPLITTER |
+        #Wx::PG::PG_TOOLTIPS |
+        #Wx::PG::PG_HIDE_CATEGORIES |
+        #Wx::PG::PG_LIMITED_EDITING |
+        Wx::PG::PG_TOOLBAR |
+        Wx::PG::PG_DESCRIPTION
+    end
+    if extraStyle == -1
+        # default extra style
+        extraStyle = Wx::PG::PG_EX_MODE_BUTTONS |
+          Wx::PG::PG_EX_MULTIPLE_SELECTION
+        #| Wx::PG::PG_EX_AUTO_UNSPECIFIED_VALUES
+        #| Wx::PG::PG_EX_GREY_LABEL_WHEN_DISABLED
+        #| Wx::PG::PG_EX_HELP_AS_TOOLTIPS
+      if Wx.has_feature?(:ALWAYS_NATIVE_DOUBLE_BUFFER)
+        extraStyle |= Wx::PG::PG_EX_NATIVE_DOUBLE_BUFFERING
+      end # ALWAYS_NATIVE_DOUBLE_BUFFER
+    end
+    
+    #
+    # This shows how to combine two static choice descriptors
+    @combinedFlags.add(FS_WINDOWSTYLE_LABELS, FS_WINDOWSTYLE_VALUES)
+    @combinedFlags.add(FS_FRAMESTYLE_LABELS, FS_FRAMESTYLE_VALUES)
+
+    pgman = @propGridManager =
+      Wx::PG::PropertyGridManager.new(@panel,
+                                      # Don't change this into wxID_ANY in the sample, or the
+                                      # event handling will obviously be broken.
+                                      ID::PGID, # wxID_ANY
+                                      Wx::DEFAULT_POSITION,
+                                      Wx::DEFAULT_SIZE,
+                                      style)
+
+    @propGrid = pgman.grid
+
+    pgman.set_extra_style(extraStyle)
+
+    # This is the default validation failure behaviour
+    @propGridManager.set_validation_failure_behavior(Wx::PG::PG_VFB_MARK_CELL|Wx::PG::PG_VFB_SHOW_MESSAGEBOX)
+
+    @propGridManager.grid.set_vertical_spacing(2)
+
+    #
+    # Set somewhat different unspecified value appearance
+    cell = Wx::PG::PGCell.new
+    cell.text = 'Unspecified'
+    cell.set_fg_col(Wx::LIGHT_GREY)
+    @propGrid.set_unspecified_value_appearance(cell)
+
+    populate_grid
+
+    @propGrid.make_column_editable(0, @labelEditingEnabled)
+    @propGridManager.show_header(@hasHeader)
+    @propGridManager.set_column_title(2, 'Units') if @hasHeader
+  end
+
+  def replace_grid(style, extraStyle)
+    pgmanOld = @propGridManager;
+    create_grid(style, extraStyle)
+    @topSizer.replace(pgmanOld, @propGridManager)
+    pgmanOld.destroy
+    @propGridManager.set_focus
+    @panel.layout
+  end
+
+  # These are used in CreateGrid(), and in tests to compose
+  # grids for testing purposes.
+  def populate_grid
+    pgman = @propGridManager;
+    pgman.add_page('Standard Items')
+
+    populate_with_standard_items
+
+    pgman.add_page('wxWidgets Library Config')
+
+    populate_with_library_config
+
+    myPage = WxMyPropertyGridPage.new
+    myPage.append(Wx::PG::IntProperty.new("IntProperty", Wx::PG::PG_LABEL, 12345678))
+
+    # Use WxMyPropertyGridPage (see above) to test the
+    # custom wxPropertyGridPage feature.
+    pgman.add_page("Examples", Wx::BitmapBundle.new, myPage)
+
+    populate_with_examples
+  end
+
+  def populate_with_standard_items
+    pgman = @propGridManager
+    pg = pgman.get_page("Standard Items")
+
+    # Append is ideal way to add items to wxPropertyGrid.
+    pg.append(Wx::PG::PropertyCategory.new("Appearance", Wx::PG::PG_LABEL))
+
+    pg.append(Wx::PG::StringProperty.new("Label", Wx::PG::PG_LABEL, get_title))
+    pg.append(Wx::PG::FontProperty.new("Font", Wx::PG::PG_LABEL))
+    pg.set_property_help_string("Font", "Editing this will change font used in the property grid.")
+
+    pg.append(Wx::PG::SystemColourProperty.new("Margin Colour",Wx::PG::PG_LABEL,
+                                               Wx::PG::ColourPropertyValue.new(pg.get_grid.get_margin_colour)))
+
+    pg.append(Wx::PG::SystemColourProperty.new("Cell Colour",Wx::PG::PG_LABEL,
+                                               pg.grid.get_cell_background_colour))
+    pg.append(Wx::PG::SystemColourProperty.new("Cell Text Colour",Wx::PG::PG_LABEL,
+                                               pg.grid.get_cell_text_colour))
+    pg.append(Wx::PG::SystemColourProperty.new("Line Colour",Wx::PG::PG_LABEL,
+                                               pg.grid.get_line_colour))
+    pg.append(Wx::PG::FlagsProperty.new("Window Styles",Wx::PG::PG_LABEL,
+                                        @combinedFlags, get_window_style))
+
+    pg.append(Wx::PG::CursorProperty.new("Cursor",Wx::PG::PG_LABEL))
+
+    pg.append(Wx::PG::PropertyCategory.new("Position","PositionCategory"))
+    pg.set_property_help_string("PositionCategory", "Change in items in this category will cause respective changes in frame.")
+
+    # Let's demonstrate 'Units' attribute here
+
+    # Note that we use many attribute constants instead of strings here
+    # (for instance, Wx::PG::PG_ATTR_MIN, instead of "min").
+    # Using constant may reduce binary size.
+
+    pg.append(Wx::PG::IntProperty.new("Height",Wx::PG::PG_LABEL,480))
+    pg.set_property_attribute("Height", Wx::PG::PG_ATTR_MIN, 10)
+    pg.set_property_attribute("Height", Wx::PG::PG_ATTR_MAX, 2048)
+    pg.set_property_attribute("Height", Wx::PG::PG_ATTR_UNITS, "Pixels")
+
+    # Set value to unspecified so that Hint attribute will be demonstrated
+    pg.set_property_value_unspecified("Height")
+    pg.set_property_attribute("Height", Wx::PG::PG_ATTR_HINT,
+                             "Enter new height for window")
+
+    # Difference between hint and help string is that the hint is shown in
+    # an empty value cell, while help string is shown either in the
+    # description text box, as a tool tip, or on the status bar.
+    pg.set_property_help_string("Height",
+        "This property uses attributes \"Units\" and \"Hint\".")
+
+    pg.append(Wx::PG::IntProperty.new("Width",Wx::PG::PG_LABEL,640))
+    pg.set_property_attribute("Width", Wx::PG::PG_ATTR_MIN, 10)
+    pg.set_property_attribute("Width", Wx::PG::PG_ATTR_MAX, 2048)
+    pg.set_property_attribute("Width", Wx::PG::PG_ATTR_UNITS, "Pixels")
+
+    pg.set_property_value_unspecified("Width")
+    pg.set_property_attribute("Width", Wx::PG::PG_ATTR_HINT,
+                             "Enter new width for window")
+    pg.set_property_help_string("Width",
+        "This property uses attributes \"Units\" and \"Hint\".")
+
+    pg.append(Wx::PG::IntProperty.new("X",Wx::PG::PG_LABEL,10))
+    pg.set_property_attribute("X", Wx::PG::PG_ATTR_UNITS, "Pixels")
+    pg.set_property_help_string("X", "This property uses \"Units\" attribute.")
+
+    pg.append Wx::PG::IntProperty.new("Y",Wx::PG::PG_LABEL,10)
+    pg.set_property_attribute("Y", Wx::PG::PG_ATTR_UNITS, "Pixels")
+    pg.set_property_help_string("Y", "This property uses \"Units\" attribute.")
+
+    disabledHelpString = "This property is simply disabled. In order to have label disabled as well, "+
+      "you need to set Wx::PG::PG_EX_GREY_LABEL_WHEN_DISABLED using SetExtraStyle."
+
+    pg.append(Wx::PG::PropertyCategory.new("Environment",Wx::PG::PG_LABEL))
+    pg.append(Wx::PG::StringProperty.new("Operating System",Wx::PG::PG_LABEL, Wx.get_os_description))
+
+    pg.append(Wx::PG::StringProperty.new("User Id",Wx::PG::PG_LABEL, Wx.get_user_id))
+    pg.append(Wx::PG::DirProperty.new("User Home",Wx::PG::PG_LABEL, Wx.get_user_home))
+    pg.append(Wx::PG::StringProperty.new("User Name",Wx::PG::PG_LABEL, Wx.get_user_name))
+
+    # Disable some of them
+    pg.disable_property("Operating System")
+    pg.disable_property("User Id")
+    pg.disable_property("User Name")
+
+    pg.set_property_help_string("Operating System", disabledHelpString)
+    pg.set_property_help_string("User Id", disabledHelpString)
+    pg.set_property_help_string("User Name", disabledHelpString)
+
+    pg.append(Wx::PG::PropertyCategory.new("More Examples",Wx::PG::PG_LABEL))
+
+    pg.append(WxFontDataProperty.new("FontDataProperty", Wx::PG::PG_LABEL))
+    pg.set_property_help_string("FontDataProperty",
+        "This demonstrates Wx::PG::FontDataProperty class defined in this sample app. "+
+        "It is exactly like Wx::PG::FontProperty from the library, but also has colour sub-property.")
+
+    pg.append(WxDirsProperty.new("DirsProperty",Wx::PG::PG_LABEL))
+    pg.set_property_help_string("DirsProperty",
+        "This demonstrates Wx::PG::DirsProperty class defined in this sample app. "+
+        "It is built with WX_PG_IMPLEMENT_ARRAYSTRING_PROPERTY_WITH_VALIDATOR macro, "+
+        "with custom action (dir dialog popup) defined.")
+
+    arrdbl = [
+      -1.0,
+      -0.5,
+      0.0,
+      0.5,
+      1.0
+    ]
+
+    pg.append(WxArrayDoubleProperty.new("ArrayDoubleProperty",Wx::PG::PG_LABEL,arrdbl))
+    pg.set_property_attribute("ArrayDoubleProperty",Wx::PG::PG_FLOAT_PRECISION,2)
+    pg.set_property_help_string("ArrayDoubleProperty",
+        "This demonstrates Wx::PG::ArrayDoubleProperty class defined in this sample app. "+
+        "It is an example of a custom list editor property.")
+
+    pg.append(Wx::PG::LongStringProperty.new("Information",Wx::PG::PG_LABEL,
+        "Editing properties will have immediate effect on this window, "+
+        "and vice versa (at least in most cases, that is)."))
+    pg.set_property_help_string("Information",
+                               "This property is read-only.")
+
+    pg.set_property_read_only("Information", true)
+
+    #
+    # Set test information for cells in columns 3 and 4
+    # (reserve column 2 for displaying units)
+    bmp = Wx::ArtProvider.get_bitmap(Wx::ART_FOLDER)
+
+    pg.grid.each_property do |p|
+      continue if p.category?
+
+      pg.set_property_cell(p, 3, "Cell 3", bmp)
+      pg.set_property_cell(p, 4, "Cell 4", Wx::BitmapBundle.new, Wx::WHITE, Wx::BLACK)
+    end
+  end
+
+  def populate_with_examples
+    pgman = @propGridManager
+    pg = pgman.get_page("Examples")
+
+    if Wx.has_feature?(:USE_SPINBTN)
+      pg.append(Wx::PG::IntProperty.new("SpinCtrl", Wx::PG::PG_LABEL, 0))
+
+      pg.set_property_editor("SpinCtrl", Wx::PG::PG_EDITOR_SPIN_CTRL)
+      pg.set_property_attribute("SpinCtrl", Wx::PG::PG_ATTR_MIN, -2)  # Use constants instead of string
+      pg.set_property_attribute("SpinCtrl", Wx::PG::PG_ATTR_MAX, 16384)   # for reduced binary size.
+      pg.set_property_attribute("SpinCtrl", Wx::PG::PG_ATTR_SPINCTRL_STEP, 2)
+      pg.set_property_attribute("SpinCtrl", Wx::PG::PG_ATTR_SPINCTRL_MOTION, true)
+      pg.set_property_attribute("SpinCtrl", Wx::PG::PG_ATTR_SPINCTRL_WRAP, true)
+  
+      pg.set_property_help_string("SpinCtrl",
+                                 "This is regular Wx::PG::IntProperty, which editor has been "+
+                                   "changed to Wx::PG::PGEditor_SpinCtrl. Note however that "+
+                                   "static wxPropertyGrid::RegisterAdditionalEditors() "+
+                                   "needs to be called prior to using it.")
+    end
+
+    # Add bool property
+    pg.append(Wx::PG::BoolProperty.new("BoolProperty", Wx::PG::PG_LABEL, false))
+
+    # Add bool property with check box
+    pg.append(Wx::PG::BoolProperty.new("BoolProperty with CheckBox", Wx::PG::PG_LABEL, false))
+    pg.set_property_attribute("BoolProperty with CheckBox",
+                              Wx::PG::PG_BOOL_USE_CHECKBOX,
+                              true)
+
+    pg.set_property_help_string("BoolProperty with CheckBox",
+                               "Property attribute Wx::PG::PG_BOOL_USE_CHECKBOX has been set to true.")
+
+    prop = pg.append(Wx::PG::FloatProperty.new("FloatProperty",
+                                           Wx::PG::PG_LABEL,
+                                           1234500.23))
+    prop.set_attribute(Wx::PG::PG_ATTR_MIN, -100.12)
+
+    # A string property that can be edited in a separate editor dialog.
+    pg.append(Wx::PG::LongStringProperty.new("LongStringProperty", "LongStringProp",
+                                              "This is much longer string than the first one. Edit it by clicking the button."))
+
+    # A property that edits a wxArrayString.
+    example_array = [
+      "String 1",
+      "String 2",
+      "String 3"
+    ]
+    pg.append(Wx::PG::ArrayStringProperty.new("ArrayStringProperty", Wx::PG::PG_LABEL,
+                                           example_array))
+
+    # A file selector property. Note that argument between name
+    # and initial value is wildcard (format same as in wxFileDialog).
+    prop = Wx::PG::FileProperty.new("FileProperty", "TextFile")
+    pg.append(prop)
+
+    prop.set_attribute(Wx::PG::PG_FILE_WILDCARD,"Text Files (*.txt)|*.txt")
+    prop.set_attribute(Wx::PG::PG_DIALOG_TITLE,"Custom File Dialog Title")
+    prop.set_attribute(Wx::PG::PG_FILE_SHOW_FULL_PATH,false)
+
+    if Wx::PLATFORM == 'WXMSW'
+      prop.set_attribute(Wx::PG::PG_FILE_SHOW_RELATIVE_PATH,"C:\\Windows")
+      pg.set_property_value(prop,"C:\\Windows\\System32\\msvcrt71.dll")
+    end
+
+    if Wx.has_feature? :USE_IMAGE
+      # An image file property. Arguments are just like for FileProperty, but
+      # wildcard is missing (it is autogenerated from supported image formats).
+      # If you really need to override it, create property separately, and call
+      # its SetWildcard method.
+      pg.append(Wx::PG::ImageFileProperty.new("ImageFile", Wx::PG::PG_LABEL))
+    end
+
+    pid = pg.append(Wx::PG::ColourProperty.new("ColourProperty",Wx::PG::PG_LABEL,Wx::RED))
+    pg.set_property_editor("ColourProperty", Wx::PG::PG_EDITOR_COMBO_BOX)
+    pg.get_property("ColourProperty").set_auto_unspecified(true)
+    pg.set_property_help_string("ColourProperty",
+                                "wxPropertyGrid::SetPropertyEditor method has been used to change "+
+                                "editor of this property to Wx::PG::PGEditor_ComboBox)")
+
+    pid = pg.append(Wx::PG::ColourProperty.new("ColourPropertyWithAlpha",
+                                               Wx::PG::PG_LABEL,
+                                               Wx::Colour.new(15, 200, 95, 128)))
+    pg.set_property_attribute("ColourPropertyWithAlpha", Wx::PG::PG_COLOUR_HAS_ALPHA, true)
+    pg.set_property_help_string("ColourPropertyWithAlpha",
+                              "Attribute \"HasAlpha\" is set to true for this property.")
+
+    #
+    # This demonstrates using alternative editor for colour property
+    # to trigger colour dialog directly from button.
+    pg.append(Wx::PG::ColourProperty.new("ColourProperty2",Wx::PG::PG_LABEL,Wx::GREEN))
+
+    #
+    # Wx::PG::EnumProperty does not store strings or even list of strings
+    # (so that's why they are static in function).
+    enum_prop_labels = [
+      "One Item",
+      "Another Item",
+      "One More",
+      "This Is Last" ]
+
+    # this value array would be optional if values matched string indexes
+    enum_prop_values = [ 40, 80, 120, 160 ]
+
+    # note that the initial value (the last argument) is the actual value,
+    # not index or anything like that. Thus, our value selects "Another Item".
+    pg.append(Wx::PG::EnumProperty.new("EnumProperty",Wx::PG::PG_LABEL,
+                                       enum_prop_labels, enum_prop_values, 80))
+
+    soc = Wx::PG::PGChoices.new
+
+    # use basic table from our previous example
+    # can also set/add wxArrayStrings and wxArrayInts directly.
+    soc.set(enum_prop_labels, enum_prop_values)
+
+    # add extra items
+    soc.add("Look, it continues", 200)
+    soc.add("Even More", 240)
+    soc.add("And More", 280)
+    soc.add('', 300)
+    soc.add("True End of the List", 320)
+
+    # Test custom colours ([] operator of Wx::PG::PGChoices returns
+    # references to Wx::PG::PGChoiceEntry).
+    soc[1].set_fg_col(Wx::RED)
+    soc[1].set_bg_col(Wx::LIGHT_GREY)
+    soc[2].set_fg_col(Wx::GREEN)
+    soc[2].set_bg_col(Wx::LIGHT_GREY)
+    soc[3].set_fg_col(Wx::BLUE)
+    soc[3].set_bg_col(Wx::LIGHT_GREY)
+    soc[4].set_bitmap(Wx::ArtProvider.get_bitmap(Wx::ART_FOLDER))
+
+    pg.append(Wx::PG::EnumProperty.new("EnumProperty 2",
+                                   Wx::PG::PG_LABEL,
+                                   soc,
+                                   240))
+    pg.get_property("EnumProperty 2").add_choice("Testing Extra", 360)
+
+    # Here we only display the original 'soc' choices
+    pg.append(Wx::PG::EnumProperty.new("EnumProperty 3",Wx::PG::PG_LABEL,
+        soc, 240))
+
+    # Test Hint attribute in EnumProperty
+    pg.get_property("EnumProperty 3").set_attribute(Wx::PG::PG_ATTR_HINT, "Dummy Hint")
+
+    pg.set_property_help_string("EnumProperty 3",
+        "This property uses \"Hint\" attribute.")
+
+    # 'soc' plus one exclusive extra choice "4th only"
+    pg.append(Wx::PG::EnumProperty.new("EnumProperty 4",Wx::PG::PG_LABEL,
+        soc, 240))
+    pg.get_property("EnumProperty 4").add_choice("4th only", 360)
+
+    pg.set_property_help_string("EnumProperty 4",
+        "Should have one extra item when compared to EnumProperty 3")
+
+    # Plus property value bitmap
+    pg.append(Wx::PG::EnumProperty.new("EnumProperty With Bitmap", "EnumProperty 5",
+        soc, 280))
+    pg.set_property_help_string("EnumProperty 5",
+        "Should have bitmap in front of the displayed value")
+    bmpVal = Wx::ArtProvider.get_bitmap(Wx::ART_REMOVABLE)
+    pg.set_property_image("EnumProperty 5", bmpVal)
+
+    # Password property example.
+    pg.append(Wx::PG::StringProperty.new("Password",Wx::PG::PG_LABEL, "password"))
+    pg.set_property_attribute("Password", Wx::PG::PG_STRING_PASSWORD, true)
+    pg.set_property_help_string("Password",
+        "Has attribute Wx::PG::PG_STRING_PASSWORD set to true")
+
+    # String editor with dir selector button. Uses wxEmptyString as name, which
+    # is allowed (naturally, in this case property cannot be accessed by name).
+    pg.append(Wx::PG::DirProperty.new("DirProperty", Wx::PG::PG_LABEL, Wx.get_user_home))
+    pg.set_property_attribute("DirProperty",
+                              Wx::PG::PG_DIALOG_TITLE,
+                              "This is a custom dir dialog title")
+
+    # Add string property - first arg is label, second name, and third initial value
+    pg.append(Wx::PG::StringProperty.new("StringProperty", Wx::PG::PG_LABEL))
+    pg.set_property_max_length("StringProperty", 6)
+    pg.set_property_help_string("StringProperty",
+        "Max length of this text has been limited to 6, using wxPropertyGrid::SetPropertyMaxLength.")
+
+    # Set value after limiting so that it will be applied
+    pg.set_property_value("StringProperty", "some text")
+
+    #
+    # Demonstrate "AutoComplete" attribute
+    pg.append(Wx::PG::StringProperty.new("StringProperty AutoComplete",
+                                      Wx::PG::PG_LABEL))
+
+    autoCompleteStrings = [
+      "One choice",
+      "Another choice",
+      "Another choice, yeah",
+      "Yet another choice",
+      "Yet another choice, bear with me"
+    ]
+    pg.set_property_attribute("StringProperty AutoComplete",
+                              Wx::PG::PG_ATTR_AUTOCOMPLETE,
+                              autoCompleteStrings)
+
+    pg.set_property_help_string("StringProperty AutoComplete",
+        "AutoComplete attribute has been set for this property "+
+        "(try writing something beginning with 'a', 'o' or 'y').")
+
+
+    # Add string property with arbitrarily wide bitmap in front of it. We
+    # intentionally lower-than-typical row height here so that the ugly
+    # scaling code won't be run.
+    pg.append(Wx::PG::StringProperty.new("StringPropertyWithBitmap",
+                                      Wx::PG::PG_LABEL,
+                                      "Test Text"))
+    myTestBitmap1x = Wx::Bitmap.new(60, 15, 32)
+    mdc = Wx::MemoryDC.new(myTestBitmap1x)
+    mdc.set_background(Wx::WHITE_BRUSH)
+    mdc.clear
+    mdc.set_pen(Wx::BLACK_PEN)
+    mdc.set_brush(Wx::WHITE_BRUSH)
+    mdc.draw_rectangle(0, 0, 60, 15)
+    mdc.draw_line(0, 0, 59, 14)
+    mdc.set_text_foreground(Wx::BLACK)
+    mdc.draw_text("x1", 0, 0)
+
+    myTestBitmap2x = Wx::Bitmap.new(120, 30, 32)
+    mdc = Wx::MemoryDC.new(myTestBitmap2x)
+    mdc.set_background(Wx::WHITE_BRUSH)
+    mdc.clear
+    mdc.set_pen(Wx::Pen.new(Wx::BLUE, 2))
+    mdc.set_brush(Wx::WHITE_BRUSH)
+    mdc.draw_rectangle(0, 0, 120, 30)
+    mdc.draw_line(0, 0, 119, 31)
+    mdc.set_text_foreground(Wx::BLUE)
+    f = mdc.font
+    f.set_pixel_size(f.get_pixel_size * 2)
+    mdc.set_font(f)
+    mdc.draw_text("x2", 0, 0)
+
+    myTestBitmap2x.set_scale_factor(2)
+    pg.set_property_image("StringPropertyWithBitmap", Wx::BitmapBundle.from_bitmaps(myTestBitmap1x, myTestBitmap2x))
+
+    # Multi choice dialog.
+    tchoices = %w[Cabbage Carrot Onion Potato Strawberry]
+
+    tchoicesValues = %w[Carrot Potato]
+
+    pg.append(Wx::PG::EnumProperty.new("EnumProperty X",Wx::PG::PG_LABEL, tchoices))
+
+    pg.append(Wx::PG::MultiChoiceProperty.new("MultiChoiceProperty", Wx::PG::PG_LABEL,
+                                           tchoices, tchoicesValues))
+    pg.set_property_attribute("MultiChoiceProperty", Wx::PG::PG_ATTR_MULTICHOICE_USERSTRINGMODE, 1)
+
+    pg.append(WxSizeProperty.new("SizeProperty", "Size", get_size))
+    pg.append(WxPointProperty.new("PointProperty", "Position", get_position))
+
+    # UInt samples
+    pg.append(Wx::PG::UIntProperty.new("UIntProperty", Wx::PG::PG_LABEL, 0xFEEEFEEEFEEE))
+    pg.set_property_attribute("UIntProperty", Wx::PG::PG_UINT_PREFIX, Wx::PG::PG_PREFIX_NONE)
+    pg.set_property_attribute("UIntProperty", Wx::PG::PG_UINT_BASE, Wx::PG::PG_BASE_HEX)
+    #pg.set_property_attribute("UIntProperty", Wx::PG::PG_UINT_PREFIX, Wx::PG::PG_PREFIX_NONE)
+    #pg.set_property_attribute("UIntProperty", Wx::PG::PG_UINT_BASE, Wx::PG::PG_BASE_OCT)
+
+    #
+    # Wx::PG::EditEnumProperty
+    eech = Wx::PG::PGChoices.new([
+      "Choice 1",
+      "Choice 2",
+      "Choice 3"
+    ])
+    pg.append(Wx::PG::EditEnumProperty.new("EditEnumProperty",
+                                           Wx::PG::PG_LABEL,
+                                           eech,
+                                           "Choice not in the list"))
+
+    # Test Hint attribute in EditEnumProperty
+    pg.get_property("EditEnumProperty").set_attribute(Wx::PG::PG_ATTR_HINT, "Dummy Hint")
+
+    #wxString v_;
+    #wxTextValidator validator1(wxFILTER_NUMERIC,&v_)
+    #pg.SetPropertyValidator("EditEnumProperty", validator1)
+
+    if Wx.has_feature? :USE_DATETIME
+      #
+      # Wx::PG::DateTimeProperty
+      pg.append(Wx::PG::DateProperty.new("DateProperty", Wx::PG::PG_LABEL, Time.now))
+
+      if Wx.has_feature? :USE_DATEPICKCTRL
+        pg.set_property_attribute("DateProperty", Wx::PG::PG_DATE_PICKER_STYLE,
+                                  Wx::DP_DROPDOWN|Wx::DP_SHOWCENTURY|Wx::DP_ALLOWNONE)
+
+        pg.set_property_help_string("DateProperty",
+                                   "Attribute Wx::PG::PG_DATE_PICKER_STYLE has been set to (long)"+
+                                     "(wxDP_DROPDOWN | wxDP_SHOWCENTURY | wxDP_ALLOWNONE).")
+      end
+
+    end
+
+    #
+    # Add Triangle properties as both Wx::PG::TriangleProperty and
+    # a generic parent property (using Wx::PG::StringProperty).
+    #
+    topId = pg.append(Wx::PG::StringProperty.new("3D Object", Wx::PG::PG_LABEL, "<composed>"))
+
+    pid = pg.append_in(topId, Wx::PG::StringProperty.new("Triangle 1", "Triangle 1", "<composed>"))
+    pg.append_in(pid, WxVectorProperty.new("A", Wx::PG::PG_LABEL))
+    pg.append_in(pid, WxVectorProperty.new("B", Wx::PG::PG_LABEL))
+    pg.append_in(pid, WxVectorProperty.new("C", Wx::PG::PG_LABEL))
+
+    pg.append_in(topId, WxTriangleProperty.new("Triangle 2", "Triangle 2"))
+
+    pg.set_property_help_string("3D Object",
+                               "3D Object is Wx::PG::StringProperty with value \"<composed>\". Two of its children are similar wxStringProperties with "+
+                                 "three Wx::PG::VectorProperty children, and other two are custom wxTriangleProperties.")
+
+    pid = pg.append_in(topId, Wx::PG::StringProperty.new("Triangle 3", "Triangle 3", "<composed>"))
+    pg.append_in(pid, WxVectorProperty.new("A", Wx::PG::PG_LABEL))
+    pg.append_in(pid, WxVectorProperty.new("B", Wx::PG::PG_LABEL))
+    pg.append_in(pid, WxVectorProperty.new("C", Wx::PG::PG_LABEL))
+
+    pg.append_in(topId, WxTriangleProperty.new("Triangle 4", "Triangle 4"))
+
+    #
+    # This snippet is a doc sample test
+    #
+    carProp = pg.append(Wx::PG::StringProperty.new("Car",
+                                                   Wx::PG::PG_LABEL,
+                                                   "<composed>"))
+
+    pg.append_in(carProp, Wx::PG::StringProperty.new("Model",
+                                               Wx::PG::PG_LABEL,
+                                               "Lamborghini Diablo SV"))
+
+    pg.append_in(carProp, Wx::PG::IntProperty.new("Engine Size (cc)",
+                                            Wx::PG::PG_LABEL,
+                                            5707))
+
+    speedsProp = pg.append_in(carProp,
+                              Wx::PG::StringProperty.new("Speeds",
+                                                         Wx::PG::PG_LABEL,
+                                                         "<composed>"))
+
+    pg.append_in(speedsProp, Wx::PG::IntProperty.new("Max. Speed (mph)",
+                                                Wx::PG::PG_LABEL,290))
+    pg.append_in(speedsProp, Wx::PG::FloatProperty.new("0-100 mph (sec)",
+                                                  Wx::PG::PG_LABEL,3.9))
+    pg.append_in(speedsProp, Wx::PG::FloatProperty.new("1/4 mile (sec)",
+                                                  Wx::PG::PG_LABEL,8.6))
+
+    # This is how child property can be referred to by name
+    pg.set_property_value("Car.Speeds.Max. Speed (mph)", 300)
+
+    pg.append_in(carProp, Wx::PG::IntProperty.new("Price ($)",
+                                            Wx::PG::PG_LABEL,
+                                            300000))
+
+    pg.append_in(carProp, Wx::PG::BoolProperty.new("Convertible",
+                                             Wx::PG::PG_LABEL,
+                                             false))
+
+    # Displayed value of "Car" property is now very close to this:
+    # "Lamborghini Diablo SV; 5707 [300; 3.9; 8.6] 300000"
+
+    #
+    # Test wxSampleMultiButtonEditor
+    pg.append(Wx::PG::LongStringProperty.new("MultipleButtons", Wx::PG::PG_LABEL))
+    pg.set_property_editor("MultipleButtons", @sampleMultiButtonEditor)
+
+    # Test SingleChoiceProperty
+    pg.append(WxSingleChoiceProperty.new("SingleChoiceProperty"))
+
+    #
+    # Test adding variable height bitmaps in Wx::PG::PGChoices
+    bc = Wx::PG::PGChoices.new
+    bc.add("Wee",
+           Wx::ArtProvider.get_bitmap(Wx::ART_CDROM, Wx::ART_OTHER, [16, 16]))
+    bc.add("Not so wee",
+           Wx::ArtProvider.get_bitmap(Wx::ART_FLOPPY, Wx::ART_OTHER, [32, 32]))
+    bc.add("Friggin' huge",
+           Wx::ArtProvider.get_bitmap(Wx::ART_HARDDISK, Wx::ART_OTHER, [64, 64]))
+
+    pg.append(Wx::PG::EnumProperty.new("Variable Height Bitmaps",
+                                   Wx::PG::PG_LABEL,
+                                   bc,
+                                   0))
+
+    #
+    # Test how non-editable composite strings appear
+    pid = Wx::PG::StringProperty.new("wxRuby Traits", Wx::PG::PG_LABEL, "<composed>")
+    pg.set_property_read_only(pid)
+
+    #
+    # For testing purposes, combine two methods of adding children
+    #
+
+    pid.append_child(Wx::PG::StringProperty.new("Latest Release",
+                                           Wx::PG::PG_LABEL,
+                                           "3.0.0"))
+    pid.append_child(Wx::PG::BoolProperty.new("Win API",
+                                         Wx::PG::PG_LABEL,
+                                         true))
+
+    pg.append(pid)
+
+    pg.append_in(pid, Wx::PG::BoolProperty.new("QT", Wx::PG::PG_LABEL, true))
+    pg.append_in(pid, Wx::PG::BoolProperty.new("Cocoa", Wx::PG::PG_LABEL, true))
+    pg.append_in(pid, Wx::PG::BoolProperty.new("Haiku", Wx::PG::PG_LABEL, false))
+    pg.append_in(pid, Wx::PG::StringProperty.new("Trunk Version", Wx::PG::PG_LABEL, Wx::WXRUBY_VERSION))
+    pg.append_in(pid, Wx::PG::BoolProperty.new("GTK+", Wx::PG::PG_LABEL, true))
+    pg.append_in(pid, Wx::PG::BoolProperty.new("Android", Wx::PG::PG_LABEL, false))
+
+    add_test_properties(pg)
+  end
+
+  def populate_with_library_config
+    pgman = @propGridManager;
+    pg = pgman.get_page("wxWidgets Library Config")
+
+    # Set custom column proportions (here in the sample app we need
+    # to check if the grid has wxPG_SPLITTER_AUTO_CENTER style. You usually
+    # need not to do it in your application).
+    if pgman.has_flag(Wx::PG::PG_SPLITTER_AUTO_CENTER)
+      pg.set_column_proportion(0, 3)
+      pg.set_column_proportion(1, 1)
+    end
+
+    bmp = Wx::ArtProvider.get_bitmap(Wx::ART_REPORT_VIEW)
+
+    italicFont = pgman.grid.get_caption_font
+    italicFont.set_style(Wx::FONTSTYLE_ITALIC)
+
+    italicFontHelp = "Font of this property's wxPGCell has " +
+      "been modified. Obtain property's cell " +
+      "with wxPGProperty::" +
+      "GetOrCreateCell(column)."
+
+    pid = pg.append(Wx::PG::PropertyCategory.new("wxWidgets Library Configuration" ))
+    pg.set_property_cell(pid, 0, Wx::PG::PG_LABEL, bmp)
+
+    # Both of following lines would set a label for the second column
+    pg.set_property_cell(pid, 1, "Is Enabled")
+    pid.set_value("Is Enabled")
+
+    _ADD_WX_LIB_CONF_GROUP = ->(label) {
+      cat = pg.append_in(pid, Wx::PG::PropertyCategory.new(label))
+      pg.set_property_cell(cat, 0, Wx::PG::PG_LABEL, bmp)
+      cat.get_cell(0).set_font(italicFont)
+      cat.set_help_string(italicFontHelp)
+    }
+
+    _ADD_WX_LIB_CONF = ->(sym) {
+      pg.append(Wx::PG::BoolProperty.new(sym.to_s, Wx::PG::PG_LABEL, Wx.has_feature?(sym)))
+    }
+
+    _ADD_WX_LIB_CONF_NODEF = ->(sym) {
+      pg.append(Wx::PG::BoolProperty.new(sym.to_s, Wx::PG::PG_LABEL, Wx.has_feature?(sym)))
+      pg.disable_property(sym.to_s) unless Wx.has_feature?(sym)
+    }
+
+    _ADD_WX_LIB_CONF_GROUP.call("Global Settings")
+    _ADD_WX_LIB_CONF.call(:USE_GUI)
+
+    _ADD_WX_LIB_CONF_GROUP.call("Compatibility Settings")
+    if Wx.has_feature?(:WXWIN_COMPATIBILITY_3_0)
+      _ADD_WX_LIB_CONF.call(:WXWIN_COMPATIBILITY_3_0)
+    end
+    _ADD_WX_LIB_CONF_NODEF.call(:FONT_SIZE_COMPATIBILITY)
+    _ADD_WX_LIB_CONF_NODEF.call(:DIALOG_UNIT_COMPATIBILITY)
+
+    _ADD_WX_LIB_CONF_GROUP.call("Debugging Settings")
+    _ADD_WX_LIB_CONF.call(:USE_DEBUG_CONTEXT)
+    _ADD_WX_LIB_CONF.call(:USE_MEMORY_TRACING)
+    _ADD_WX_LIB_CONF.call(:USE_GLOBAL_MEMORY_OPERATORS)
+    _ADD_WX_LIB_CONF.call(:USE_DEBUG_NEW_ALWAYS)
+    _ADD_WX_LIB_CONF.call(:USE_ON_FATAL_EXCEPTION)
+
+    _ADD_WX_LIB_CONF_GROUP.call("Unicode Support")
+    _ADD_WX_LIB_CONF.call(:USE_UNICODE)
+
+    _ADD_WX_LIB_CONF_GROUP.call("Global Features")
+    _ADD_WX_LIB_CONF.call(:USE_EXCEPTIONS)
+    _ADD_WX_LIB_CONF.call(:USE_EXTENDED_RTTI)
+    _ADD_WX_LIB_CONF.call(:USE_STL)
+    _ADD_WX_LIB_CONF.call(:USE_LOG)
+    _ADD_WX_LIB_CONF.call(:USE_LOGWINDOW)
+    _ADD_WX_LIB_CONF.call(:USE_LOGGUI)
+    _ADD_WX_LIB_CONF.call(:USE_LOG_DIALOG)
+    _ADD_WX_LIB_CONF.call(:USE_CMDLINE_PARSER)
+    _ADD_WX_LIB_CONF.call(:USE_THREADS)
+    _ADD_WX_LIB_CONF.call(:USE_STREAMS)
+    _ADD_WX_LIB_CONF.call(:USE_STD_IOSTREAM)
+
+    _ADD_WX_LIB_CONF_GROUP.call("Non-GUI Features")
+    _ADD_WX_LIB_CONF.call(:USE_LONGLONG)
+    _ADD_WX_LIB_CONF.call(:USE_FILE)
+    _ADD_WX_LIB_CONF.call(:USE_FFILE)
+    _ADD_WX_LIB_CONF.call(:USE_FSVOLUME)
+    _ADD_WX_LIB_CONF.call(:USE_TEXTBUFFER)
+    _ADD_WX_LIB_CONF.call(:USE_TEXTFILE)
+    _ADD_WX_LIB_CONF.call(:USE_INTL)
+    _ADD_WX_LIB_CONF.call(:USE_DATETIME)
+    _ADD_WX_LIB_CONF.call(:USE_TIMER)
+    _ADD_WX_LIB_CONF.call(:USE_STOPWATCH)
+    _ADD_WX_LIB_CONF.call(:USE_CONFIG)
+    _ADD_WX_LIB_CONF_NODEF.call(:USE_CONFIG_NATIVE)
+    _ADD_WX_LIB_CONF.call(:USE_DIALUP_MANAGER)
+    _ADD_WX_LIB_CONF.call(:USE_DYNLIB_CLASS)
+    _ADD_WX_LIB_CONF.call(:USE_DYNAMIC_LOADER)
+    _ADD_WX_LIB_CONF.call(:USE_SOCKETS)
+    _ADD_WX_LIB_CONF.call(:USE_FILESYSTEM)
+    _ADD_WX_LIB_CONF.call(:USE_FS_ZIP)
+    _ADD_WX_LIB_CONF.call(:USE_FS_INET)
+    _ADD_WX_LIB_CONF.call(:USE_ZIPSTREAM)
+    _ADD_WX_LIB_CONF.call(:USE_ZLIB)
+    _ADD_WX_LIB_CONF.call(:USE_APPLE_IEEE)
+    _ADD_WX_LIB_CONF.call(:USE_JOYSTICK)
+    _ADD_WX_LIB_CONF.call(:USE_FONTMAP)
+    _ADD_WX_LIB_CONF.call(:USE_MIMETYPE)
+    _ADD_WX_LIB_CONF.call(:USE_PROTOCOL)
+    _ADD_WX_LIB_CONF.call(:USE_PROTOCOL_FILE)
+    _ADD_WX_LIB_CONF.call(:USE_PROTOCOL_FTP)
+    _ADD_WX_LIB_CONF.call(:USE_PROTOCOL_HTTP)
+    _ADD_WX_LIB_CONF.call(:USE_URL)
+    _ADD_WX_LIB_CONF_NODEF.call(:USE_URL_NATIVE)
+    _ADD_WX_LIB_CONF.call(:USE_REGEX)
+    _ADD_WX_LIB_CONF.call(:USE_SYSTEM_OPTIONS)
+    _ADD_WX_LIB_CONF.call(:USE_SOUND)
+    _ADD_WX_LIB_CONF_NODEF.call(:USE_XRC)
+    _ADD_WX_LIB_CONF.call(:USE_XML)
+
+    # Set them to use check box.
+    pg.set_property_attribute(pid, Wx::PG::PG_BOOL_USE_CHECKBOX, true, Wx::PG::PG_RECURSE)
+  end
+
+  def on_close_click(event)
+    close(false)
+  end
+
+  def on_colour_scheme(event)
+    id = event.id
+    if id == ID::COLOURSCHEME1
+      @propGridManager.grid.reset_colours
+    elsif id == ID::COLOURSCHEME2
+      # white
+      my_grey_1 = Wx::Colour.new(212,208,200)
+      my_grey_3 = Wx::Colour.new(113,111,100)
+      @propGridManager.freeze
+      @propGridManager.grid.set_margin_colour(Wx::WHITE)
+      @propGridManager.grid.set_caption_background_colour(Wx::WHITE)
+      @propGridManager.grid.set_cell_background_colour(Wx::WHITE)
+      @propGridManager.grid.set_cell_text_colour(my_grey_3)
+      @propGridManager.grid.set_line_colour(my_grey_1)
+      @propGridManager.thaw
+     elsif id == ID::COLOURSCHEME3
+       # .NET
+      my_grey_1 = Wx::Colour.new(212,208,200)
+      my_grey_2 = Wx::Colour.new(236,233,216)
+      @propGridManager.freeze
+      @propGridManager.grid.set_margin_colour(my_grey_1)
+      @propGridManager.grid.set_caption_background_colour(my_grey_1)
+      @propGridManager.grid.set_line_colour(my_grey_1)
+      @propGridManager.thaw
+    elsif id == ID::COLOURSCHEME4
+      # cream
+      my_grey_1 = Wx::Colour.new(212,208,200)
+      my_grey_2 = Wx::Colour.new(241,239,226)
+      my_grey_3 = Wx::Colour.new(113,111,100)
+       @propGridManager.freeze
+       @propGridManager.grid.set_margin_colour(Wx::WHITE)
+       @propGridManager.grid.set_caption_background_colour(Wx::WHITE)
+       @propGridManager.grid.set_cell_background_colour(my_grey_2)
+       @propGridManager.grid.set_cell_background_colour(my_grey_2)
+       @propGridManager.grid.set_cell_text_colour(my_grey_3)
+       @propGridManager.grid.set_line_colour(my_grey_1)
+       @propGridManager.thaw
+    end
+  end
+
+  def on_insert_prop_click(event)
+    if @propGridManager.grid.root.get_child_count == 0
+      Wx.message_box("No items to relate - first add some with Append.")
+      return
+    end
+
+    id = @propGridManager.grid.get_selection
+    unless id
+      Wx.message_box("First select a property - new one will be inserted right before that.")
+      return
+    end
+
+    propLabel = FormMain.generate_unique_property_label(@propGridManager, 'Property')
+
+    @propGridManager.insert(@propGridManager.get_property_parent(id),
+                            id.get_index_in_parent,
+                            Wx::PG::StringProperty.new(propLabel))
+  end
+
+  def on_append_prop_click(event)
+    propLabel = FormMain.generate_unique_property_label(@propGridManager, 'Property')
+
+    @propGridManager.append(Wx::PG::StringProperty.new(propLabel))
+
+    @propGridManager.refresh
+  end
+
+  def on_clear_click(event)
+    @propGridManager.grid.clear
+  end
+
+  def on_append_cat_click(event)
+    propLabel = FormMain.generate_unique_property_label(@propGridManager, 'Category')
+
+    @propGridManager.append(Wx::PG::PropertyCategory.new(propLabel))
+
+    @propGridManager.refresh
+  end
+
+  def on_insert_cat_click(event)
+    if @propGridManager.grid.root.get_child_count == 0
+      Wx.message_box("No items to relate - first add some with Append.")
+      return
+    end
+
+    id = @propGridManager.grid.get_selection
+    unless id
+      Wx.message_box("First select a property - new one will be inserted right before that.")
+      return
+    end
+
+    propLabel = FormMain.generate_unique_property_label(@propGridManager, 'Category')
+
+    @propGridManager.insert(@propGridManager.get_property_parent(id),
+                            id.get_index_in_parent,
+                            Wx::PG::PropertyCategory.new(propLabel))
+  end
+
+  def on_del_prop_click(event)
+    id = @propGridManager.grid.get_selection
+    unless id
+      Wx.message_box("First select a property.")
+      return
+    end
+
+    @propGridManager.delete_property(id)
+  end
+
+  def on_del_prop_r_click(event)
+    # Delete random property
+    p = @propGridManager.grid.root
+
+    while true
+      break if p.get_child_count == 0
+
+      n = rand(p.get_child_count)
+      p = p.item(n)
+
+      if !p.category?
+        label = p.get_label
+        @propGridManager.delete_property(p)
+        Wx.log_message("Property deleted: %s", label)
+        break
+      end
+    end
+  end
+
+  def on_context_menu(event)
+    Wx.log_debug("FormMain::OnContextMenu(%i,%i)",
+               event.get_position.x,event.get_position.y)
+  end
+
+  def on_enable_disable(event)
+    id = @propGridManager.grid.get_selection
+    unless id
+      Wx.message_box("First select a property.")
+      return
+    end
+
+    if @propGridManager.is_property_enabled(id)
+      @propGridManager.disable_property(id)
+      @itemEnable.set_item_label("Enable")
+    else
+      @propGridManager.enable_property(id)
+      @itemEnable.set_item_label("Disable")
+    end
+  end
+
+  def on_set_read_only(event)
+    id = @propGridManager.grid.get_selection
+    unless id
+      Wx.message_box("First select a property.")
+      return
+    end
+    @propGridManager.set_property_read_only(id)
+  end
+
+  def on_hide(event)
+    id = @propGridManager.grid.get_selection
+    unless id
+      Wx.message_box("First select a property.")
+      return
+    end
+    @propGridManager.hide_property(id, true)
+  end
+
+  def on_bool_checkbox(evt)
+    @propGridManager.set_property_attribute_all(Wx::PG::PG_BOOL_USE_CHECKBOX, evt.checked?)
+  end
+
+  def on_set_background_colour(event)
+    pg = @propGridManager.grid
+    prop = pg.get_selection
+    unless prop
+      Wx.message_box("First select a property.")
+      return
+    end
+
+    col = Wx.get_colour_from_user(self, Wx::WHITE, "Choose colour")
+
+    if col.ok?
+      flags = (event.id==ID::SETBGCOLOURRECUR) ? Wx::PG::PG_RECURSE : 0
+      pg.set_property_background_colour(prop, col, flags)
+    end
+  end
+
+  def on_clear_modify_status_click(event)
+    @propGridManager.clear_modified_status
+    @propGridManager.refresh
+  end
+
+  def on_freeze_click(event)
+    return unless @propGridManager
+
+    if event.checked?
+      unless @propGridManager.is_frozen
+        @propGridManager.freeze
+      end
+    else
+      if @propGridManager.frozen?
+        @propGridManager.thaw
+        @propGridManager.refresh
+      end
+    end
+  end
+
+  def on_enable_label_editing(event)
+    @labelEditingEnabled = event.checked?
+    @propGrid.make_column_editable(0, @labelEditingEnabled)
+  end
+
+  if Wx.has_feature?(:USE_HEADERCTRL)
+    def on_show_header(event)
+      @hasHeader = event.checked?
+      @propGridManager.show_header(@hasHeader)
+      if @hasHeader
+        @propGridManager.set_column_title(2, "Units")
+      end
+    end
+  end
+
+  def on_dump_list(event)
+    values = @propGridManager.get_property_values("list", nil, Wx::PG::PG_INC_ATTRIBUTES)
+    text = "This only tests that wxVariant related routines do not crash.\n"
+
+    Wx.Dialog(self, Wx::ID_ANY,"wxVariant Test",
+              Wx::DEFAULT_POSITION,Wx::DEFAULT_SIZE,Wx::DEFAULT_DIALOG_STYLE|Wx::RESIZE_BORDER) do |dlg|
+      values.get_count.times do |i|
+        v = values[i]
+
+        strValue = v.to_s
+
+        if v.name.end_with?("@attr")
+          text << "Attributes:\n"
+
+          v.count.times do |n|
+            a = v[n]
+
+            t = "  attribute %i: name=\"%s\"  (type=\"%s\"  value=\"%s\")\n" % [n , a.name, a.type, a.to_s]
+            text << t
+          end
+        else
+          t = "%i: name=\"%s\"  type=\"%s\"  value=\"%s\"\n" % [i, v.name, v.type, strValue]
+          text << t
+        end
+      end
+
+      # multi-line text editor dialog
+      spacing = 8;
+      topsizer = Wx::BoxSizer.new(Wx::VERTICAL)
+      rowsizer = Wx::BoxSizer.new(Wx::HORIZONTAL)
+      ed = Wx::TextCtrl.new(dlg, Wx::ID_ANY, text, style: Wx::TE_MULTILINE|Wx::TE_READONLY)
+      rowsizer.add(ed, Wx::SizerFlags.new(1).expand.border(Wx::ALL, spacing))
+      topsizer.add(rowsizer, Wx::SizerFlags.new(1).expand)
+      rowsizer = Wx::BoxSizer.new(Wx::HORIZONTAL)
+      rowsizer.add(Wx::Button.new(dlg, Wx::ID_OK, "Ok"),
+                   Wx::SizerFlags.new.centre_horizontal.centre_vertical.border(Wx::Direction::BOTTOM|Wx::LEFT|Wx::RIGHT, spacing))
+      topsizer.add(rowsizer, Wx::SizerFlags.new.right)
+
+      dlg.set_sizer(topsizer)
+      topsizer.set_size_hints(dlg)
+
+      dlg.set_size([400,300])
+      dlg.centre
+      dlg.show_modal
+    end
+  end
+
+  def on_cat_colours_update_ui(event)
+    # Prevent menu item from being checked
+    # if it is selected from improper page.
+    pg = @propGridManager.grid
+    @itemCatColours.enable(
+      !!(pg.get_property_by_name("Appearance") &&
+        pg.get_property_by_name("PositionCategory") &&
+        pg.get_property_by_name("Environment") &&
+        pg.get_property_by_name("More Examples"))
+    )
+  end
+
+  def on_cat_colours(event)
+    pg = @propGridManager.grid
+    unless !!(pg.get_property_by_name("Appearance") &&
+              pg.get_property_by_name("PositionCategory") &&
+              pg.get_property_by_name("Environment") &&
+              pg.get_property_by_name("More Examples"))
+      Wx.message_box("First switch to 'Standard Items' page!")
+      return
+    end
+
+    @propGridManager.freeze
+
+    if event.checked?
+      # Set custom colours.
+      pg.set_property_text_colour("Appearance", Wx::Colour.new(255,0,0), Wx::PG::PG_DONT_RECURSE)
+      pg.set_property_background_colour("Appearance", Wx::Colour.new(255,255,183))
+      pg.set_property_text_colour("Appearance", Wx::Colour.new(255,0,183))
+      pg.set_property_text_colour("PositionCategory", Wx::Colour.new(0,255,0), Wx::PG::PG_DONT_RECURSE)
+      pg.set_property_background_colour("PositionCategory", Wx::Colour.new(255,226,190))
+      pg.set_property_text_colour("PositionCategory", Wx::Colour.new(255,0,190))
+      pg.set_property_text_colour("Environment", Wx::Colour.new(0,0,255), Wx::PG::PG_DONT_RECURSE)
+      pg.set_property_background_colour("Environment", Wx::Colour.new(208,240,175))
+      pg.set_property_text_colour("Environment", Wx::Colour.new(255,255,255))
+      pg.set_property_background_colour("More Examples", Wx::Colour.new(172,237,255))
+      pg.set_property_text_colour("More Examples", Wx::Colour.new(172,0,255))
+    else
+      # Revert to original.
+      pg.set_property_colours_to_default("Appearance")
+      pg.set_property_colours_to_default("Appearance", Wx::PG::PG_RECURSE)
+      pg.set_property_colours_to_default("PositionCategory")
+      pg.set_property_colours_to_default("PositionCategory", Wx::PG::PG_RECURSE)
+      pg.set_property_colours_to_default("Environment")
+      pg.set_property_colours_to_default("Environment", Wx::PG::PG_RECURSE)
+      pg.set_property_colours_to_default("More Examples", Wx::PG::PG_RECURSE)
+    end
+    @propGridManager.thaw
+    @propGridManager.refresh
+  end
+
+  def on_set_columns(event)
+    colCount = Wx::get_number_from_user("Enter number of columns (2-20).","Columns:",
+                                          "Change Columns", @propGridManager.get_column_count,
+                                          2,20)
+
+    if colCount != @propGridManager.column_count
+      @propGridManager.set_column_count(colCount)
+    end
+  end
+
+  def on_set_virtual_width(evt)
+    oldWidth = @propGridManager.current_page.get_virtual_width
+    newWidth = oldWidth
+    Wx.NumberEntryDialog(self, "Enter virtual width (-1-2000).", "Width:",
+                              "Change Virtual Width", oldWidth, -1, 2000) do |dlg|
+      newWidth = dlg.value if dlg.show_modal == Wx::ID_OK
+    end
+    if newWidth != oldWidth
+      @propGridManager.grid.set_virtual_width(newWidth)
+    end
+  end
+
+  def on_set_grid_disabled(evt)
+    @propGridManager.enable(!evt.is_checked)
+  end
+
+  def on_misc(event)
+    case event.id
+    when ID::STATICLAYOUT
+      wsf = @propGridManager.get_window_style_flag
+      if event.is_checked
+        @propGridManager.set_window_style_flag(wsf|Wx::PG::PG_STATIC_LAYOUT)
+      else
+        @propGridManager.set_window_style_flag(wsf&~(Wx::PG::PG_STATIC_LAYOUT))
+      end
+    when ID::COLLAPSEALL
+      pg = @propGridManager.grid
+      pg.each_property(Wx::PG::PG_ITERATE_ALL) { |p| p.set_expanded(false) }
+      pg.refresh_grid
+    when ID::GETVALUES
+      @storedValues = @propGridManager.grid.get_property_values("Test",
+                                                                @propGridManager.grid.root,
+                                                                Wx::PG::PG_KEEP_STRUCTURE|Wx::PG::PG_INC_ATTRIBUTES)
+    when ID::SETVALUES
+      if @storedValues && @storedValues.is_type("list")
+        @propGridManager.grid.set_property_values(@storedValues)
+      else
+        Wx.message_box("First use Get Property Values.")
+      end
+    when ID::SETVALUES2
+      list = Wx::Variant.new([ Wx::Variant.new(1234, "VariantLong"),
+                               Wx::Variant.new(true,"VariantBool") ])
+      list.append(Wx::Variant.new("Test Text", "VariantString"))
+      @propGridManager.grid.set_property_values(list)
+    when ID::COLLAPSE
+      # Collapses selected.
+      selProp = @propGridManager.selection
+      @propGridManager.collapse(selProp) if selProp
+    when ID::RUNTESTFULL
+      # Runs a regression test.
+      run_tests(true)
+    when ID::RUNTESTPARTIAL
+      # Runs a regression test.
+      run_tests(false)
+    when ID::UNSPECIFY
+      prop = @propGridManager.selection
+      if prop
+        @propGridManager.set_property_value_unspecified(prop)
+        prop.refresh_editor
+      end
+    end
+  end
+
+  def on_populate_click(event)
+    id = event.id
+    @propGrid.clear
+    @propGrid.freeze
+    if id == ID::POPULATE1
+      populate_with_standard_items
+    elsif id == ID::POPULATE2
+      populate_with_library_config
+    end
+    @propGrid.thaw
+  end
+
+  def on_set_spin_ctrl_editor_click(event)
+    if Wx.has_feature? :USE_SPINBTN
+      pgId = @propGridManager.get_selection
+      if pgId
+        @propGridManager.set_property_editor(pgId, Wx::PG::PG_EDITOR_SPIN_CTRL)
+      else
+        Wx.message_box("First select a property")
+      end
+    end
+  end
+
+  def on_test_replace_click(event)
+    pgId = @propGridManager.selection
+    if pgId
+      choices = Wx::PG::PGChoices.new
+      choices.add("Flag 0", 0x0001)
+      choices.add("Flag 1", 0x0002)
+      choices.add("Flag 2", 0x0004)
+      choices.add("Flag 3", 0x0008)
+      maxVal = 0x000F
+      # Look for unused property name
+      propName = "ReplaceFlagsProperty"
+      idx = 0;
+      while @propGridManager.get_property_by_name(propName)
+          propName = "ReplaceFlagsProperty %i" % (idx += 1)
+      end
+      # Replace property and select new one
+      # with random value in range [1..maxVal]
+      propVal = Time.now.to_i % maxVal + 1
+      newId = @propGridManager.replace_property(pgId, Wx::FlagsProperty.new(propName, Wx::PG::PG_LABEL,
+                                                                            choices, propVal))
+      @propGridManager.set_property_attribute(newId, Wx::PG::PG_BOOL_USE_CHECKBOX,
+                                              true, Wx::PG::PG_RECURSE)
+      @propGridManager.select_property(newId)
+    else
+      Wx.message_box("First select a property")
+    end
+  end
+
+  def on_test_xrc(event)
+    Wx.message_box("Sorry, not yet implemented")
+  end
+
+  def on_enable_common_values(event)
+    prop = @propGridManager.selection
+    if prop
+      prop.enable_common_value
+    else
+      Wx.message_box("First select a property")
+    end
+  end
+
+  def on_select_style(event)
+    extraStyle = style = 0
+    names, values = %w[
+      PG_HIDE_CATEGORIES
+      PG_AUTO_SORT
+      PG_BOLD_MODIFIED
+      PG_SPLITTER_AUTO_CENTER
+      PG_TOOLTIPS
+      PG_STATIC_SPLITTER
+      PG_HIDE_MARGIN
+      PG_LIMITED_EDITING
+      PG_TOOLBAR
+      PG_DESCRIPTION
+      PG_NO_INTERNAL_BORDER
+    ].inject([[],[]]) { |set, name| set[0] << "Wx::PG::#{name}"; set[1] << Wx::PG.const_get(name); set }
+    flags = @propGridManager.get_window_style
+    Wx.MultiChoiceDialog(self, "Select window styles to use",
+                             "wxPropertyGrid Window Style", names) do |dlg|
+      sel = []
+      values.each_with_index { |val, ix| sel << ix if (flags & val) == val }
+      dlg.set_selections(sel)
+      return if dlg.show_modal == Wx::ID_CANCEL
+
+      flags = 0
+      sel = dlg.selections
+      sel.each { |ix| flags |= values[ix] }
+      style = flags
+    end
+
+    names, values = %w[
+      PG_EX_INIT_NOCAT
+      PG_EX_NO_FLAT_TOOLBAR
+      PG_EX_MODE_BUTTONS
+      PG_EX_HELP_AS_TOOLTIPS
+      PG_EX_NATIVE_DOUBLE_BUFFERING
+      PG_EX_AUTO_UNSPECIFIED_VALUES
+      PG_EX_WRITEONLY_BUILTIN_ATTRIBUTES
+      PG_EX_HIDE_PAGE_BUTTONS
+      PG_EX_MULTIPLE_SELECTION
+      PG_EX_ENABLE_TLP_TRACKING
+      PG_EX_NO_TOOLBAR_DIVIDER
+      PG_EX_TOOLBAR_SEPARATOR
+      PG_EX_ALWAYS_ALLOW_FOCUS
+    ].inject([[],[]]) { |set, name| set[0] << "Wx::PG::#{name}"; set[1] << Wx::PG.const_get(name); set }
+    flags = @propGridManager.get_extra_style
+    Wx.MultiChoiceDialog(self, "Select extra window styles to use",
+                         "wxPropertyGrid Extra Style", names) do |dlg|
+      sel = []
+      values.each_with_index { |val, ix| sel << ix if (flags & val) == val }
+      dlg.set_selections(sel)
+      return if dlg.show_modal == Wx::ID_CANCEL
+
+      flags = 0
+      sel = dlg.selections
+      sel.each { |ix| flags |= values[ix] }
+      extraStyle = flags
+    end
+
+    replace_grid(style, extraStyle)
+  end
+
+  def on_fit_columns_click(event)
+    page = @propGridManager.get_current_page
+
+    # Remove auto-centering
+    @propGridManager.set_window_style(@propGridManager.get_window_style & ~Wx::PG::PG_SPLITTER_AUTO_CENTER)
+
+    # Grow manager size just prior fit - otherwise
+    # column information may be lost.
+    oldGridSize = @propGridManager.grid.get_client_size
+    oldFullSize = self.size
+    self.size = ([1000, oldFullSize.height])
+
+    newSz = page.fit_columns
+
+    dx = oldFullSize.width - oldGridSize.width;
+    dy = oldFullSize.height - oldGridSize.height;
+
+    newSz.inc_by(dx, dy)
+
+    self.size = newSz
+  end
+
+  def on_change_flags_prop_items_click(event)
+    p = @propGridManager.get_property_by_name("Window Styles")
+
+    newChoices = Wx::PG::PGChoices.new
+    newChoices.add("Fast",0x1)
+    newChoices.add("Powerful",0x2)
+    newChoices.add("Safe",0x4)
+    newChoices.add("Sleek",0x8)
+
+    p.set_choices(newChoices)
+  end
+
+  # def on_save_to_file_click(event) end
+
+  # def on_load_from_file_click(event) end
+
+  def on_set_property_value(event)
+    pg = @propGridManager.grid
+    selected = pg.selection
+
+    if selected
+      value = Wx.get_text_from_user("Enter new value:")
+      pg.set_property_value(selected, value)
+    end
+  end
+
+  def on_insert_choice(event)
+    pg = @propGridManager.grid
+    selected = pg.selection
+
+    if selected
+      choices = selected.choices
+
+      if choices.ok?
+        # Insert new choice to the center of list
+        pos = choices.count / 2
+        selected.insert_choice("New Choice", pos)
+        return
+      end
+    end
+
+    Wx.message_box("First select a property with some choices.")
+  end
+
+  def on_delete_choice(event)
+    pg = @propGridManager.grid
+    selected = pg.selection
+
+    if selected
+      choices = selected.choices
+
+      if choices.ok?
+        # Deletes choice from the center of list
+        pos = choices.count / 2
+        selected.delete_choice(pos)
+        return
+      end
+    end
+
+    Wx.message_box("First select a property with some choices.")
+  end
+
+  def on_insert_page(event)
+    @propGridManager.add_page("New Page")
+  end
+
+  def on_remove_page(event)
+    @propGridManager.remove_page(@propGridManager.get_selected_page)
+  end
+
+  def on_save_state(event)
+    @savedState = @propGridManager.save_editable_state
+    Wx.log_debug("Saved editable state string: \"%s\"", @savedState)
+  end
+
+  def on_restore_state(event)
+    @propGridManager.restore_editable_state(@savedState) if @savedState
+  end
+
+  def on_run_minimal_click(event)
+    display_minimal_frame(self)
+  end
+
+  def iterate_message(prop)
+    s = "\"%s\" class = %s, valuetype = %s" % [prop.label,  prop.class.name, prop.value_type]
+
+    Wx.message_box(s, "Iterating... (press CANCEL to end)", Wx::OK|Wx::CANCEL)
+  end
+  private :iterate_message
+
+  def on_iterate1_click(event)
+    @propGridManager.get_current_page.each_property do |p|
+      break if iterate_message(p) == Wx::CANCEL
+    end
+  end
+
+  def on_iterate2_click(event)
+    @propGridManager.get_current_page.each_property(Wx::PG::PG_ITERATE_VISIBLE) do |p|
+      break if iterate_message(p) == Wx::CANCEL
+    end
+  end
+
+  def on_iterate3_click(event)
+    @propGridManager.get_current_page.properties_reversed(Wx::PG::PG_ITERATE_DEFAULT).each do |p|
+      break if iterate_message(p) == Wx::CANCEL
+    end
+  end
+
+  def on_iterate4_click(event)
+    @propGridManager.get_current_page.each_property(Wx::PG::PG_ITERATE_CATEGORIES) do |p|
+      break if iterate_message(p) == Wx::CANCEL
+    end
+  end
+
+  def on_extended_key_nav(event)
+    # Use AddActionTrigger() and DedicateKey() to set up Enter,
+    # Up, and Down keys for navigating between properties.
+    propGrid = @propGridManager.grid
+
+    propGrid.add_action_trigger(Wx::PG::PG_ACTION_NEXT_PROPERTY,
+                                Wx::K_RETURN)
+    propGrid.dedicate_key(Wx::K_RETURN)
+
+    # Up and Down keys are already associated with navigation,
+    # but we must also prevent them from being eaten by
+    # editor controls.
+    propGrid.dedicate_key(Wx::K_UP)
+    propGrid.dedicate_key(Wx::K_DOWN)
+  end
+
+  def on_property_grid_change(event)
+    property = event.property
+
+    name = property.name
+
+    # Properties store values internally as wxVariants, but it is preferred
+    # to use the more modern wxAny at the interface level in C++
+    # wxRuby however does not support wxAny and does not need to as Variants map
+    # pretty seamless to Ruby
+    value = property.value
+
+    # Don't handle 'unspecified' values
+    return if value.null?
+
+    # Some settings are disabled outside Windows platform
+    if name == "X"
+        set_size(value.to_i, -1, -1, -1, Wx::SIZE_USE_EXISTING)
+    elsif name == "Y"
+      set_size(-1, value.to_i, -1, -1, Wx::SIZE_USE_EXISTING)
+    elsif ( name == "Width" )
+      set_size(-1, -1, value.to_i, -1, Wx::SIZE_USE_EXISTING)
+    elsif name == "Height"
+      set_size( -1, -1, -1, value.to_i, Wx::SIZE_USE_EXISTING)
+    elsif name == "Label"
+      set_title(value.to_s)
+    elsif name == "Font"
+      font = value.font
+      unless font.ok?
+        Wx.message_box('Invalid font!')
+        return
+      end
+      @propGridManager.set_font(font)
+    elsif name == "Margin Colour"
+      cpv = value.colour_property_value
+      @propGridManager.grid.set_margin_colour(cpv.colour_)
+    elsif name == "Cell Colour"
+      cpv = value.colour_property_value
+      @propGridManager.grid.set_cell_background_colour(cpv.colour_)
+    elsif name == "Line Colour"
+      cpv = value.colour_property_value
+      @propGridManager.grid.set_line_colour(cpv.colour_)
+    elsif name == "Cell Text Colour"
+      cpv = value.colour_property_value
+      @propGridManager.grid.set_cell_text_colour(cpv.colour_)
+    end
+  end
+
+  def on_property_grid_changing(event)
+    p = event.property
+
+    if p.name == "Font"
+      res = Wx.message_box("'%s' is about to change (to variant of type '%s')\n\nAllow or deny?" %
+                                      [p.name, event.value.type],
+                     "Testing wxEVT_PG_CHANGING", Wx::YES_NO, @propGridManager)
+      if res == Wx::NO
+        Kernel.raise 'Must be able to Veto event' unless event.can_veto?
+
+        event.veto
+
+        # Since we ask a question, it is better if we omit any validation
+        # failure behaviour.
+        event.set_validation_failure_behavior(0)
+      end
+    end
+  end
+
+  def on_property_grid_select(event)
+    property = event.property
+    if property
+      @itemEnable.enable(true)
+      if property.enabled?
+        @itemEnable.set_item_label("Disable")
+      else
+        @itemEnable.set_item_label("Enable")
+      end
+    else
+      @itemEnable.enable(false)
+    end
+
+    if Wx.has_feature? :USE_STATUSBAR
+      prop = event.property
+      sb = self.status_bar
+      if prop
+        text = "Selected: "
+        text << @propGridManager.get_property_label(prop)
+        sb.set_status_text(text)
+      end
+    end
+  end
+
+  def on_property_grid_highlight(event)
+  end
+
+  def on_property_grid_item_right_click(event)
+    if Wx.has_feature? :USE_STATUSBAR
+      prop = event.property
+      sb = self.status_bar
+      if prop
+        text  = "Right-clicked: "
+        text << prop.label
+        text << ", name=";
+        text << @propGridManager.get_property_name(prop)
+        sb.set_status_text(text)
+      else
+        sb.set_status_text('')
+      end
+    end
+  end
+
+  def on_property_grid_item_double_click(event)
+    if Wx.has_feature? :USE_STATUSBAR
+      prop = event.property
+      sb = self.status_bar
+      if prop
+        text = "Double-clicked: "
+        text << prop.label
+        text << ", name="
+        text << @propGridManager.get_property_name(prop)
+        sb.set_status_text(text)
+      else
+        sb.set_status_text('')
+      end
+    end
+  end
+
+  def on_property_grid_page_change(event)
+    if Wx.has_feature? :USE_STATUSBAR
+      sb = self.status_bar
+      text = "Page Changed: "
+      text << @propGridManager.get_page_name(@propGridManager.get_selected_page)
+      sb.set_status_text(text)
+    end
+  end
+
+  def on_property_grid_button_click(event)
+    if Wx.has_feature? :USE_STATUSBAR
+      prop = @propGridManager.selection
+      sb = self.status_bar
+      if prop
+        text = "Button clicked: "
+        text << @propGridManager.get_property_label(prop)
+        text << ", name="
+        text << @propGridManager.get_property_name(prop)
+        sb.set_status_text(text)
+      else
+        Wx.message_box("SHOULD NOT HAPPEN!!!")
+      end
+    end
+  end
+
+  def on_property_grid_text_update(event)
+    event.skip
+  end
+
+  def on_property_grid_key_event(event)
+  end
+
+  def on_property_grid_item_collapse(event)
+    Wx.log_message("Item was Collapsed")
+  end
+
+  def on_property_grid_item_expand(event)
+    Wx.log_message("Item was Expanded")
+  end
+
+  def on_property_grid_label_edit_begin(event)
+    Wx.log_message("PG_EVT_LABEL_EDIT_BEGIN(%s)", event.property.label)
+  end
+
+  def on_property_grid_label_edit_ending(event)
+    Wx.log_message("PG_EVT_LABEL_EDIT_ENDING(%s)", event.property.label)
+  end
+
+  def on_property_grid_col_begin_drag(event)
+    if @itemVetoDragging.is_checked
+      Wx.log_message("Splitter %i resize was vetoed", event.column)
+      event.veto
+    else
+      Wx.log_debug("Splitter %i resize began", event.column)
+    end
+  end
+
+  def on_property_grid_col_dragging(event)
+  end
+
+  def on_property_grid_col_end_drag(event)
+    Wx.log_debug("Splitter %i resize ended", event.column)
+  end
+
+  def on_about(event)
+    toolkit = "%s %i.%i.%i" % [Wx::PlatformInfo.get_port_id_name,
+                               Wx::PlatformInfo.get_toolkit_major_version,
+                               Wx::PlatformInfo.get_toolkit_minor_version,
+                               Wx::PlatformInfo.get_toolkit_micro_version]
+    msg = ("wxRuby PropertyGrid Sample" +
+    if Wx.has_feature? :USE_UNICODE
+      if Wx.has_feature?(:USE_UNICODE_UTF8) && Wx.has_feature?(:USE_UNICODE_UTF8)
+        " <utf-8>"
+      else
+        " <unicode>"
+      end
+    else
+      " <ansi>"
+    end +
+    if Wx::RB_DEBUG
+      " <debug>"
+    else
+      " <release>"
+    end +
+    "\n\n" +
+    "Programmed by %s\n\n" +
+    "Using wxRuby %s (wxWidgets %s; %s)\n\n") %
+      ["Martin Corino (C++ original by Jaakko Salli)", Wx::WXRUBY_VERSION, Wx::WXWIDGETS_VERSION, toolkit]
+
+    Wx.message_box(msg, "About", Wx::OK | Wx::ICON_INFORMATION, self)
+  end
+
+  def on_move(event)
+    unless @propGridManager
+      # this check is here so the frame layout can be tested
+      # without creating propertygrid
+      event.skip
+      return
+    end
+
+    # Update position properties
+    pos = get_position
+
+    # Must check if properties exist (as they may be deleted).
+
+    # Using m_pPropGridManager, we can scan all pages automatically.
+    id = @propGridManager.get_property_by_name("X")
+    @propGridManager.set_property_value(id, pos.x) if id
+
+    id = @propGridManager.get_property_by_name("Y")
+    @propGridManager.set_property_value( id, pos.y) if id
+
+    id = @propGridManager.get_property_by_name("Position")
+    @propGridManager.set_property_value(id, pos) if id
+
+    # Should always call event.skip in frame's MoveEvent handler
+    event.skip
+  end
+
+  def on_resize(event)
+    unless @propGridManager
+      # this check is here so the frame layout can be tested
+      # without creating propertygrid
+      event.skip
+      return
+    end
+
+    # Update size properties
+    sz = get_size
+
+    # Must check if properties exist (as they may be deleted).
+
+    # Using m_pPropGridManager, we can scan all pages automatically.
+    p = @propGridManager.get_property_by_name("Width")
+    @propGridManager.set_property_value(p, sz.width) if p && !p.is_value_unspecified
+
+    p = @propGridManager.get_property_by_name("Height")
+    @propGridManager.set_property_value(p, sz.height) if p && !p.is_value_unspecified
+
+    id = @propGridManager.get_property_by_name("Size")
+    @propGridManager.set_property_value(id, sz) if id
+
+    # Should always call event.skip in frame's SizeEvent handler
+    event.skip
+  end
+
+  def on_idle(event)
+    event.skip
+  end
+
+  def on_show_popup(event)
+    if @popup
+      @popup.destroy
+      @popup = nil
+      return
+    end
+
+    @popup = PropertyGridPopup.new(self)
+    pt = Wx.get_mouse_position
+    @popup.position(pt, [0, 0])
+    @popup.show
+  end
+
+  def add_test_properties(pg)
+    pg.append(MyColourProperty.new("CustomColourProperty", Wx::PG::PG_LABEL, Wx::GREEN))
+    pg.get_property("CustomColourProperty").set_auto_unspecified(true)
+    pg.set_property_editor("CustomColourProperty", Wx::PG::PG_EDITOR_COMBO_BOX)
+
+    pg.set_property_help_string("CustomColourProperty",
+                             "This is a MyColourProperty from the sample app. "+
+                               "It is built by subclassing wxColourProperty.")
+  end
+
+  def run_tests(fullTest, interactive = false) end
+
+end
+
+module PropgridSample
+
+  include WxRuby::Sample if defined? WxRuby::Sample
+
+  def self.describe
+    { file: __FILE__,
+      summary: 'wxRuby PropGrid example.',
+      description: 'wxRuby PropGrid example displaying frame showcasing PropgridManager.' }
+  end
+
+  def self.activate
+    frameSize = Wx::Size.new((Wx::SystemSettings.get_metric(Wx::SYS_SCREEN_X) / 10) * 4,
+                             (Wx::SystemSettings.get_metric(Wx::SYS_SCREEN_Y) / 10) * 8)
+    frameSize.width = 500 if frameSize.width > 500
+    frame = FormMain.new("wxPropertyGrid Sample", [0,0], frameSize)
+    frame.show(true)
+    frame
+  end
+
+  if $0 == __FILE__
+    Wx::App.run do
+      gc_stress
+      PropgridSample.activate
+    end
+  end
+
+end