fxruby 1.6.5 → 1.6.6

data/examples/splitter.rb

@@ -1,6 +1,7 @@
 #!/usr/bin/env ruby
 
 require 'fox16'
+require 'fox16/kwargs'
 
 include Fox
 
@@ -11,9 +12,9 @@ class SplitterWindow < FXMainWindow
     begin
       filename = File.join("icons", filename)
       icon = nil
-      File.open(filename, "rb") { |f|
+      File.open(filename, "rb") do |f|
         icon = FXPNGIcon.new(getApp(), f.read)
-      }
+      end
       icon
     rescue
       raise RuntimeError, "Couldn't load icon: #{filename}"
@@ -23,7 +24,7 @@ class SplitterWindow < FXMainWindow
 
   def initialize(app)
     # Do base class initialize first
-    super(app, "Splitter Test", nil, nil, DECOR_ALL, 0, 0, 800, 600)
+    super(app, "Splitter Test", :opts => DECOR_ALL, :width => 800, :height => 600)
 
     # Construct some icons we'll use
     folder_open   = makeIcon("minifolderopen.png")
@@ -46,7 +47,7 @@ class SplitterWindow < FXMainWindow
     @splitter = FXSplitter.new(self, (LAYOUT_SIDE_TOP|LAYOUT_FILL_X|
       LAYOUT_FILL_Y|SPLITTER_REVERSED|SPLITTER_TRACKING))
     group1 = FXVerticalFrame.new(@splitter,
-      FRAME_SUNKEN|FRAME_THICK|LAYOUT_FILL_X|LAYOUT_FILL_Y, 0,0,0,0, 0,0,0,0)
+      FRAME_SUNKEN|FRAME_THICK|LAYOUT_FILL_X|LAYOUT_FILL_Y, :padding => 0)
     group2 = FXVerticalFrame.new(@splitter,
       FRAME_SUNKEN|FRAME_THICK|LAYOUT_FILL_X|LAYOUT_FILL_Y)
     group3 = FXVerticalFrame.new(@splitter,
@@ -75,8 +76,8 @@ class SplitterWindow < FXMainWindow
    
     FXMenuTitle.new(menubar, "&Mode", nil, modemenu)
       
-    tree = FXTreeList.new(group1, nil, 0, 
-      (LAYOUT_FILL_X|LAYOUT_FILL_Y|LAYOUT_TOP|LAYOUT_RIGHT|TREELIST_SHOWS_LINES|
+    tree = FXTreeList.new(group1,
+      :opts => (LAYOUT_FILL_X|LAYOUT_FILL_Y|LAYOUT_TOP|LAYOUT_RIGHT|TREELIST_SHOWS_LINES|
       TREELIST_SHOWS_BOXES|TREELIST_ROOT_BOXES|TREELIST_EXTENDEDSELECT))
   
     topmost = tree.appendItem(nil, "Top", folder_open, folder_closed)

data/examples/tabbook.rb

@@ -1,6 +1,7 @@
 #!/usr/bin/env ruby
 
 require 'fox16'
+require 'fox16/kwargs'
 
 include Fox
 
@@ -8,7 +9,7 @@ class TabBookWindow < FXMainWindow
 
   def initialize(app)
     # Call the base class initializer first
-    super(app, "Tab Book Test", nil, nil, DECOR_ALL, 0, 0, 600, 400)
+    super(app, "Tab Book Test", :opts => DECOR_ALL, :width => 600, :height => 400)
 
     # Make a tooltip
     FXToolTip.new(getApp())
@@ -25,13 +26,12 @@ class TabBookWindow < FXMainWindow
       LAYOUT_SIDE_TOP|FRAME_NONE|LAYOUT_FILL_X|LAYOUT_FILL_Y|PACK_UNIFORM_WIDTH)
   
     # Switcher
-    @tabbook = FXTabBook.new(contents, nil, 0,
-      LAYOUT_FILL_X|LAYOUT_FILL_Y|LAYOUT_RIGHT)
+    @tabbook = FXTabBook.new(contents,:opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|LAYOUT_RIGHT)
   
     # First item is a list
     @tab1 = FXTabItem.new(@tabbook, "&Simple List", nil)
     listframe = FXHorizontalFrame.new(@tabbook, FRAME_THICK|FRAME_RAISED)
-    simplelist = FXList.new(listframe, nil, 0, LIST_EXTENDEDSELECT|LAYOUT_FILL_X|LAYOUT_FILL_Y)
+    simplelist = FXList.new(listframe, :opts => LIST_EXTENDEDSELECT|LAYOUT_FILL_X|LAYOUT_FILL_Y)
     simplelist.appendItem("First Entry")
     simplelist.appendItem("Second Entry")
     simplelist.appendItem("Third Entry")
@@ -40,14 +40,13 @@ class TabBookWindow < FXMainWindow
     # Second item is a file list
     @tab2 = FXTabItem.new(@tabbook, "F&ile List", nil)
     @fileframe = FXHorizontalFrame.new(@tabbook, FRAME_THICK|FRAME_RAISED)
-    filelist = FXFileList.new(@fileframe, nil, 0,
-      ICONLIST_EXTENDEDSELECT|LAYOUT_FILL_X|LAYOUT_FILL_Y)
+    filelist = FXFileList.new(@fileframe, :opts => ICONLIST_EXTENDEDSELECT|LAYOUT_FILL_X|LAYOUT_FILL_Y)
     
     # Third item is a directory list
     @tab3 = FXTabItem.new(@tabbook, "T&ree List", nil)
     dirframe = FXHorizontalFrame.new(@tabbook, FRAME_THICK|FRAME_RAISED)
-    dirlist = FXDirList.new(dirframe, nil, 0, (DIRLIST_SHOWFILES|
-      TREELIST_SHOWS_LINES|TREELIST_SHOWS_BOXES|LAYOUT_FILL_X|LAYOUT_FILL_Y))
+    dirlist = FXDirList.new(dirframe,
+      :opts => DIRLIST_SHOWFILES|TREELIST_SHOWS_LINES|TREELIST_SHOWS_BOXES|LAYOUT_FILL_X|LAYOUT_FILL_Y)
     
     # File Menu
     filemenu = FXMenuPane.new(self)
@@ -65,7 +64,7 @@ class TabBookWindow < FXMainWindow
     tabmenu = FXMenuPane.new(self)
     hideShow = FXMenuCheck.new(tabmenu, "Hide/Show Tab 2")
     hideShow.connect(SEL_COMMAND) {
-      if @tab2.shown
+      if @tab2.shown?
         @tab2.hide
         @fileframe.hide
       else
@@ -76,30 +75,73 @@ class TabBookWindow < FXMainWindow
       @fileframe.recalc
     }
     hideShow.connect(SEL_UPDATE) { hideShow.check = @tab2.shown? }
-    FXMenuCommand.new(tabmenu, "&Top Tabs").connect(SEL_COMMAND) {
+    
+    FXMenuSeparator.new(tabmenu)
+    
+    topTabsCmd = FXMenuRadio.new(tabmenu, "&Top Tabs")
+    topTabsCmd.connect(SEL_COMMAND) do
       @tabbook.tabStyle = TABBOOK_TOPTABS
       @tab1.tabOrientation = TAB_TOP
       @tab2.tabOrientation = TAB_TOP
       @tab3.tabOrientation = TAB_TOP
-    }
-    FXMenuCommand.new(tabmenu, "&Bottom Tabs").connect(SEL_COMMAND) {
+    end
+    topTabsCmd.connect(SEL_UPDATE) do |sender, sel, ptr|
+      sender.check = (@tabbook.tabStyle == TABBOOK_TOPTABS)
+    end
+    
+    bottomTabsCmd = FXMenuRadio.new(tabmenu, "&Bottom Tabs")
+    bottomTabsCmd.connect(SEL_COMMAND) do
       @tabbook.tabStyle = TABBOOK_BOTTOMTABS
       @tab1.tabOrientation = TAB_BOTTOM
       @tab2.tabOrientation = TAB_BOTTOM
       @tab3.tabOrientation = TAB_BOTTOM
-    }
-    FXMenuCommand.new(tabmenu, "&Left Tabs").connect(SEL_COMMAND) {
+    end
+    bottomTabsCmd.connect(SEL_UPDATE) do |sender, sel, ptr|
+      sender.check = (@tabbook.tabStyle == TABBOOK_BOTTOMTABS)
+    end
+    
+    leftTabsCmd = FXMenuRadio.new(tabmenu, "&Left Tabs")
+    leftTabsCmd.connect(SEL_COMMAND) do
       @tabbook.tabStyle = TABBOOK_LEFTTABS
       @tab1.tabOrientation = TAB_LEFT
       @tab2.tabOrientation = TAB_LEFT
       @tab3.tabOrientation = TAB_LEFT
-    }
-    FXMenuCommand.new(tabmenu, "&Right Tabs").connect(SEL_COMMAND) {
+    end
+    leftTabsCmd.connect(SEL_UPDATE) do |sender, sel, ptr|
+      sender.check = (@tabbook.tabStyle == TABBOOK_LEFTTABS)
+    end
+    
+    rightTabsCmd = FXMenuRadio.new(tabmenu, "&Right Tabs")
+    rightTabsCmd.connect(SEL_COMMAND) do
       @tabbook.tabStyle = TABBOOK_RIGHTTABS
       @tab1.tabOrientation = TAB_RIGHT
       @tab2.tabOrientation = TAB_RIGHT
       @tab3.tabOrientation = TAB_RIGHT
-    }
+    end
+    rightTabsCmd.connect(SEL_UPDATE) do |sender, sel, ptr|
+      sender.check = (@tabbook.tabStyle == TABBOOK_RIGHTTABS)
+    end
+    
+    FXMenuSeparator.new(tabmenu)
+    
+    addTabCmd = FXMenuCommand.new(tabmenu, "Add Tab")
+    addTabCmd.connect(SEL_COMMAND) do
+      FXTabItem.new(@tabbook, "New Tab")
+      FXHorizontalFrame.new(@tabbook, FRAME_THICK|FRAME_RAISED) do |hf|
+        FXLabel.new(hf, "Always add tab item and contents together.", :opts => LAYOUT_FILL)
+      end
+      @tabbook.create # realize widgets
+      @tabbook.recalc # mark parent layout dirty
+    end
+    
+    removeTabCmd = FXMenuCommand.new(tabmenu, "Remove Last Tab")
+    removeTabCmd.connect(SEL_COMMAND) do
+      numTabs = @tabbook.numChildren/2
+      doomedTab = numTabs - 1
+      @tabbook.removeChild(@tabbook.childAtIndex(2*doomedTab+1))
+      @tabbook.removeChild(@tabbook.childAtIndex(2*doomedTab))
+    end
+
     FXMenuTitle.new(menubar, "&Tab Placement", nil, tabmenu)
   end
 

data/examples/table.rb

@@ -1,6 +1,7 @@
 #!/usr/bin/env ruby
 
 require 'fox16'
+require 'fox16/kwargs'
 require 'date'
 
 include Fox
@@ -9,16 +10,16 @@ class TableWindow < FXMainWindow
 
   def initialize(app)
     # Call the base class initializer first
-    super(app, "Table Widget Test", nil, nil, DECOR_ALL, 0, 0, 0, 0)
+    super(app, "Table Widget Test", :opts => DECOR_ALL)
 
     # Tooltip
     tooltip = FXToolTip.new(getApp())
     
     # Icon used in some cells
     penguinicon = nil
-    File.open(File.join('icons', 'penguin.png'), 'rb') { |f|
+    File.open(File.join('icons', 'penguin.png'), 'rb') do |f|
       penguinicon = FXPNGIcon.new(getApp(), f.read, 0, IMAGE_ALPHAGUESS)
-    }
+    end
     
     # Menubar
     menubar = FXMenuBar.new(self, LAYOUT_SIDE_TOP|LAYOUT_FILL_X)
@@ -30,17 +31,12 @@ class TableWindow < FXMainWindow
     contents = FXVerticalFrame.new(self, LAYOUT_SIDE_TOP|FRAME_NONE|LAYOUT_FILL_X|LAYOUT_FILL_Y)
     
     frame = FXVerticalFrame.new(contents,
-      FRAME_SUNKEN|FRAME_THICK|LAYOUT_FILL_X|LAYOUT_FILL_Y) do |f|
-      f.padLeft = 0
-      f.padRight = 0
-      f.padTop = 0
-      f.padBottom = 0
-    end
+      FRAME_SUNKEN|FRAME_THICK|LAYOUT_FILL_X|LAYOUT_FILL_Y, :padding => 0)
   
     # Table
-    @table = FXTable.new(frame, nil, 0,
-      TABLE_COL_SIZABLE|TABLE_ROW_SIZABLE|LAYOUT_FILL_X|LAYOUT_FILL_Y,
-      0,0,0,0, 2,2,2,2)
+    @table = FXTable.new(frame,
+      :opts => TABLE_COL_SIZABLE|TABLE_ROW_SIZABLE|LAYOUT_FILL_X|LAYOUT_FILL_Y,
+      :padding => 2)
       
     @table.visibleRows = 20
     @table.visibleColumns = 8
@@ -134,11 +130,11 @@ class TableWindow < FXMainWindow
     # Set up its contents
     frame = FXHorizontalFrame.new(dlg, LAYOUT_FILL_X|LAYOUT_FILL_Y)
     FXLabel.new(frame, "Rows:", nil, LAYOUT_SIDE_LEFT|LAYOUT_CENTER_Y)
-    rows = FXTextField.new(frame, 5, nil, 0,
-      JUSTIFY_RIGHT|FRAME_SUNKEN|FRAME_THICK|LAYOUT_SIDE_LEFT|LAYOUT_CENTER_Y)
+    rows = FXTextField.new(frame, 5,
+      :opts => JUSTIFY_RIGHT|FRAME_SUNKEN|FRAME_THICK|LAYOUT_SIDE_LEFT|LAYOUT_CENTER_Y)
     FXLabel.new(frame, "Columns:", nil, LAYOUT_SIDE_LEFT|LAYOUT_CENTER_Y)
-    cols = FXTextField.new(frame, 5, nil, 0,
-      JUSTIFY_RIGHT|FRAME_SUNKEN|FRAME_THICK|LAYOUT_SIDE_LEFT|LAYOUT_CENTER_Y)
+    cols = FXTextField.new(frame, 5,
+      :opts => JUSTIFY_RIGHT|FRAME_SUNKEN|FRAME_THICK|LAYOUT_SIDE_LEFT|LAYOUT_CENTER_Y)
     FXButton.new(frame, "Cancel", nil, dlg, FXDialogBox::ID_CANCEL,
       FRAME_RAISED|FRAME_THICK|LAYOUT_SIDE_LEFT|LAYOUT_CENTER_Y)
     FXButton.new(frame, "  OK  ", nil, dlg, FXDialogBox::ID_ACCEPT,

data/ext/fox16/FXRuby.cpp

@@ -21,7 +21,7 @@
  ***********************************************************************/
 
 /***********************************************************************
- * $Id: FXRuby.cpp 2460 2006-07-09 23:38:59Z lyle $
+ * $Id: FXRuby.cpp 2608 2007-02-09 20:34:16Z lyle $
  ***********************************************************************/
 
 #ifdef _MSC_VER
@@ -877,7 +877,7 @@ static VALUE FXRbConvertMessageData(FXObject* sender,FXObject* recv,FXSelector s
     FXTRACE((100,"%s:%d: message data passed through as-is\n",__FILE__,__LINE__));
     return reinterpret_cast<VALUE>(ptr); // pass-through as is
     }
-  FXASSERT(FALSE);
+  FXTRACE((100,"%s:%d: message data passed through as-is\n",__FILE__,__LINE__));
   return reinterpret_cast<VALUE>(ptr); // pass-through as is
   }
 

data/lib/fox16/glshapes.rb

@@ -27,11 +27,11 @@ module Fox
     def initialize(*args)
       super()
       if args.length == 0
-	@pos = [0.0, 0.0, 0.0]
+        @pos = [0.0, 0.0, 0.0]
       elsif args.length == 3
-	@pos = [args[0], args[1], args[2]]
+        @pos = [args[0], args[1], args[2]]
       else
-	@pos = args[0]
+        @pos = args[0]
       end
     end
     
@@ -432,10 +432,10 @@ module Fox
     #
     def initialize(*args)
       if args.length == 4
-	super(args[0], args[1], args[2], SHADING_SMOOTH|STYLE_SURFACE)
+        super(args[0], args[1], args[2], SHADING_SMOOTH|STYLE_SURFACE)
       else
-	super(args[0], args[1], args[2], SHADING_SMOOTH|STYLE_SURFACE,
-              args[4], args[4])
+        super(args[0], args[1], args[2], SHADING_SMOOTH|STYLE_SURFACE,
+        args[4], args[4])
       end
       @radius = args[3] ? args[3] : 1.0
       @slices = SLICES_NUMBER

data/lib/fox16/iterators.rb

@@ -25,10 +25,11 @@ module Fox
     # reference to that item as a parameter.
     #
     def each # :yields: aFoldingItem
-      current = firstItem
+      current = first
       while current != nil
+        next_current = current.next
         yield current
-        current = current.next
+        current = next_current
       end
       self
     end
@@ -45,8 +46,9 @@ module Fox
     def each # :yields: aFoldingItem
       current = first
       while current != nil
+        next_current = current.next
         yield current
-        current = current.next
+        current = next_current
       end
       self
     end
@@ -164,8 +166,9 @@ module Fox
     def each # :yields: aTreeItem
       current = first
       while current != nil
+        next_current = current.next
         yield current
-        current = current.next
+        current = next_current
       end
       self
     end
@@ -180,10 +183,11 @@ module Fox
     # reference to that item as a parameter.
     #
     def each # :yields: aTreeItem
-      current = firstItem
+      current = first
       while current != nil
+        next_current = current.next
         yield current
-        current = current.next
+        current = next_current
       end
       self
     end
@@ -198,10 +202,11 @@ module Fox
     # reference to that item as a parameter.
     #
     def each # :yields: aTreeItem
-      current = firstItem
+      current = first
       while current != nil
+        next_current = current.next
         yield current
-        current = current.next
+        current = next_current
       end
       self
     end

data/lib/fox16/kwargs.rb

@@ -5,7 +5,7 @@ module Fox
 
   class FX4Splitter
     alias old_initialize initialize
-    def initialize(p, *args)
+    def initialize(p, *args, &blk)
       argument_names = %w{opts x y width height}
       default_params = { :opts => FOURSPLITTER_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0 }     
       params = {}
@@ -15,19 +15,19 @@ module Fox
         args.each_with_index { |e, i| params[argument_names[i-2].intern] = e if i >= 2 }
         params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
         params = default_params.merge(params)
-        old_initialize(p, tgt, sel, params[:opts], params[:x], params[:y], params[:width], params[:height])
+        old_initialize(p, tgt, sel, params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
       else
         args.each_with_index { |e, i| params[argument_names[i].intern] = e }
         params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
         params = default_params.merge(params)
-        old_initialize(p, params[:opts], params[:x], params[:y], params[:width], params[:height])
+        old_initialize(p, params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
       end
     end
   end
 
   class FXDockBar
     alias old_initialize initialize
-    def initialize(p, *args)
+    def initialize(p, *args, &blk)
       argument_names = %w{opts x y width height padLeft padRight padTop padBottom hSpacing vSpacing}
       default_params = { :opts => LAYOUT_TOP|LAYOUT_LEFT|LAYOUT_FILL_X, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => 3, :padRight => 3, :padTop => 2, :padBottom => 2, :hSpacing => DEFAULT_SPACING, :vSpacing => DEFAULT_SPACING }     
       params = {}
@@ -35,40 +35,48 @@ module Fox
       if args.length > 0 && (args.first.nil? || args.first.is_a?(FXComposite))
         q = args[0]
         args.each_with_index { |e, i| params[argument_names[i-1].intern] = e if i >= 1 }
+        if params.key? :padding
+          value = params.delete(:padding)
+          [:padLeft, :padRight, :padTop, :padBottom].each { |s| params[s] ||= value }
+        end
         params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
         params = default_params.merge(params)
-        old_initialize(p, q, params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], params[:hSpacing], params[:vSpacing])
+        old_initialize(p, q, params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], params[:hSpacing], params[:vSpacing], &blk)
       else
         args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+        if params.key? :padding
+          value = params.delete(:padding)
+          [:padLeft, :padRight, :padTop, :padBottom].each { |s| params[s] ||= value }
+        end
         params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
         params = default_params.merge(params)
-        old_initialize(p, params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], params[:hSpacing], params[:vSpacing])
+        old_initialize(p, params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], params[:hSpacing], params[:vSpacing], &blk)
       end
     end
   end
   
   class FXFont
     alias old_initialize initialize
-    def initialize(a, arg1, *args)
+    def initialize(a, arg1, *args, &blk)
       if args.length > 0
         face, size = arg1, args[0]
         argument_names = %w{weight slant encoding setWidth hints}
-        default_params = { :weight => FXFont::Normal, :slant => Font::Straight, :encoding => FONTENCODING_DEFAULT, :setWidth => FXFont::NonExpanded, :hints => 0 }     
+        default_params = { :weight => FXFont::Normal, :slant => FXFont::Straight, :encoding => FONTENCODING_DEFAULT, :setWidth => FXFont::NonExpanded, :hints => 0 }     
         params = {}
         params = args.pop if args.last.is_a? Hash
         args.each_with_index { |e, i| params[argument_names[i-1].intern] = e if i >= 1 }
         params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
         params = default_params.merge(params)
-        old_initialize(a, face, size, params[:weight], params[:slant], params[:encoding], params[:setWidth], params[:hints])
+        old_initialize(a, face, size, params[:weight], params[:slant], params[:encoding], params[:setWidth], params[:hints], &blk)
       else
-        old_initialize(a, arg1)
+        old_initialize(a, arg1, &blk)
       end
     end
   end
   
   class FXGLCanvas
     alias old_initialize initialize
-    def initialize(parent, vis, *args)
+    def initialize(parent, vis, *args, &blk)
       argument_names = %w{target selector opts x y width height}
       default_params = { :target => nil, :selector => 0, :opts => 0, :x => 0, :y => 0, :width => 0, :height => 0 }
       params = {}
@@ -78,19 +86,19 @@ module Fox
         args.each_with_index { |e, i| params[argument_names[i-1].intern] = e if i >= 1 }
         params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
         params = default_params.merge(params)
-        old_initialize(parent, vis, sharegroup, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height])
+        old_initialize(parent, vis, sharegroup, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
       else
         args.each_with_index { |e, i| params[argument_names[i].intern] = e }
         params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
         params = default_params.merge(params)
-        old_initialize(parent, vis, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height])
+        old_initialize(parent, vis, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
       end
     end
   end
 
   class FXGLViewer
     alias old_initialize initialize
-    def initialize(parent, vis, *args)
+    def initialize(parent, vis, *args, &blk)
       argument_names = %w{target selector opts x y width height}
       default_params = { :target => nil, :selector => 0, :opts => 0, :x => 0, :y => 0, :width => 0, :height => 0 }
       params = {}
@@ -100,40 +108,48 @@ module Fox
         args.each_with_index { |e, i| params[argument_names[i-1].intern] = e if i >= 1 }
         params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
         params = default_params.merge(params)
-        old_initialize(parent, vis, sharegroup, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height])
+        old_initialize(parent, vis, sharegroup, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
       else
         args.each_with_index { |e, i| params[argument_names[i].intern] = e }
         params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
         params = default_params.merge(params)
-        old_initialize(parent, vis, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height])
+        old_initialize(parent, vis, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
       end
     end
   end
   
   class FXMenuBar
     alias old_initialize initialize
-    def initialize(p, *args)
+    def initialize(p, *args, &blk)
       argument_names = %w{opts x y width height padLeft padRight padTop padBottom hSpacing vSpacing}
       default_params = { :opts => LAYOUT_TOP|LAYOUT_LEFT|LAYOUT_FILL_X, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => 3, :padRight => 3, :padTop => 2, :padBottom => 2, :hSpacing => DEFAULT_SPACING, :vSpacing => DEFAULT_SPACING }
       params = {}
       params = args.pop if args.last.is_a? Hash
       if args.length > 0 && (args[0].nil? || args[0].is_a?(FXComposite))
         args.each_with_index { |e, i| params[argument_names[i-1].intern] = e if i >= 1 }
+        if params.key? :padding
+          value = params.delete(:padding)
+          [:padLeft, :padRight, :padTop, :padBottom].each { |s| params[s] ||= value }
+        end
         params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
         params = default_params.merge(params)
-        old_initialize(p, q, params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], params[:hSpacing], params[:vSpacing])
+        old_initialize(p, q, params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], params[:hSpacing], params[:vSpacing], &blk)
       else
         args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+        if params.key? :padding
+          value = params.delete(:padding)
+          [:padLeft, :padRight, :padTop, :padBottom].each { |s| params[s] ||= value }
+        end
         params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
         params = default_params.merge(params)
-        old_initialize(p, params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], params[:hSpacing], params[:vSpacing])
+        old_initialize(p, params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], params[:hSpacing], params[:vSpacing], &blk)
       end
     end
   end
 
   class FXSplitter
     alias old_initialize initialize
-    def initialize(p, *args)
+    def initialize(p, *args, &blk)
       argument_names = %w{opts x y width height}
       default_params = { :opts => SPLITTER_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0 }     
       params = {}
@@ -143,19 +159,19 @@ module Fox
         args.each_with_index { |e, i| params[argument_names[i-2].intern] = e if i >= 2 }
         params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
         params = default_params.merge(params)
-        old_initialize(p, tgt, sel, params[:opts], params[:x], params[:y], params[:width], params[:height])
+        old_initialize(p, tgt, sel, params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
       else
         args.each_with_index { |e, i| params[argument_names[i].intern] = e }
         params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
         params = default_params.merge(params)
-        old_initialize(p, params[:opts], params[:x], params[:y], params[:width], params[:height])
+        old_initialize(p, params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
       end
     end
   end
 
   class FXToolBar
     alias old_initialize initialize
-    def initialize(p, *args)
+    def initialize(p, *args, &blk)
       argument_names = %w{opts x y width height padLeft padRight padTop padBottom hSpacing vSpacing}
       default_params = { :opts => LAYOUT_TOP|LAYOUT_LEFT|LAYOUT_FILL_X, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => 3, :padRight => 3, :padTop => 2, :padBottom => 2, :hSpacing => DEFAULT_SPACING, :vSpacing => DEFAULT_SPACING }     
       params = {}
@@ -163,23 +179,31 @@ module Fox
       if args.length > 0 && (args[0].nil? || args[0].is_a?(FXComposite))
         q = args[0]
         args.each_with_index { |e, i| params[argument_names[i-1].intern] = e if i >= 1 }
+        if params.key? :padding
+          value = params.delete(:padding)
+          [:padLeft, :padRight, :padTop, :padBottom].each { |s| params[s] ||= value }
+        end
         params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
         params = default_params.merge(params)
-        old_initialize(p, q, params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], params[:hSpacing], params[:vSpacing])
+        old_initialize(p, q, params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], params[:hSpacing], params[:vSpacing], &blk)
       else
         args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+        if params.key? :padding
+          value = params.delete(:padding)
+          [:padLeft, :padRight, :padTop, :padBottom].each { |s| params[s] ||= value }
+        end
         params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
         params = default_params.merge(params)
-        old_initialize(p, params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], params[:hSpacing], params[:vSpacing])
+        old_initialize(p, params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], params[:hSpacing], params[:vSpacing], &blk)
       end
     end
   end
   
   class FXWindow
     alias old_initialize initialize
-    def initialize(p, *args)
+    def initialize(p, *args, &blk)
       if p.is_a? FXApp
-        old_initialize(p, *args)
+        old_initialize(p, *args, &blk)
       else
         argument_names = %w{opts x y width height}
         default_params = { :opts => 0, :x => 0, :y => 0, :width => 0, :height => 0 }
@@ -188,28 +212,32 @@ module Fox
         args.each_with_index { |e, i| params[argument_names[i].intern] = e }
         params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
         params = default_params.merge(params)
-        old_initialize(p, params[:opts], params[:x], params[:y], params[:width], params[:height])
+        old_initialize(p, params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
       end
     end
   end
 
   class FX7Segment
     alias old_initialize initialize
-    def initialize(p, text, *args)
+    def initialize(p, text, *args, &blk)
       argument_names = %w{opts x y width height padLeft padRight padTop padBottom}
       default_params = { :opts => SEVENSEGMENT_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_PAD, :padRight => DEFAULT_PAD, :padTop => DEFAULT_PAD, :padBottom => DEFAULT_PAD }
       params = {}
       params = args.pop if args.last.is_a? Hash
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      if params.key? :padding
+        value = params.delete(:padding)
+        [:padLeft, :padRight, :padTop, :padBottom].each { |s| params[s] ||= value }
+      end
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(p, text, params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom])
+      old_initialize(p, text, params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
     end
   end
 
   class FXApp
     alias old_initialize initialize
-    def initialize(*args)
+    def initialize(*args, &blk)
       argument_names = %w{appName vendorName}
       default_params = { :appName => "Application", :vendorName => "FoxDefault" }
       params = {}
@@ -217,27 +245,31 @@ module Fox
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(params[:appName], params[:vendorName])
+      old_initialize(params[:appName], params[:vendorName], &blk)
     end
   end
 
   class FXArrowButton
     alias old_initialize initialize
-    def initialize(parent, *args)
+    def initialize(parent, *args, &blk)
       argument_names = %w{target selector opts x y width height padLeft padRight padTop padBottom}
       default_params = { :target => nil, :selector => 0, :opts => ARROW_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_PAD, :padRight => DEFAULT_PAD, :padTop => DEFAULT_PAD, :padBottom => DEFAULT_PAD }
       params = {}
       params = args.pop if args.last.is_a? Hash
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      if params.key? :padding
+        value = params.delete(:padding)
+        [:padLeft, :padRight, :padTop, :padBottom].each { |s| params[s] ||= value }
+      end
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(parent, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom])
+      old_initialize(parent, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
     end
   end
 
   class FXBitmap
     alias old_initialize initialize
-    def initialize(app, *args)
+    def initialize(app, *args, &blk)
       argument_names = %w{pixels opts width height}
       default_params = { :pixels => nil, :opts => 0, :width => 1, :height => 1 }
       params = {}
@@ -245,27 +277,31 @@ module Fox
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(app, params[:pixels], params[:opts], params[:width], params[:height])
+      old_initialize(app, params[:pixels], params[:opts], params[:width], params[:height], &blk)
     end
   end
 
   class FXBitmapFrame
     alias old_initialize initialize
-    def initialize(p, bmp, *args)
+    def initialize(p, bmp, *args, &blk)
       argument_names = %w{opts x y width height padLeft padRight padTop padBottom}
       default_params = { :opts => FRAME_SUNKEN|FRAME_THICK, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => 0, :padRight => 0, :padTop => 0, :padBottom => 0 }
       params = {}
       params = args.pop if args.last.is_a? Hash
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      if params.key? :padding
+        value = params.delete(:padding)
+        [:padLeft, :padRight, :padTop, :padBottom].each { |s| params[s] ||= value }
+      end
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(p, bmp, params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom])
+      old_initialize(p, bmp, params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
     end
   end
 
   class FXBitmapView
     alias old_initialize initialize
-    def initialize(p, *args)
+    def initialize(p, *args, &blk)
       argument_names = %w{bmp target selector opts x y width height}
       default_params = { :bmp => nil, :target => nil, :selector => 0, :opts => 0, :x => 0, :y => 0, :width => 0, :height => 0 }
       params = {}
@@ -273,13 +309,13 @@ module Fox
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(p, params[:bmp], params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height])
+      old_initialize(p, params[:bmp], params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
     end
   end
 
   class FXBMPIcon
     alias old_initialize initialize
-    def initialize(a, *args)
+    def initialize(a, *args, &blk)
       argument_names = %w{pix clr opts width height}
       default_params = { :pix => nil, :clr => FXRGB(192,192,192), :opts => 0, :width => 1, :height => 1 }
       params = {}
@@ -287,13 +323,13 @@ module Fox
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(a, params[:pix], params[:clr], params[:opts], params[:width], params[:height])
+      old_initialize(a, params[:pix], params[:clr], params[:opts], params[:width], params[:height], &blk)
     end
   end
 
   class FXBMPImage
     alias old_initialize initialize
-    def initialize(a, *args)
+    def initialize(a, *args, &blk)
       argument_names = %w{pix opts width height}
       default_params = { :pix => nil, :opts => 0, :width => 1, :height => 1 }
       params = {}
@@ -301,27 +337,31 @@ module Fox
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(a, params[:pix], params[:opts], params[:width], params[:height])
+      old_initialize(a, params[:pix], params[:opts], params[:width], params[:height], &blk)
     end
   end
 
   class FXButton
     alias old_initialize initialize
-    def initialize(parent, text, *args)
+    def initialize(parent, text, *args, &blk)
       argument_names = %w{icon target selector opts x y width height padLeft padRight padTop padBottom}
       default_params = { :icon => nil, :target => nil, :selector => 0, :opts => BUTTON_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_PAD, :padRight => DEFAULT_PAD, :padTop => DEFAULT_PAD, :padBottom => DEFAULT_PAD }
       params = {}
       params = args.pop if args.last.is_a? Hash
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      if params.key? :padding
+        value = params.delete(:padding)
+        [:padLeft, :padRight, :padTop, :padBottom].each { |s| params[s] ||= value }
+      end
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(parent, text, params[:icon], params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom])
+      old_initialize(parent, text, params[:icon], params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
     end
   end
 
   class FXCanvas
     alias old_initialize initialize
-    def initialize(parent, *args)
+    def initialize(parent, *args, &blk)
       argument_names = %w{target selector opts x y width height}
       default_params = { :target => nil, :selector => 0, :opts => FRAME_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0 }
       params = {}
@@ -329,27 +369,31 @@ module Fox
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(parent, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height])
+      old_initialize(parent, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
     end
   end
 
   class FXCheckButton
     alias old_initialize initialize
-    def initialize(parent, text, *args)
+    def initialize(parent, text, *args, &blk)
       argument_names = %w{target selector opts x y width height padLeft padRight padTop padBottom}
       default_params = { :target => nil, :selector => 0, :opts => CHECKBUTTON_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_PAD, :padRight => DEFAULT_PAD, :padTop => DEFAULT_PAD, :padBottom => DEFAULT_PAD }
       params = {}
       params = args.pop if args.last.is_a? Hash
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      if params.key? :padding
+        value = params.delete(:padding)
+        [:padLeft, :padRight, :padTop, :padBottom].each { |s| params[s] ||= value }
+      end
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(parent, text, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom])
+      old_initialize(parent, text, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
     end
   end
 
   class FXChoiceBox
     alias old_initialize initialize
-    def initialize(owner, caption, text, icon, choices, *args)
+    def initialize(owner, caption, text, icon, choices, *args, &blk)
       argument_names = %w{opts x y width height}
       default_params = { :opts => 0, :x => 0, :y => 0, :width => 0, :height => 0 }
       params = {}
@@ -357,27 +401,31 @@ module Fox
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(owner, caption, text, icon, choices, params[:opts], params[:x], params[:y], params[:width], params[:height])
+      old_initialize(owner, caption, text, icon, choices, params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
     end
   end
 
   class FXColorBar
     alias old_initialize initialize
-    def initialize(parent, *args)
+    def initialize(parent, *args, &blk)
       argument_names = %w{target selector opts x y width height padLeft padRight padTop padBottom}
       default_params = { :target => nil, :selector => 0, :opts => FRAME_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_PAD, :padRight => DEFAULT_PAD, :padTop => DEFAULT_PAD, :padBottom => DEFAULT_PAD }
       params = {}
       params = args.pop if args.last.is_a? Hash
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      if params.key? :padding
+        value = params.delete(:padding)
+        [:padLeft, :padRight, :padTop, :padBottom].each { |s| params[s] ||= value }
+      end
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(parent, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom])
+      old_initialize(parent, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
     end
   end
 
   class FXColorDialog
     alias old_initialize initialize
-    def initialize(owner, title, *args)
+    def initialize(owner, title, *args, &blk)
       argument_names = %w{opts x y width height}
       default_params = { :opts => 0, :x => 0, :y => 0, :width => 0, :height => 0 }
       params = {}
@@ -385,13 +433,13 @@ module Fox
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(owner, title, params[:opts], params[:x], params[:y], params[:width], params[:height])
+      old_initialize(owner, title, params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
     end
   end
 
   class FXColorItem
     alias old_initialize initialize
-    def initialize(text, clr, *args)
+    def initialize(text, clr, *args, &blk)
       argument_names = %w{data}
       default_params = { :data => nil }
       params = {}
@@ -399,13 +447,13 @@ module Fox
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(text, clr, params[:data])
+      old_initialize(text, clr, params[:data], &blk)
     end
   end
 
   class FXColorList
     alias old_initialize initialize
-    def initialize(p, *args)
+    def initialize(p, *args, &blk)
       argument_names = %w{target selector opts x y width height}
       default_params = { :target => nil, :selector => 0, :opts => LIST_BROWSESELECT, :x => 0, :y => 0, :width => 0, :height => 0 }
       params = {}
@@ -413,27 +461,31 @@ module Fox
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(p, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height])
+      old_initialize(p, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
     end
   end
 
   class FXColorRing
     alias old_initialize initialize
-    def initialize(p, *args)
+    def initialize(p, *args, &blk)
       argument_names = %w{target selector opts x y width height padLeft padRight padTop padBottom}
       default_params = { :target => nil, :selector => 0, :opts => FRAME_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_PAD, :padRight => DEFAULT_PAD, :padTop => DEFAULT_PAD, :padBottom => DEFAULT_PAD }
       params = {}
       params = args.pop if args.last.is_a? Hash
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      if params.key? :padding
+        value = params.delete(:padding)
+        [:padLeft, :padRight, :padTop, :padBottom].each { |s| params[s] ||= value }
+      end
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(p, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom])
+      old_initialize(p, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
     end
   end
 
   class FXColorSelector
     alias old_initialize initialize
-    def initialize(parent, *args)
+    def initialize(parent, *args, &blk)
       argument_names = %w{target selector opts x y width height}
       default_params = { :target => nil, :selector => 0, :opts => 0, :x => 0, :y => 0, :width => 0, :height => 0 }
       params = {}
@@ -441,55 +493,67 @@ module Fox
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(parent, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height])
+      old_initialize(parent, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
     end
   end
 
   class FXColorWell
     alias old_initialize initialize
-    def initialize(parent, *args)
+    def initialize(parent, *args, &blk)
       argument_names = %w{color target selector opts x y width height padLeft padRight padTop padBottom}
       default_params = { :color => 0, :target => nil, :selector => 0, :opts => COLORWELL_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_PAD, :padRight => DEFAULT_PAD, :padTop => DEFAULT_PAD, :padBottom => DEFAULT_PAD }
       params = {}
       params = args.pop if args.last.is_a? Hash
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      if params.key? :padding
+        value = params.delete(:padding)
+        [:padLeft, :padRight, :padTop, :padBottom].each { |s| params[s] ||= value }
+      end
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(parent, params[:color], params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom])
+      old_initialize(parent, params[:color], params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
     end
   end
 
   class FXColorWheel
     alias old_initialize initialize
-    def initialize(p, *args)
+    def initialize(p, *args, &blk)
       argument_names = %w{target selector opts x y width height padLeft padRight padTop padBottom}
       default_params = { :target => nil, :selector => 0, :opts => FRAME_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_PAD, :padRight => DEFAULT_PAD, :padTop => DEFAULT_PAD, :padBottom => DEFAULT_PAD }
       params = {}
       params = args.pop if args.last.is_a? Hash
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      if params.key? :padding
+        value = params.delete(:padding)
+        [:padLeft, :padRight, :padTop, :padBottom].each { |s| params[s] ||= value }
+      end
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(p, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom])
+      old_initialize(p, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
     end
   end
 
   class FXComboBox
     alias old_initialize initialize
-    def initialize(p, cols, *args)
+    def initialize(p, cols, *args, &blk)
       argument_names = %w{target selector opts x y width height padLeft padRight padTop padBottom}
       default_params = { :target => nil, :selector => 0, :opts => COMBOBOX_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_PAD, :padRight => DEFAULT_PAD, :padTop => DEFAULT_PAD, :padBottom => DEFAULT_PAD }
       params = {}
       params = args.pop if args.last.is_a? Hash
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      if params.key? :padding
+        value = params.delete(:padding)
+        [:padLeft, :padRight, :padTop, :padBottom].each { |s| params[s] ||= value }
+      end
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(p, cols, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom])
+      old_initialize(p, cols, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
     end
   end
 
   class FXComposite
     alias old_initialize initialize
-    def initialize(parent, *args)
+    def initialize(parent, *args, &blk)
       argument_names = %w{opts x y width height}
       default_params = { :opts => 0, :x => 0, :y => 0, :width => 0, :height => 0 }
       params = {}
@@ -497,13 +561,13 @@ module Fox
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(parent, params[:opts], params[:x], params[:y], params[:width], params[:height])
+      old_initialize(parent, params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
     end
   end
 
   class FXDataTarget
     alias old_initialize initialize
-    def initialize(*args)
+    def initialize(*args, &blk)
       argument_names = %w{value target selector}
       default_params = { :value => nil, :target => nil, :selector => 0 }
       params = {}
@@ -511,27 +575,13 @@ module Fox
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(params[:value], params[:target], params[:selector])
-    end
-  end
-
-  class FXDCWindow
-    alias old_initialize initialize
-    def initialize(drawable, *args)
-      argument_names = %w{event}
-      default_params = { :event => nil }
-      params = {}
-      params = args.pop if args.last.is_a? Hash
-      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
-      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
-      params = default_params.merge(params)
-      old_initialize(drawable, params[:event])
+      old_initialize(params[:value], params[:target], params[:selector], &blk)
     end
   end
 
   class FXDelegator
     alias old_initialize initialize
-    def initialize(*args)
+    def initialize(*args, &blk)
       argument_names = %w{delegate}
       default_params = { :delegate => nil }
       params = {}
@@ -539,55 +589,67 @@ module Fox
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(params[:delegate])
+      old_initialize(params[:delegate], &blk)
     end
   end
 
   class FXDial
     alias old_initialize initialize
-    def initialize(p, *args)
+    def initialize(p, *args, &blk)
       argument_names = %w{target selector opts x y width height padLeft padRight padTop padBottom}
       default_params = { :target => nil, :selector => 0, :opts => DIAL_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_PAD, :padRight => DEFAULT_PAD, :padTop => DEFAULT_PAD, :padBottom => DEFAULT_PAD }
       params = {}
       params = args.pop if args.last.is_a? Hash
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      if params.key? :padding
+        value = params.delete(:padding)
+        [:padLeft, :padRight, :padTop, :padBottom].each { |s| params[s] ||= value }
+      end
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(p, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom])
+      old_initialize(p, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
     end
   end
 
   class FXDialogBox
     alias old_initialize initialize
-    def initialize(owner, title, *args)
+    def initialize(owner, title, *args, &blk)
       argument_names = %w{opts x y width height padLeft padRight padTop padBottom hSpacing vSpacing}
       default_params = { :opts => DECOR_TITLE|DECOR_BORDER, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => 10, :padRight => 10, :padTop => 10, :padBottom => 10, :hSpacing => 4, :vSpacing => 4 }
       params = {}
       params = args.pop if args.last.is_a? Hash
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      if params.key? :padding
+        value = params.delete(:padding)
+        [:padLeft, :padRight, :padTop, :padBottom].each { |s| params[s] ||= value }
+      end
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(owner, title, params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], params[:hSpacing], params[:vSpacing])
+      old_initialize(owner, title, params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], params[:hSpacing], params[:vSpacing], &blk)
     end
   end
 
   class FXDirBox
     alias old_initialize initialize
-    def initialize(p, *args)
+    def initialize(p, *args, &blk)
       argument_names = %w{target selector opts x y width height padLeft padRight padTop padBottom}
       default_params = { :target => nil, :selector => 0, :opts => FRAME_SUNKEN|FRAME_THICK|TREELISTBOX_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_PAD, :padRight => DEFAULT_PAD, :padTop => DEFAULT_PAD, :padBottom => DEFAULT_PAD }
       params = {}
       params = args.pop if args.last.is_a? Hash
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      if params.key? :padding
+        value = params.delete(:padding)
+        [:padLeft, :padRight, :padTop, :padBottom].each { |s| params[s] ||= value }
+      end
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(p, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom])
+      old_initialize(p, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
     end
   end
 
   class FXDirDialog
     alias old_initialize initialize
-    def initialize(owner, name, *args)
+    def initialize(owner, name, *args, &blk)
       argument_names = %w{opts x y width height}
       default_params = { :opts => 0, :x => 0, :y => 0, :width => 500, :height => 300 }
       params = {}
@@ -595,13 +657,13 @@ module Fox
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(owner, name, params[:opts], params[:x], params[:y], params[:width], params[:height])
+      old_initialize(owner, name, params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
     end
   end
 
   class FXDirItem
     alias old_initialize initialize
-    def initialize(text, *args)
+    def initialize(text, *args, &blk)
       argument_names = %w{oi ci data}
       default_params = { :oi => nil, :ci => nil, :data => nil }
       params = {}
@@ -609,13 +671,13 @@ module Fox
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(text, params[:oi], params[:ci], params[:data])
+      old_initialize(text, params[:oi], params[:ci], params[:data], &blk)
     end
   end
 
   class FXDirList
     alias old_initialize initialize
-    def initialize(p, *args)
+    def initialize(p, *args, &blk)
       argument_names = %w{target selector opts x y width height}
       default_params = { :target => nil, :selector => 0, :opts => 0, :x => 0, :y => 0, :width => 0, :height => 0 }
       params = {}
@@ -623,13 +685,13 @@ module Fox
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(p, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height])
+      old_initialize(p, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
     end
   end
 
   class FXDirSelector
     alias old_initialize initialize
-    def initialize(p, *args)
+    def initialize(p, *args, &blk)
       argument_names = %w{target selector opts x y width height}
       default_params = { :target => nil, :selector => 0, :opts => 0, :x => 0, :y => 0, :width => 0, :height => 0 }
       params = {}
@@ -637,55 +699,67 @@ module Fox
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(p, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height])
+      old_initialize(p, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
     end
   end
 
   class FXDockSite
     alias old_initialize initialize
-    def initialize(p, *args)
+    def initialize(p, *args, &blk)
       argument_names = %w{opts x y width height padLeft padRight padTop padBottom hSpacing vSpacing}
       default_params = { :opts => 0, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => 0, :padRight => 0, :padTop => 0, :padBottom => 0, :hSpacing => 0, :vSpacing => 0 }
       params = {}
       params = args.pop if args.last.is_a? Hash
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      if params.key? :padding
+        value = params.delete(:padding)
+        [:padLeft, :padRight, :padTop, :padBottom].each { |s| params[s] ||= value }
+      end
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(p, params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], params[:hSpacing], params[:vSpacing])
+      old_initialize(p, params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], params[:hSpacing], params[:vSpacing], &blk)
     end
   end
 
   class FXDockTitle
     alias old_initialize initialize
-    def initialize(p, text, *args)
+    def initialize(p, text, *args, &blk)
       argument_names = %w{target selector opts x y width height padLeft padRight padTop padBottom}
       default_params = { :target => nil, :selector => 0, :opts => FRAME_NORMAL|JUSTIFY_CENTER_X|JUSTIFY_CENTER_Y, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => 0, :padRight => 0, :padTop => 0, :padBottom => 0 }
       params = {}
       params = args.pop if args.last.is_a? Hash
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      if params.key? :padding
+        value = params.delete(:padding)
+        [:padLeft, :padRight, :padTop, :padBottom].each { |s| params[s] ||= value }
+      end
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(p, text, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom])
+      old_initialize(p, text, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
     end
   end
 
   class FXDriveBox
     alias old_initialize initialize
-    def initialize(p, *args)
+    def initialize(p, *args, &blk)
       argument_names = %w{target selector opts x y width height padLeft padRight padTop padBottom}
       default_params = { :target => nil, :selector => 0, :opts => FRAME_SUNKEN|FRAME_THICK|LISTBOX_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_PAD, :padRight => DEFAULT_PAD, :padTop => DEFAULT_PAD, :padBottom => DEFAULT_PAD }
       params = {}
       params = args.pop if args.last.is_a? Hash
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      if params.key? :padding
+        value = params.delete(:padding)
+        [:padLeft, :padRight, :padTop, :padBottom].each { |s| params[s] ||= value }
+      end
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(p, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom])
+      old_initialize(p, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
     end
   end
 
   class FXFileDialog
     alias old_initialize initialize
-    def initialize(owner, name, *args)
+    def initialize(owner, name, *args, &blk)
       argument_names = %w{opts x y width height}
       default_params = { :opts => 0, :x => 0, :y => 0, :width => 500, :height => 300 }
       params = {}
@@ -693,13 +767,13 @@ module Fox
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(owner, name, params[:opts], params[:x], params[:y], params[:width], params[:height])
+      old_initialize(owner, name, params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
     end
   end
 
   class FXFileDict
     alias old_initialize initialize
-    def initialize(app, *args)
+    def initialize(app, *args, &blk)
       argument_names = %w{db}
       default_params = { :db => nil }
       params = {}
@@ -707,13 +781,13 @@ module Fox
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(app, params[:db])
+      old_initialize(app, params[:db], &blk)
     end
   end
 
   class FXFileItem
     alias old_initialize initialize
-    def initialize(text, *args)
+    def initialize(text, *args, &blk)
       argument_names = %w{bi mi ptr}
       default_params = { :bi => nil, :mi => nil, :ptr => nil }
       params = {}
@@ -721,13 +795,13 @@ module Fox
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(text, params[:bi], params[:mi], params[:ptr])
+      old_initialize(text, params[:bi], params[:mi], params[:ptr], &blk)
     end
   end
 
   class FXFileList
     alias old_initialize initialize
-    def initialize(p, *args)
+    def initialize(p, *args, &blk)
       argument_names = %w{target selector opts x y width height}
       default_params = { :target => nil, :selector => 0, :opts => 0, :x => 0, :y => 0, :width => 0, :height => 0 }
       params = {}
@@ -735,13 +809,13 @@ module Fox
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(p, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height])
+      old_initialize(p, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
     end
   end
 
   class FXFileSelector
     alias old_initialize initialize
-    def initialize(p, *args)
+    def initialize(p, *args, &blk)
       argument_names = %w{target selector opts x y width height}
       default_params = { :target => nil, :selector => 0, :opts => 0, :x => 0, :y => 0, :width => 0, :height => 0 }
       params = {}
@@ -749,13 +823,13 @@ module Fox
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(p, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height])
+      old_initialize(p, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
     end
   end
 
   class FXFileStream
     alias old_initialize initialize
-    def initialize(*args)
+    def initialize(*args, &blk)
       argument_names = %w{cont}
       default_params = { :cont => nil }
       params = {}
@@ -763,13 +837,13 @@ module Fox
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(params[:cont])
+      old_initialize(params[:cont], &blk)
     end
   end
 
   class FXFoldingItem
     alias old_initialize initialize
-    def initialize(text, *args)
+    def initialize(text, *args, &blk)
       argument_names = %w{openIcon closedIcon data}
       default_params = { :openIcon => nil, :closedIcon => nil, :data => nil }
       params = {}
@@ -777,13 +851,13 @@ module Fox
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(text, params[:openIcon], params[:closedIcon], params[:data])
+      old_initialize(text, params[:openIcon], params[:closedIcon], params[:data], &blk)
     end
   end
 
   class FXFoldingList
     alias old_initialize initialize
-    def initialize(p, *args)
+    def initialize(p, *args, &blk)
       argument_names = %w{target selector opts x y width height}
       default_params = { :target => nil, :selector => 0, :opts => TREELIST_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0 }
       params = {}
@@ -791,13 +865,13 @@ module Fox
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(p, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height])
+      old_initialize(p, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
     end
   end
 
   class FXFontDialog
     alias old_initialize initialize
-    def initialize(owner, name, *args)
+    def initialize(owner, name, *args, &blk)
       argument_names = %w{opts x y width height}
       default_params = { :opts => 0, :x => 0, :y => 0, :width => 600, :height => 380 }
       params = {}
@@ -805,13 +879,13 @@ module Fox
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(owner, name, params[:opts], params[:x], params[:y], params[:width], params[:height])
+      old_initialize(owner, name, params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
     end
   end
 
   class FXFontSelector
     alias old_initialize initialize
-    def initialize(p, *args)
+    def initialize(p, *args, &blk)
       argument_names = %w{target selector opts x y width height}
       default_params = { :target => nil, :selector => 0, :opts => 0, :x => 0, :y => 0, :width => 0, :height => 0 }
       params = {}
@@ -819,27 +893,31 @@ module Fox
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(p, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height])
+      old_initialize(p, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
     end
   end
 
   class FXFrame
     alias old_initialize initialize
-    def initialize(parent, *args)
+    def initialize(parent, *args, &blk)
       argument_names = %w{opts x y width height padLeft padRight padTop padBottom}
       default_params = { :opts => FRAME_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_PAD, :padRight => DEFAULT_PAD, :padTop => DEFAULT_PAD, :padBottom => DEFAULT_PAD }
       params = {}
       params = args.pop if args.last.is_a? Hash
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      if params.key? :padding
+        value = params.delete(:padding)
+        [:padLeft, :padRight, :padTop, :padBottom].each { |s| params[s] ||= value }
+      end
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(parent, params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom])
+      old_initialize(parent, params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
     end
   end
 
   class FXGIFCursor
     alias old_initialize initialize
-    def initialize(a, pix, *args)
+    def initialize(a, pix, *args, &blk)
       argument_names = %w{hx hy}
       default_params = { :hx => -1, :hy => -1 }
       params = {}
@@ -847,13 +925,13 @@ module Fox
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(a, pix, params[:hx], params[:hy])
+      old_initialize(a, pix, params[:hx], params[:hy], &blk)
     end
   end
 
   class FXGIFIcon
     alias old_initialize initialize
-    def initialize(a, *args)
+    def initialize(a, *args, &blk)
       argument_names = %w{pix clr opts width height}
       default_params = { :pix => nil, :clr => 0, :opts => 0, :width => 1, :height => 1 }
       params = {}
@@ -861,13 +939,13 @@ module Fox
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(a, params[:pix], params[:clr], params[:opts], params[:width], params[:height])
+      old_initialize(a, params[:pix], params[:clr], params[:opts], params[:width], params[:height], &blk)
     end
   end
 
   class FXGIFImage
     alias old_initialize initialize
-    def initialize(a, *args)
+    def initialize(a, *args, &blk)
       argument_names = %w{pix opts width height}
       default_params = { :pix => nil, :opts => 0, :width => 1, :height => 1 }
       params = {}
@@ -875,13 +953,13 @@ module Fox
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(a, params[:pix], params[:opts], params[:width], params[:height])
+      old_initialize(a, params[:pix], params[:opts], params[:width], params[:height], &blk)
     end
   end
 
   class FXGLContext
     alias old_initialize initialize
-    def initialize(app, visual, *args)
+    def initialize(app, visual, *args, &blk)
       argument_names = %w{other}
       default_params = { :other => nil }
       params = {}
@@ -889,55 +967,49 @@ module Fox
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(app, visual, params[:other])
-    end
-  end
-
-  class FXGLShape
-    alias old_initialize initialize
-    def initialize(x, y, z, opts, *args)
-      argument_names = %w{front back}
-      default_params = { :front => nil, :back => nil }
-      params = {}
-      params = args.pop if args.last.is_a? Hash
-      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
-      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
-      params = default_params.merge(params)
-      old_initialize(x, y, z, opts, params[:front], params[:back])
+      old_initialize(app, visual, params[:other], &blk)
     end
   end
 
   class FXGradientBar
     alias old_initialize initialize
-    def initialize(p, *args)
+    def initialize(p, *args, &blk)
       argument_names = %w{target selector opts x y width height padLeft padRight padTop padBottom}
       default_params = { :target => nil, :selector => 0, :opts => FRAME_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_PAD, :padRight => DEFAULT_PAD, :padTop => DEFAULT_PAD, :padBottom => DEFAULT_PAD }
       params = {}
       params = args.pop if args.last.is_a? Hash
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      if params.key? :padding
+        value = params.delete(:padding)
+        [:padLeft, :padRight, :padTop, :padBottom].each { |s| params[s] ||= value }
+      end
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(p, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom])
+      old_initialize(p, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
     end
   end
 
   class FXGroupBox
     alias old_initialize initialize
-    def initialize(parent, text, *args)
+    def initialize(parent, text, *args, &blk)
       argument_names = %w{opts x y width height padLeft padRight padTop padBottom hSpacing vSpacing}
       default_params = { :opts => GROUPBOX_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_SPACING, :padRight => DEFAULT_SPACING, :padTop => DEFAULT_SPACING, :padBottom => DEFAULT_SPACING, :hSpacing => DEFAULT_SPACING, :vSpacing => DEFAULT_SPACING }
       params = {}
       params = args.pop if args.last.is_a? Hash
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      if params.key? :padding
+        value = params.delete(:padding)
+        [:padLeft, :padRight, :padTop, :padBottom].each { |s| params[s] ||= value }
+      end
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(parent, text, params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], params[:hSpacing], params[:vSpacing])
+      old_initialize(parent, text, params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], params[:hSpacing], params[:vSpacing], &blk)
     end
   end
 
   class FXHeaderItem
     alias old_initialize initialize
-    def initialize(text, *args)
+    def initialize(text, *args, &blk)
       argument_names = %w{ic s ptr}
       default_params = { :ic => nil, :s => 0, :ptr => nil }
       params = {}
@@ -945,41 +1017,49 @@ module Fox
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(text, params[:ic], params[:s], params[:ptr])
+      old_initialize(text, params[:ic], params[:s], params[:ptr], &blk)
     end
   end
 
   class FXHeader
     alias old_initialize initialize
-    def initialize(p, *args)
+    def initialize(p, *args, &blk)
       argument_names = %w{target selector opts x y width height padLeft padRight padTop padBottom}
       default_params = { :target => nil, :selector => 0, :opts => HEADER_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_PAD, :padRight => DEFAULT_PAD, :padTop => DEFAULT_PAD, :padBottom => DEFAULT_PAD }
       params = {}
       params = args.pop if args.last.is_a? Hash
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      if params.key? :padding
+        value = params.delete(:padding)
+        [:padLeft, :padRight, :padTop, :padBottom].each { |s| params[s] ||= value }
+      end
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(p, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom])
+      old_initialize(p, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
     end
   end
 
   class FXHorizontalFrame
     alias old_initialize initialize
-    def initialize(p, *args)
+    def initialize(p, *args, &blk)
       argument_names = %w{opts x y width height padLeft padRight padTop padBottom hSpacing vSpacing}
       default_params = { :opts => 0, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_SPACING, :padRight => DEFAULT_SPACING, :padTop => DEFAULT_SPACING, :padBottom => DEFAULT_SPACING, :hSpacing => DEFAULT_SPACING, :vSpacing => DEFAULT_SPACING }
       params = {}
       params = args.pop if args.last.is_a? Hash
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      if params.key? :padding
+        value = params.delete(:padding)
+        [:padLeft, :padRight, :padTop, :padBottom].each { |s| params[s] ||= value }
+      end
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(p, params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], params[:hSpacing], params[:vSpacing])
+      old_initialize(p, params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], params[:hSpacing], params[:vSpacing], &blk)
     end
   end
 
   class FXICOIcon
     alias old_initialize initialize
-    def initialize(a, *args)
+    def initialize(a, *args, &blk)
       argument_names = %w{pix clr opts width height}
       default_params = { :pix => nil, :clr => 0, :opts => 0, :width => 1, :height => 1 }
       params = {}
@@ -987,13 +1067,13 @@ module Fox
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(a, params[:pix], params[:clr], params[:opts], params[:width], params[:height])
+      old_initialize(a, params[:pix], params[:clr], params[:opts], params[:width], params[:height], &blk)
     end
   end
 
   class FXICOImage
     alias old_initialize initialize
-    def initialize(a, *args)
+    def initialize(a, *args, &blk)
       argument_names = %w{pix opts width height}
       default_params = { :pix => nil, :opts => 0, :width => 1, :height => 1 }
       params = {}
@@ -1001,13 +1081,13 @@ module Fox
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(a, params[:pix], params[:opts], params[:width], params[:height])
+      old_initialize(a, params[:pix], params[:opts], params[:width], params[:height], &blk)
     end
   end
 
   class FXIcon
     alias old_initialize initialize
-    def initialize(app, *args)
+    def initialize(app, *args, &blk)
       argument_names = %w{pix clr opts width height}
       default_params = { :pix => nil, :clr => 0, :opts => 0, :width => 1, :height => 1 }
       params = {}
@@ -1015,13 +1095,13 @@ module Fox
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(app, params[:pix], params[:clr], params[:opts], params[:width], params[:height])
+      old_initialize(app, params[:pix], params[:clr], params[:opts], params[:width], params[:height], &blk)
     end
   end
 
   class FXIconDict
     alias old_initialize initialize
-    def initialize(app, *args)
+    def initialize(app, *args, &blk)
       argument_names = %w{path}
       default_params = { :path => defaultIconPath }
       params = {}
@@ -1029,13 +1109,13 @@ module Fox
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(app, params[:path])
+      old_initialize(app, params[:path], &blk)
     end
   end
 
   class FXIconItem
     alias old_initialize initialize
-    def initialize(text, *args)
+    def initialize(text, *args, &blk)
       argument_names = %w{bigIcon miniIcon data}
       default_params = { :bigIcon => nil, :miniIcon => nil, :data => nil }
       params = {}
@@ -1043,13 +1123,13 @@ module Fox
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(text, params[:bigIcon], params[:miniIcon], params[:data])
+      old_initialize(text, params[:bigIcon], params[:miniIcon], params[:data], &blk)
     end
   end
 
   class FXIconList
     alias old_initialize initialize
-    def initialize(p, *args)
+    def initialize(p, *args, &blk)
       argument_names = %w{target selector opts x y width height}
       default_params = { :target => nil, :selector => 0, :opts => ICONLIST_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0 }
       params = {}
@@ -1057,13 +1137,13 @@ module Fox
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(p, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height])
+      old_initialize(p, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
     end
   end
 
   class FXImage
     alias old_initialize initialize
-    def initialize(a, *args)
+    def initialize(a, *args, &blk)
       argument_names = %w{pixels opts width height}
       default_params = { :pixels => nil, :opts => 0, :width => 1, :height => 1 }
       params = {}
@@ -1071,27 +1151,31 @@ module Fox
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(a, params[:pixels], params[:opts], params[:width], params[:height])
+      old_initialize(a, params[:pixels], params[:opts], params[:width], params[:height], &blk)
     end
   end
 
   class FXImageFrame
     alias old_initialize initialize
-    def initialize(p, img, *args)
+    def initialize(p, img, *args, &blk)
       argument_names = %w{opts x y width height padLeft padRight padTop padBottom}
       default_params = { :opts => FRAME_SUNKEN|FRAME_THICK, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => 0, :padRight => 0, :padTop => 0, :padBottom => 0 }
       params = {}
       params = args.pop if args.last.is_a? Hash
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      if params.key? :padding
+        value = params.delete(:padding)
+        [:padLeft, :padRight, :padTop, :padBottom].each { |s| params[s] ||= value }
+      end
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(p, img, params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom])
+      old_initialize(p, img, params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
     end
   end
 
   class FXImageView
     alias old_initialize initialize
-    def initialize(p, *args)
+    def initialize(p, *args, &blk)
       argument_names = %w{img target selector opts x y width height}
       default_params = { :img => nil, :target => nil, :selector => 0, :opts => 0, :x => 0, :y => 0, :width => 0, :height => 0 }
       params = {}
@@ -1099,13 +1183,13 @@ module Fox
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(p, params[:img], params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height])
+      old_initialize(p, params[:img], params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
     end
   end
 
   class FXInputDialog
     alias old_initialize initialize
-    def initialize(owner, caption, label, *args)
+    def initialize(owner, caption, label, *args, &blk)
       argument_names = %w{icon opts x y width height}
       default_params = { :icon => nil, :opts => INPUTDIALOG_STRING, :x => 0, :y => 0, :width => 0, :height => 0 }
       params = {}
@@ -1113,13 +1197,13 @@ module Fox
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(owner, caption, label, params[:icon], params[:opts], params[:x], params[:y], params[:width], params[:height])
+      old_initialize(owner, caption, label, params[:icon], params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
     end
   end
 
   class FXJPGIcon
     alias old_initialize initialize
-    def initialize(a, *args)
+    def initialize(a, *args, &blk)
       argument_names = %w{pix clr opts width height}
       default_params = { :pix => nil, :clr => 0, :opts => 0, :width => 1, :height => 1 }
       params = {}
@@ -1127,13 +1211,13 @@ module Fox
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(a, params[:pix], params[:clr], params[:opts], params[:width], params[:height])
+      old_initialize(a, params[:pix], params[:clr], params[:opts], params[:width], params[:height], &blk)
     end
   end
 
   class FXJPGImage
     alias old_initialize initialize
-    def initialize(a, *args)
+    def initialize(a, *args, &blk)
       argument_names = %w{pix opts width height}
       default_params = { :pix => nil, :opts => 0, :width => 1, :height => 1 }
       params = {}
@@ -1141,41 +1225,49 @@ module Fox
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(a, params[:pix], params[:opts], params[:width], params[:height])
+      old_initialize(a, params[:pix], params[:opts], params[:width], params[:height], &blk)
     end
   end
 
   class FXKnob
     alias old_initialize initialize
-    def initialize(p, *args)
+    def initialize(p, *args, &blk)
       argument_names = %w{target selector opts x y width height padLeft padRight padTop padBottom}
       default_params = { :target => nil, :selector => 0, :opts => KNOB_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_PAD, :padRight => DEFAULT_PAD, :padTop => DEFAULT_PAD, :padBottom => DEFAULT_PAD }
       params = {}
       params = args.pop if args.last.is_a? Hash
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      if params.key? :padding
+        value = params.delete(:padding)
+        [:padLeft, :padRight, :padTop, :padBottom].each { |s| params[s] ||= value }
+      end
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(p, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom])
+      old_initialize(p, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
     end
   end
 
   class FXLabel
     alias old_initialize initialize
-    def initialize(parent, text, *args)
+    def initialize(parent, text, *args, &blk)
       argument_names = %w{icon opts x y width height padLeft padRight padTop padBottom}
       default_params = { :icon => nil, :opts => LABEL_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_PAD, :padRight => DEFAULT_PAD, :padTop => DEFAULT_PAD, :padBottom => DEFAULT_PAD }
       params = {}
       params = args.pop if args.last.is_a? Hash
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      if params.key? :padding
+        value = params.delete(:padding)
+        [:padLeft, :padRight, :padTop, :padBottom].each { |s| params[s] ||= value }
+      end
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(parent, text, params[:icon], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom])
+      old_initialize(parent, text, params[:icon], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
     end
   end
 
   class FXListItem
     alias old_initialize initialize
-    def initialize(text, *args)
+    def initialize(text, *args, &blk)
       argument_names = %w{icon data}
       default_params = { :icon => nil, :data => nil }
       params = {}
@@ -1183,13 +1275,13 @@ module Fox
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(text, params[:icon], params[:data])
+      old_initialize(text, params[:icon], params[:data], &blk)
     end
   end
 
   class FXList
     alias old_initialize initialize
-    def initialize(p, *args)
+    def initialize(p, *args, &blk)
       argument_names = %w{target selector opts x y width height}
       default_params = { :target => nil, :selector => 0, :opts => LIST_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0 }
       params = {}
@@ -1197,55 +1289,67 @@ module Fox
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(p, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height])
+      old_initialize(p, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
     end
   end
 
   class FXListBox
     alias old_initialize initialize
-    def initialize(p, *args)
+    def initialize(p, *args, &blk)
       argument_names = %w{target selector opts x y width height padLeft padRight padTop padBottom}
       default_params = { :target => nil, :selector => 0, :opts => FRAME_SUNKEN|FRAME_THICK|LISTBOX_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_PAD, :padRight => DEFAULT_PAD, :padTop => DEFAULT_PAD, :padBottom => DEFAULT_PAD }
       params = {}
       params = args.pop if args.last.is_a? Hash
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      if params.key? :padding
+        value = params.delete(:padding)
+        [:padLeft, :padRight, :padTop, :padBottom].each { |s| params[s] ||= value }
+      end
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(p, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom])
+      old_initialize(p, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
     end
   end
 
   class FXMainWindow
     alias old_initialize initialize
-    def initialize(app, title, *args)
+    def initialize(app, title, *args, &blk)
       argument_names = %w{icon miniIcon opts x y width height padLeft padRight padTop padBottom hSpacing vSpacing}
       default_params = { :icon => nil, :miniIcon => nil, :opts => DECOR_ALL, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => 0, :padRight => 0, :padTop => 0, :padBottom => 0, :hSpacing => 4, :vSpacing => 4 }
       params = {}
       params = args.pop if args.last.is_a? Hash
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      if params.key? :padding
+        value = params.delete(:padding)
+        [:padLeft, :padRight, :padTop, :padBottom].each { |s| params[s] ||= value }
+      end
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(app, title, params[:icon], params[:miniIcon], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], params[:hSpacing], params[:vSpacing])
+      old_initialize(app, title, params[:icon], params[:miniIcon], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], params[:hSpacing], params[:vSpacing], &blk)
     end
   end
 
   class FXMatrix
     alias old_initialize initialize
-    def initialize(parent, *args)
+    def initialize(parent, *args, &blk)
       argument_names = %w{n opts x y width height padLeft padRight padTop padBottom hSpacing vSpacing}
       default_params = { :n => 1, :opts => MATRIX_BY_ROWS, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_SPACING, :padRight => DEFAULT_SPACING, :padTop => DEFAULT_SPACING, :padBottom => DEFAULT_SPACING, :hSpacing => DEFAULT_SPACING, :vSpacing => DEFAULT_SPACING }
       params = {}
       params = args.pop if args.last.is_a? Hash
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      if params.key? :padding
+        value = params.delete(:padding)
+        [:padLeft, :padRight, :padTop, :padBottom].each { |s| params[s] ||= value }
+      end
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(parent, params[:n], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], params[:hSpacing], params[:vSpacing])
+      old_initialize(parent, params[:n], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], params[:hSpacing], params[:vSpacing], &blk)
     end
   end
 
   class FXMDIDeleteButton
     alias old_initialize initialize
-    def initialize(p, *args)
+    def initialize(p, *args, &blk)
       argument_names = %w{target selector opts x y width height}
       default_params = { :target => nil, :selector => 0, :opts => FRAME_RAISED, :x => 0, :y => 0, :width => 0, :height => 0 }
       params = {}
@@ -1253,13 +1357,13 @@ module Fox
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(p, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height])
+      old_initialize(p, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
     end
   end
 
   class FXMDIRestoreButton
     alias old_initialize initialize
-    def initialize(p, *args)
+    def initialize(p, *args, &blk)
       argument_names = %w{target selector opts x y width height}
       default_params = { :target => nil, :selector => 0, :opts => FRAME_RAISED, :x => 0, :y => 0, :width => 0, :height => 0 }
       params = {}
@@ -1267,13 +1371,13 @@ module Fox
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(p, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height])
+      old_initialize(p, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
     end
   end
 
   class FXMDIMaximizeButton
     alias old_initialize initialize
-    def initialize(p, *args)
+    def initialize(p, *args, &blk)
       argument_names = %w{target selector opts x y width height}
       default_params = { :target => nil, :selector => 0, :opts => FRAME_RAISED, :x => 0, :y => 0, :width => 0, :height => 0 }
       params = {}
@@ -1281,13 +1385,13 @@ module Fox
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(p, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height])
+      old_initialize(p, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
     end
   end
 
   class FXMDIMinimizeButton
     alias old_initialize initialize
-    def initialize(p, *args)
+    def initialize(p, *args, &blk)
       argument_names = %w{target selector opts x y width height}
       default_params = { :target => nil, :selector => 0, :opts => FRAME_RAISED, :x => 0, :y => 0, :width => 0, :height => 0 }
       params = {}
@@ -1295,13 +1399,13 @@ module Fox
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(p, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height])
+      old_initialize(p, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
     end
   end
 
   class FXMDIWindowButton
     alias old_initialize initialize
-    def initialize(p, pup, *args)
+    def initialize(p, pup, *args, &blk)
       argument_names = %w{target selector opts x y width height}
       default_params = { :target => nil, :selector => 0, :opts => 0, :x => 0, :y => 0, :width => 0, :height => 0 }
       params = {}
@@ -1309,13 +1413,13 @@ module Fox
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(p, pup, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height])
+      old_initialize(p, pup, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
     end
   end
 
   class FXMDIMenu
     alias old_initialize initialize
-    def initialize(owner, *args)
+    def initialize(owner, *args, &blk)
       argument_names = %w{target}
       default_params = { :target => nil }
       params = {}
@@ -1323,13 +1427,13 @@ module Fox
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(owner, params[:target])
+      old_initialize(owner, params[:target], &blk)
     end
   end
 
   class FXMDIChild
     alias old_initialize initialize
-    def initialize(p, name, *args)
+    def initialize(p, name, *args, &blk)
       argument_names = %w{ic pup opts x y width height}
       default_params = { :ic => nil, :pup => nil, :opts => 0, :x => 0, :y => 0, :width => 0, :height => 0 }
       params = {}
@@ -1337,13 +1441,13 @@ module Fox
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(p, name, params[:ic], params[:pup], params[:opts], params[:x], params[:y], params[:width], params[:height])
+      old_initialize(p, name, params[:ic], params[:pup], params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
     end
   end
 
   class FXMDIClient
     alias old_initialize initialize
-    def initialize(p, *args)
+    def initialize(p, *args, &blk)
       argument_names = %w{opts x y width height}
       default_params = { :opts => 0, :x => 0, :y => 0, :width => 0, :height => 0 }
       params = {}
@@ -1351,13 +1455,13 @@ module Fox
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(p, params[:opts], params[:x], params[:y], params[:width], params[:height])
+      old_initialize(p, params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
     end
   end
 
   class FXMemoryStream
     alias old_initialize initialize
-    def initialize(*args)
+    def initialize(*args, &blk)
       argument_names = %w{cont}
       default_params = { :cont => nil }
       params = {}
@@ -1365,27 +1469,31 @@ module Fox
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(params[:cont])
+      old_initialize(params[:cont], &blk)
     end
   end
 
   class FXMenuButton
     alias old_initialize initialize
-    def initialize(parent, text, *args)
+    def initialize(parent, text, *args, &blk)
       argument_names = %w{icon popupMenu opts x y width height padLeft padRight padTop padBottom}
       default_params = { :icon => nil, :popupMenu => nil, :opts => JUSTIFY_NORMAL|ICON_BEFORE_TEXT|MENUBUTTON_DOWN, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_SPACING, :padRight => DEFAULT_SPACING, :padTop => DEFAULT_SPACING, :padBottom => DEFAULT_SPACING }
       params = {}
       params = args.pop if args.last.is_a? Hash
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      if params.key? :padding
+        value = params.delete(:padding)
+        [:padLeft, :padRight, :padTop, :padBottom].each { |s| params[s] ||= value }
+      end
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(parent, text, params[:icon], params[:popupMenu], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom])
+      old_initialize(parent, text, params[:icon], params[:popupMenu], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
     end
   end
 
   class FXMenuCaption
     alias old_initialize initialize
-    def initialize(parent, text, *args)
+    def initialize(parent, text, *args, &blk)
       argument_names = %w{icon opts}
       default_params = { :icon => nil, :opts => 0 }
       params = {}
@@ -1393,13 +1501,13 @@ module Fox
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(parent, text, params[:icon], params[:opts])
+      old_initialize(parent, text, params[:icon], params[:opts], &blk)
     end
   end
 
   class FXMenuCascade
     alias old_initialize initialize
-    def initialize(parent, text, *args)
+    def initialize(parent, text, *args, &blk)
       argument_names = %w{icon popupMenu opts}
       default_params = { :icon => nil, :popupMenu => nil, :opts => 0 }
       params = {}
@@ -1407,13 +1515,13 @@ module Fox
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(parent, text, params[:icon], params[:popupMenu], params[:opts])
+      old_initialize(parent, text, params[:icon], params[:popupMenu], params[:opts], &blk)
     end
   end
 
   class FXMenuCheck
     alias old_initialize initialize
-    def initialize(p, text, *args)
+    def initialize(p, text, *args, &blk)
       argument_names = %w{target selector opts}
       default_params = { :target => nil, :selector => 0, :opts => 0 }
       params = {}
@@ -1421,13 +1529,13 @@ module Fox
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(p, text, params[:target], params[:selector], params[:opts])
+      old_initialize(p, text, params[:target], params[:selector], params[:opts], &blk)
     end
   end
 
   class FXMenuCommand
     alias old_initialize initialize
-    def initialize(p, text, *args)
+    def initialize(p, text, *args, &blk)
       argument_names = %w{ic target selector opts}
       default_params = { :ic => nil, :target => nil, :selector => 0, :opts => 0 }
       params = {}
@@ -1435,13 +1543,13 @@ module Fox
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(p, text, params[:ic], params[:target], params[:selector], params[:opts])
+      old_initialize(p, text, params[:ic], params[:target], params[:selector], params[:opts], &blk)
     end
   end
 
   class FXMenuPane
     alias old_initialize initialize
-    def initialize(owner, *args)
+    def initialize(owner, *args, &blk)
       argument_names = %w{opts}
       default_params = { :opts => 0 }
       params = {}
@@ -1449,13 +1557,13 @@ module Fox
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(owner, params[:opts])
+      old_initialize(owner, params[:opts], &blk)
     end
   end
 
   class FXMenuRadio
     alias old_initialize initialize
-    def initialize(p, text, *args)
+    def initialize(p, text, *args, &blk)
       argument_names = %w{target selector opts}
       default_params = { :target => nil, :selector => 0, :opts => 0 }
       params = {}
@@ -1463,13 +1571,13 @@ module Fox
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(p, text, params[:target], params[:selector], params[:opts])
+      old_initialize(p, text, params[:target], params[:selector], params[:opts], &blk)
     end
   end
 
   class FXMenuSeparator
     alias old_initialize initialize
-    def initialize(parent, *args)
+    def initialize(parent, *args, &blk)
       argument_names = %w{opts}
       default_params = { :opts => 0 }
       params = {}
@@ -1477,13 +1585,13 @@ module Fox
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(parent, params[:opts])
+      old_initialize(parent, params[:opts], &blk)
     end
   end
 
   class FXMenuTitle
     alias old_initialize initialize
-    def initialize(parent, text, *args)
+    def initialize(parent, text, *args, &blk)
       argument_names = %w{icon popupMenu opts}
       default_params = { :icon => nil, :popupMenu => nil, :opts => 0 }
       params = {}
@@ -1491,13 +1599,13 @@ module Fox
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(parent, text, params[:icon], params[:popupMenu], params[:opts])
+      old_initialize(parent, text, params[:icon], params[:popupMenu], params[:opts], &blk)
     end
   end
 
   class FXMessageBox
     alias old_initialize initialize
-    def initialize(owner, caption, text, *args)
+    def initialize(owner, caption, text, *args, &blk)
       argument_names = %w{ic opts x y}
       default_params = { :ic => nil, :opts => 0, :x => 0, :y => 0 }
       params = {}
@@ -1505,41 +1613,49 @@ module Fox
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(owner, caption, text, params[:ic], params[:opts], params[:x], params[:y])
+      old_initialize(owner, caption, text, params[:ic], params[:opts], params[:x], params[:y], &blk)
     end
   end
 
   class FXOption
     alias old_initialize initialize
-    def initialize(p, text, *args)
+    def initialize(p, text, *args, &blk)
       argument_names = %w{ic target selector opts x y width height padLeft padRight padTop padBottom}
       default_params = { :ic => nil, :target => nil, :selector => 0, :opts => JUSTIFY_NORMAL|ICON_BEFORE_TEXT, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_PAD, :padRight => DEFAULT_PAD, :padTop => DEFAULT_PAD, :padBottom => DEFAULT_PAD }
       params = {}
       params = args.pop if args.last.is_a? Hash
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      if params.key? :padding
+        value = params.delete(:padding)
+        [:padLeft, :padRight, :padTop, :padBottom].each { |s| params[s] ||= value }
+      end
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(p, text, params[:ic], params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom])
+      old_initialize(p, text, params[:ic], params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
     end
   end
 
   class FXOptionMenu
     alias old_initialize initialize
-    def initialize(p, *args)
+    def initialize(p, *args, &blk)
       argument_names = %w{pup opts x y width height padLeft padRight padTop padBottom}
       default_params = { :pup => nil, :opts => JUSTIFY_NORMAL|ICON_BEFORE_TEXT, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_PAD, :padRight => DEFAULT_PAD, :padTop => DEFAULT_PAD, :padBottom => DEFAULT_PAD }
       params = {}
       params = args.pop if args.last.is_a? Hash
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      if params.key? :padding
+        value = params.delete(:padding)
+        [:padLeft, :padRight, :padTop, :padBottom].each { |s| params[s] ||= value }
+      end
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(p, params[:pup], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom])
+      old_initialize(p, params[:pup], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
     end
   end
 
   class FXPCXIcon
     alias old_initialize initialize
-    def initialize(a, *args)
+    def initialize(a, *args, &blk)
       argument_names = %w{pix clr opts width height}
       default_params = { :pix => nil, :clr => 0, :opts => 0, :width => 1, :height => 1 }
       params = {}
@@ -1547,13 +1663,13 @@ module Fox
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(a, params[:pix], params[:clr], params[:opts], params[:width], params[:height])
+      old_initialize(a, params[:pix], params[:clr], params[:opts], params[:width], params[:height], &blk)
     end
   end
 
   class FXPCXImage
     alias old_initialize initialize
-    def initialize(a, *args)
+    def initialize(a, *args, &blk)
       argument_names = %w{pix opts width height}
       default_params = { :pix => nil, :opts => 0, :width => 1, :height => 1 }
       params = {}
@@ -1561,27 +1677,31 @@ module Fox
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(a, params[:pix], params[:opts], params[:width], params[:height])
+      old_initialize(a, params[:pix], params[:opts], params[:width], params[:height], &blk)
     end
   end
 
   class FXPicker
     alias old_initialize initialize
-    def initialize(p, text, *args)
+    def initialize(p, text, *args, &blk)
       argument_names = %w{ic target selector opts x y width height padLeft padRight padTop padBottom}
       default_params = { :ic => nil, :target => nil, :selector => 0, :opts => BUTTON_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_PAD, :padRight => DEFAULT_PAD, :padTop => DEFAULT_PAD, :padBottom => DEFAULT_PAD }
       params = {}
       params = args.pop if args.last.is_a? Hash
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      if params.key? :padding
+        value = params.delete(:padding)
+        [:padLeft, :padRight, :padTop, :padBottom].each { |s| params[s] ||= value }
+      end
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(p, text, params[:ic], params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom])
+      old_initialize(p, text, params[:ic], params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
     end
   end
 
   class FXPNGIcon
     alias old_initialize initialize
-    def initialize(a, *args)
+    def initialize(a, *args, &blk)
       argument_names = %w{pix clr opts width height}
       default_params = { :pix => nil, :clr => 0, :opts => 0, :width => 1, :height => 1 }
       params = {}
@@ -1589,13 +1709,13 @@ module Fox
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(a, params[:pix], params[:clr], params[:opts], params[:width], params[:height])
+      old_initialize(a, params[:pix], params[:clr], params[:opts], params[:width], params[:height], &blk)
     end
   end
 
   class FXPNGImage
     alias old_initialize initialize
-    def initialize(a, *args)
+    def initialize(a, *args, &blk)
       argument_names = %w{pix opts width height}
       default_params = { :pix => nil, :opts => 0, :width => 1, :height => 1 }
       params = {}
@@ -1603,13 +1723,13 @@ module Fox
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(a, params[:pix], params[:opts], params[:width], params[:height])
+      old_initialize(a, params[:pix], params[:opts], params[:width], params[:height], &blk)
     end
   end
 
   class FXPopup
     alias old_initialize initialize
-    def initialize(owner, *args)
+    def initialize(owner, *args, &blk)
       argument_names = %w{opts x y width height}
       default_params = { :opts => POPUP_VERTICAL|FRAME_RAISED|FRAME_THICK, :x => 0, :y => 0, :width => 0, :height => 0 }
       params = {}
@@ -1617,13 +1737,13 @@ module Fox
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(owner, params[:opts], params[:x], params[:y], params[:width], params[:height])
+      old_initialize(owner, params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
     end
   end
 
   class FXPPMIcon
     alias old_initialize initialize
-    def initialize(a, *args)
+    def initialize(a, *args, &blk)
       argument_names = %w{pix clr opts width height}
       default_params = { :pix => nil, :clr => 0, :opts => 0, :width => 1, :height => 1 }
       params = {}
@@ -1631,13 +1751,13 @@ module Fox
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(a, params[:pix], params[:clr], params[:opts], params[:width], params[:height])
+      old_initialize(a, params[:pix], params[:clr], params[:opts], params[:width], params[:height], &blk)
     end
   end
 
   class FXPPMImage
     alias old_initialize initialize
-    def initialize(a, *args)
+    def initialize(a, *args, &blk)
       argument_names = %w{pix opts width height}
       default_params = { :pix => nil, :opts => 0, :width => 1, :height => 1 }
       params = {}
@@ -1645,13 +1765,13 @@ module Fox
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(a, params[:pix], params[:opts], params[:width], params[:height])
+      old_initialize(a, params[:pix], params[:opts], params[:width], params[:height], &blk)
     end
   end
 
   class FXPrintDialog
     alias old_initialize initialize
-    def initialize(owner, name, *args)
+    def initialize(owner, name, *args, &blk)
       argument_names = %w{opts x y width height}
       default_params = { :opts => 0, :x => 0, :y => 0, :width => 0, :height => 0 }
       params = {}
@@ -1659,27 +1779,31 @@ module Fox
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(owner, name, params[:opts], params[:x], params[:y], params[:width], params[:height])
+      old_initialize(owner, name, params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
     end
   end
 
   class FXProgressBar
     alias old_initialize initialize
-    def initialize(p, *args)
+    def initialize(p, *args, &blk)
       argument_names = %w{target selector opts x y width height padLeft padRight padTop padBottom}
       default_params = { :target => nil, :selector => 0, :opts => PROGRESSBAR_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_PAD, :padRight => DEFAULT_PAD, :padTop => DEFAULT_PAD, :padBottom => DEFAULT_PAD }
       params = {}
       params = args.pop if args.last.is_a? Hash
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      if params.key? :padding
+        value = params.delete(:padding)
+        [:padLeft, :padRight, :padTop, :padBottom].each { |s| params[s] ||= value }
+      end
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(p, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom])
+      old_initialize(p, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
     end
   end
 
   class FXProgressDialog
     alias old_initialize initialize
-    def initialize(owner, caption, label, *args)
+    def initialize(owner, caption, label, *args, &blk)
       argument_names = %w{opts x y width height}
       default_params = { :opts => PROGRESSDIALOG_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0 }
       params = {}
@@ -1687,55 +1811,67 @@ module Fox
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(owner, caption, label, params[:opts], params[:x], params[:y], params[:width], params[:height])
+      old_initialize(owner, caption, label, params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
     end
   end
 
   class FXRadioButton
     alias old_initialize initialize
-    def initialize(parent, text, *args)
+    def initialize(parent, text, *args, &blk)
       argument_names = %w{target selector opts x y width height padLeft padRight padTop padBottom}
       default_params = { :target => nil, :selector => 0, :opts => RADIOBUTTON_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_PAD, :padRight => DEFAULT_PAD, :padTop => DEFAULT_PAD, :padBottom => DEFAULT_PAD }
       params = {}
       params = args.pop if args.last.is_a? Hash
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      if params.key? :padding
+        value = params.delete(:padding)
+        [:padLeft, :padRight, :padTop, :padBottom].each { |s| params[s] ||= value }
+      end
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(parent, text, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom])
+      old_initialize(parent, text, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
     end
   end
 
   class FXRealSlider
     alias old_initialize initialize
-    def initialize(p, *args)
+    def initialize(p, *args, &blk)
       argument_names = %w{target selector opts x y width height padLeft padRight padTop padBottom}
       default_params = { :target => nil, :selector => 0, :opts => REALSLIDER_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => 0, :padRight => 0, :padTop => 0, :padBottom => 0 }
       params = {}
       params = args.pop if args.last.is_a? Hash
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      if params.key? :padding
+        value = params.delete(:padding)
+        [:padLeft, :padRight, :padTop, :padBottom].each { |s| params[s] ||= value }
+      end
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(p, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom])
+      old_initialize(p, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
     end
   end
 
   class FXRealSpinner
     alias old_initialize initialize
-    def initialize(p, cols, *args)
+    def initialize(p, cols, *args, &blk)
       argument_names = %w{target selector opts x y width height padLeft padRight padTop padBottom}
       default_params = { :target => nil, :selector => 0, :opts => REALSPIN_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_PAD, :padRight => DEFAULT_PAD, :padTop => DEFAULT_PAD, :padBottom => DEFAULT_PAD }
       params = {}
       params = args.pop if args.last.is_a? Hash
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      if params.key? :padding
+        value = params.delete(:padding)
+        [:padLeft, :padRight, :padTop, :padBottom].each { |s| params[s] ||= value }
+      end
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(p, cols, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom])
+      old_initialize(p, cols, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
     end
   end
 
   class FXRegistry
     alias old_initialize initialize
-    def initialize(*args)
+    def initialize(*args, &blk)
       argument_names = %w{appKey vendorKey}
       default_params = { :appKey => "", :vendorKey => "" }
       params = {}
@@ -1743,13 +1879,13 @@ module Fox
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(params[:appKey], params[:vendorKey])
+      old_initialize(params[:appKey], params[:vendorKey], &blk)
     end
   end
 
   class FXReplaceDialog
     alias old_initialize initialize
-    def initialize(owner, caption, *args)
+    def initialize(owner, caption, *args, &blk)
       argument_names = %w{ic opts x y width height}
       default_params = { :ic => nil, :opts => 0, :x => 0, :y => 0, :width => 0, :height => 0 }
       params = {}
@@ -1757,13 +1893,13 @@ module Fox
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(owner, caption, params[:ic], params[:opts], params[:x], params[:y], params[:width], params[:height])
+      old_initialize(owner, caption, params[:ic], params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
     end
   end
 
   class FXRGBIcon
     alias old_initialize initialize
-    def initialize(a, *args)
+    def initialize(a, *args, &blk)
       argument_names = %w{pix clr opts width height}
       default_params = { :pix => nil, :clr => 0, :opts => 0, :width => 1, :height => 1 }
       params = {}
@@ -1771,13 +1907,13 @@ module Fox
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(a, params[:pix], params[:clr], params[:opts], params[:width], params[:height])
+      old_initialize(a, params[:pix], params[:clr], params[:opts], params[:width], params[:height], &blk)
     end
   end
 
   class FXRGBImage
     alias old_initialize initialize
-    def initialize(a, *args)
+    def initialize(a, *args, &blk)
       argument_names = %w{pix opts width height}
       default_params = { :pix => nil, :opts => 0, :width => 1, :height => 1 }
       params = {}
@@ -1785,27 +1921,31 @@ module Fox
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(a, params[:pix], params[:opts], params[:width], params[:height])
+      old_initialize(a, params[:pix], params[:opts], params[:width], params[:height], &blk)
     end
   end
 
   class FXRuler
     alias old_initialize initialize
-    def initialize(p, *args)
+    def initialize(p, *args, &blk)
       argument_names = %w{target selector opts x y width height padLeft padRight padTop padBottom}
       default_params = { :target => nil, :selector => 0, :opts => RULER_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_PAD, :padRight => DEFAULT_PAD, :padTop => DEFAULT_PAD, :padBottom => DEFAULT_PAD }
       params = {}
       params = args.pop if args.last.is_a? Hash
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      if params.key? :padding
+        value = params.delete(:padding)
+        [:padLeft, :padRight, :padTop, :padBottom].each { |s| params[s] ||= value }
+      end
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(p, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom])
+      old_initialize(p, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
     end
   end
 
   class FXRulerView
     alias old_initialize initialize
-    def initialize(p, *args)
+    def initialize(p, *args, &blk)
       argument_names = %w{target selector opts x y width height}
       default_params = { :target => nil, :selector => 0, :opts => 0, :x => 0, :y => 0, :width => 0, :height => 0 }
       params = {}
@@ -1813,13 +1953,13 @@ module Fox
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(p, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height])
+      old_initialize(p, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
     end
   end
 
   class FXScintilla
     alias old_initialize initialize
-    def initialize(p, *args)
+    def initialize(p, *args, &blk)
       argument_names = %w{target selector opts x y width height}
       default_params = { :target => nil, :selector => 0, :opts => 0, :x => 0, :y => 0, :width => 0, :height => 0 }
       params = {}
@@ -1827,13 +1967,13 @@ module Fox
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(p, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height])
+      old_initialize(p, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
     end
   end
 
   class FXScrollArea
     alias old_initialize initialize
-    def initialize(parent, *args)
+    def initialize(parent, *args, &blk)
       argument_names = %w{opts x y width height}
       default_params = { :opts => 0, :x => 0, :y => 0, :width => 0, :height => 0 }
       params = {}
@@ -1841,13 +1981,13 @@ module Fox
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(parent, params[:opts], params[:x], params[:y], params[:width], params[:height])
+      old_initialize(parent, params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
     end
   end
 
   class FXScrollBar
     alias old_initialize initialize
-    def initialize(p, *args)
+    def initialize(p, *args, &blk)
       argument_names = %w{target selector opts x y width height}
       default_params = { :target => nil, :selector => 0, :opts => SCROLLBAR_VERTICAL, :x => 0, :y => 0, :width => 0, :height => 0 }
       params = {}
@@ -1855,13 +1995,13 @@ module Fox
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(p, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height])
+      old_initialize(p, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
     end
   end
 
   class FXScrollPane
     alias old_initialize initialize
-    def initialize(owner, nvis, *args)
+    def initialize(owner, nvis, *args, &blk)
       argument_names = %w{opts}
       default_params = { :opts => 0 }
       params = {}
@@ -1869,13 +2009,13 @@ module Fox
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(owner, nvis, params[:opts])
+      old_initialize(owner, nvis, params[:opts], &blk)
     end
   end
 
   class FXScrollWindow
     alias old_initialize initialize
-    def initialize(p, *args)
+    def initialize(p, *args, &blk)
       argument_names = %w{opts x y width height}
       default_params = { :opts => 0, :x => 0, :y => 0, :width => 0, :height => 0 }
       params = {}
@@ -1883,13 +2023,13 @@ module Fox
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(p, params[:opts], params[:x], params[:y], params[:width], params[:height])
+      old_initialize(p, params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
     end
   end
 
   class FXSearchDialog
     alias old_initialize initialize
-    def initialize(owner, caption, *args)
+    def initialize(owner, caption, *args, &blk)
       argument_names = %w{ic opts x y width height}
       default_params = { :ic => nil, :opts => 0, :x => 0, :y => 0, :width => 0, :height => 0 }
       params = {}
@@ -1897,111 +2037,139 @@ module Fox
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(owner, caption, params[:ic], params[:opts], params[:x], params[:y], params[:width], params[:height])
+      old_initialize(owner, caption, params[:ic], params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
     end
   end
 
   class FXSeparator
     alias old_initialize initialize
-    def initialize(p, *args)
+    def initialize(p, *args, &blk)
       argument_names = %w{opts x y width height padLeft padRight padTop padBottom}
       default_params = { :opts => SEPARATOR_GROOVE|LAYOUT_FILL_X, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => 0, :padRight => 0, :padTop => 0, :padBottom => 0 }
       params = {}
       params = args.pop if args.last.is_a? Hash
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      if params.key? :padding
+        value = params.delete(:padding)
+        [:padLeft, :padRight, :padTop, :padBottom].each { |s| params[s] ||= value }
+      end
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(p, params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom])
+      old_initialize(p, params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
     end
   end
 
   class FXHorizontalSeparator
     alias old_initialize initialize
-    def initialize(p, *args)
+    def initialize(p, *args, &blk)
       argument_names = %w{opts x y width height padLeft padRight padTop padBottom}
       default_params = { :opts => SEPARATOR_GROOVE|LAYOUT_FILL_X, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => 1, :padRight => 1, :padTop => 0, :padBottom => 0 }
       params = {}
       params = args.pop if args.last.is_a? Hash
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      if params.key? :padding
+        value = params.delete(:padding)
+        [:padLeft, :padRight, :padTop, :padBottom].each { |s| params[s] ||= value }
+      end
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(p, params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom])
+      old_initialize(p, params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
     end
   end
 
   class FXVerticalSeparator
     alias old_initialize initialize
-    def initialize(p, *args)
+    def initialize(p, *args, &blk)
       argument_names = %w{opts x y width height padLeft padRight padTop padBottom}
       default_params = { :opts => SEPARATOR_GROOVE|LAYOUT_FILL_Y, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => 0, :padRight => 0, :padTop => 1, :padBottom => 1 }
       params = {}
       params = args.pop if args.last.is_a? Hash
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      if params.key? :padding
+        value = params.delete(:padding)
+        [:padLeft, :padRight, :padTop, :padBottom].each { |s| params[s] ||= value }
+      end
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(p, params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom])
+      old_initialize(p, params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
     end
   end
 
   class FXShutterItem
     alias old_initialize initialize
-    def initialize(p, *args)
+    def initialize(p, *args, &blk)
       argument_names = %w{text icon opts x y width height padLeft padRight padTop padBottom hSpacing vSpacing}
       default_params = { :text => "", :icon => nil, :opts => 0, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_SPACING, :padRight => DEFAULT_SPACING, :padTop => DEFAULT_SPACING, :padBottom => DEFAULT_SPACING, :hSpacing => DEFAULT_SPACING, :vSpacing => DEFAULT_SPACING }
       params = {}
       params = args.pop if args.last.is_a? Hash
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      if params.key? :padding
+        value = params.delete(:padding)
+        [:padLeft, :padRight, :padTop, :padBottom].each { |s| params[s] ||= value }
+      end
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(p, params[:text], params[:icon], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], params[:hSpacing], params[:vSpacing])
+      old_initialize(p, params[:text], params[:icon], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], params[:hSpacing], params[:vSpacing], &blk)
     end
   end
 
   class FXShutter
     alias old_initialize initialize
-    def initialize(p, *args)
+    def initialize(p, *args, &blk)
       argument_names = %w{target selector opts x y width height padLeft padRight padTop padBottom hSpacing vSpacing}
       default_params = { :target => nil, :selector => 0, :opts => 0, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_SPACING, :padRight => DEFAULT_SPACING, :padTop => DEFAULT_SPACING, :padBottom => DEFAULT_SPACING, :hSpacing => DEFAULT_SPACING, :vSpacing => DEFAULT_SPACING }
       params = {}
       params = args.pop if args.last.is_a? Hash
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      if params.key? :padding
+        value = params.delete(:padding)
+        [:padLeft, :padRight, :padTop, :padBottom].each { |s| params[s] ||= value }
+      end
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(p, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], params[:hSpacing], params[:vSpacing])
+      old_initialize(p, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], params[:hSpacing], params[:vSpacing], &blk)
     end
   end
 
   class FXSlider
     alias old_initialize initialize
-    def initialize(p, *args)
+    def initialize(p, *args, &blk)
       argument_names = %w{target selector opts x y width height padLeft padRight padTop padBottom}
       default_params = { :target => nil, :selector => 0, :opts => SLIDER_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => 0, :padRight => 0, :padTop => 0, :padBottom => 0 }
       params = {}
       params = args.pop if args.last.is_a? Hash
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      if params.key? :padding
+        value = params.delete(:padding)
+        [:padLeft, :padRight, :padTop, :padBottom].each { |s| params[s] ||= value }
+      end
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(p, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom])
+      old_initialize(p, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
     end
   end
 
   class FXSpinner
     alias old_initialize initialize
-    def initialize(p, cols, *args)
+    def initialize(p, cols, *args, &blk)
       argument_names = %w{target selector opts x y width height padLeft padRight padTop padBottom}
       default_params = { :target => nil, :selector => 0, :opts => SPIN_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_PAD, :padRight => DEFAULT_PAD, :padTop => DEFAULT_PAD, :padBottom => DEFAULT_PAD }
       params = {}
       params = args.pop if args.last.is_a? Hash
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      if params.key? :padding
+        value = params.delete(:padding)
+        [:padLeft, :padRight, :padTop, :padBottom].each { |s| params[s] ||= value }
+      end
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(p, cols, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom])
+      old_initialize(p, cols, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
     end
   end
 
   class FXSplashWindow
     alias old_initialize initialize
-    def initialize(owner, icon, *args)
+    def initialize(owner, icon, *args, &blk)
       argument_names = %w{opts ms}
       default_params = { :opts => SPLASH_SIMPLE, :ms => 5000 }
       params = {}
@@ -2009,41 +2177,49 @@ module Fox
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(owner, icon, params[:opts], params[:ms])
+      old_initialize(owner, icon, params[:opts], params[:ms], &blk)
     end
   end
 
   class FXSpring
     alias old_initialize initialize
-    def initialize(p, *args)
+    def initialize(p, *args, &blk)
       argument_names = %w{opts relw relh x y width height padLeft padRight padTop padBottom hSpacing vSpacing}
       default_params = { :opts => 0, :relw => 0, :relh => 0, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_SPACING, :padRight => DEFAULT_SPACING, :padTop => DEFAULT_SPACING, :padBottom => DEFAULT_SPACING, :hSpacing => DEFAULT_SPACING, :vSpacing => DEFAULT_SPACING }
       params = {}
       params = args.pop if args.last.is_a? Hash
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      if params.key? :padding
+        value = params.delete(:padding)
+        [:padLeft, :padRight, :padTop, :padBottom].each { |s| params[s] ||= value }
+      end
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(p, params[:opts], params[:relw], params[:relh], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], params[:hSpacing], params[:vSpacing])
+      old_initialize(p, params[:opts], params[:relw], params[:relh], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], params[:hSpacing], params[:vSpacing], &blk)
     end
   end
 
   class FXStatusBar
     alias old_initialize initialize
-    def initialize(p, *args)
+    def initialize(p, *args, &blk)
       argument_names = %w{opts x y width height padLeft padRight padTop padBottom hSpacing vSpacing}
       default_params = { :opts => 0, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => 3, :padRight => 3, :padTop => 2, :padBottom => 2, :hSpacing => 4, :vSpacing => 0 }
       params = {}
       params = args.pop if args.last.is_a? Hash
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      if params.key? :padding
+        value = params.delete(:padding)
+        [:padLeft, :padRight, :padTop, :padBottom].each { |s| params[s] ||= value }
+      end
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(p, params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], params[:hSpacing], params[:vSpacing])
+      old_initialize(p, params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], params[:hSpacing], params[:vSpacing], &blk)
     end
   end
 
   class FXStatusLine
     alias old_initialize initialize
-    def initialize(p, *args)
+    def initialize(p, *args, &blk)
       argument_names = %w{target selector}
       default_params = { :target => nil, :selector => 0 }
       params = {}
@@ -2051,13 +2227,13 @@ module Fox
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(p, params[:target], params[:selector])
+      old_initialize(p, params[:target], params[:selector], &blk)
     end
   end
 
   class FXStream
     alias old_initialize initialize
-    def initialize(*args)
+    def initialize(*args, &blk)
       argument_names = %w{cont}
       default_params = { :cont => nil }
       params = {}
@@ -2065,69 +2241,85 @@ module Fox
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(params[:cont])
+      old_initialize(params[:cont], &blk)
     end
   end
 
   class FXSwitcher
     alias old_initialize initialize
-    def initialize(p, *args)
+    def initialize(p, *args, &blk)
       argument_names = %w{opts x y width height padLeft padRight padTop padBottom}
       default_params = { :opts => 0, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_SPACING, :padRight => DEFAULT_SPACING, :padTop => DEFAULT_SPACING, :padBottom => DEFAULT_SPACING }
       params = {}
       params = args.pop if args.last.is_a? Hash
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      if params.key? :padding
+        value = params.delete(:padding)
+        [:padLeft, :padRight, :padTop, :padBottom].each { |s| params[s] ||= value }
+      end
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(p, params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom])
+      old_initialize(p, params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
     end
   end
 
   class FXTabBar
     alias old_initialize initialize
-    def initialize(p, *args)
+    def initialize(p, *args, &blk)
       argument_names = %w{target selector opts x y width height padLeft padRight padTop padBottom}
       default_params = { :target => nil, :selector => 0, :opts => TABBOOK_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_SPACING, :padRight => DEFAULT_SPACING, :padTop => DEFAULT_SPACING, :padBottom => DEFAULT_SPACING }
       params = {}
       params = args.pop if args.last.is_a? Hash
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      if params.key? :padding
+        value = params.delete(:padding)
+        [:padLeft, :padRight, :padTop, :padBottom].each { |s| params[s] ||= value }
+      end
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(p, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom])
+      old_initialize(p, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
     end
   end
 
   class FXTabBook
     alias old_initialize initialize
-    def initialize(p, *args)
+    def initialize(p, *args, &blk)
       argument_names = %w{target selector opts x y width height padLeft padRight padTop padBottom}
       default_params = { :target => nil, :selector => 0, :opts => TABBOOK_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_SPACING, :padRight => DEFAULT_SPACING, :padTop => DEFAULT_SPACING, :padBottom => DEFAULT_SPACING }
       params = {}
       params = args.pop if args.last.is_a? Hash
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      if params.key? :padding
+        value = params.delete(:padding)
+        [:padLeft, :padRight, :padTop, :padBottom].each { |s| params[s] ||= value }
+      end
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(p, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom])
+      old_initialize(p, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
     end
   end
 
   class FXTabItem
     alias old_initialize initialize
-    def initialize(p, text, *args)
+    def initialize(p, text, *args, &blk)
       argument_names = %w{ic opts x y width height padLeft padRight padTop padBottom}
       default_params = { :ic => nil, :opts => TAB_TOP_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_PAD, :padRight => DEFAULT_PAD, :padTop => DEFAULT_PAD, :padBottom => DEFAULT_PAD }
       params = {}
       params = args.pop if args.last.is_a? Hash
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      if params.key? :padding
+        value = params.delete(:padding)
+        [:padLeft, :padRight, :padTop, :padBottom].each { |s| params[s] ||= value }
+      end
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(p, text, params[:ic], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom])
+      old_initialize(p, text, params[:ic], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
     end
   end
 
   class FXTableItem
     alias old_initialize initialize
-    def initialize(text, *args)
+    def initialize(text, *args, &blk)
       argument_names = %w{icon data}
       default_params = { :icon => nil, :data => nil }
       params = {}
@@ -2135,55 +2327,67 @@ module Fox
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(text, params[:icon], params[:data])
+      old_initialize(text, params[:icon], params[:data], &blk)
     end
   end
 
   class FXTable
     alias old_initialize initialize
-    def initialize(p, *args)
+    def initialize(p, *args, &blk)
       argument_names = %w{target selector opts x y width height padLeft padRight padTop padBottom}
       default_params = { :target => nil, :selector => 0, :opts => 0, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_MARGIN, :padRight => DEFAULT_MARGIN, :padTop => DEFAULT_MARGIN, :padBottom => DEFAULT_MARGIN }
       params = {}
       params = args.pop if args.last.is_a? Hash
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      if params.key? :padding
+        value = params.delete(:padding)
+        [:padLeft, :padRight, :padTop, :padBottom].each { |s| params[s] ||= value }
+      end
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(p, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom])
+      old_initialize(p, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
     end
   end
 
   class FXText
     alias old_initialize initialize
-    def initialize(p, *args)
+    def initialize(p, *args, &blk)
       argument_names = %w{target selector opts x y width height padLeft padRight padTop padBottom}
       default_params = { :target => nil, :selector => 0, :opts => 0, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => 3, :padRight => 3, :padTop => 2, :padBottom => 2 }
       params = {}
       params = args.pop if args.last.is_a? Hash
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      if params.key? :padding
+        value = params.delete(:padding)
+        [:padLeft, :padRight, :padTop, :padBottom].each { |s| params[s] ||= value }
+      end
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(p, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom])
+      old_initialize(p, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
     end
   end
 
   class FXTextField
     alias old_initialize initialize
-    def initialize(p, ncols, *args)
+    def initialize(p, ncols, *args, &blk)
       argument_names = %w{target selector opts x y width height padLeft padRight padTop padBottom}
       default_params = { :target => nil, :selector => 0, :opts => TEXTFIELD_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_PAD, :padRight => DEFAULT_PAD, :padTop => DEFAULT_PAD, :padBottom => DEFAULT_PAD }
       params = {}
       params = args.pop if args.last.is_a? Hash
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      if params.key? :padding
+        value = params.delete(:padding)
+        [:padLeft, :padRight, :padTop, :padBottom].each { |s| params[s] ||= value }
+      end
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(p, ncols, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom])
+      old_initialize(p, ncols, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
     end
   end
 
   class FXTGAIcon
     alias old_initialize initialize
-    def initialize(a, *args)
+    def initialize(a, *args, &blk)
       argument_names = %w{pix clr opts width height}
       default_params = { :pix => nil, :clr => 0, :opts => 0, :width => 1, :height => 1 }
       params = {}
@@ -2191,13 +2395,13 @@ module Fox
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(a, params[:pix], params[:clr], params[:opts], params[:width], params[:height])
+      old_initialize(a, params[:pix], params[:clr], params[:opts], params[:width], params[:height], &blk)
     end
   end
 
   class FXTGAImage
     alias old_initialize initialize
-    def initialize(a, *args)
+    def initialize(a, *args, &blk)
       argument_names = %w{pix opts width height}
       default_params = { :pix => nil, :opts => 0, :width => 1, :height => 1 }
       params = {}
@@ -2205,13 +2409,13 @@ module Fox
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(a, params[:pix], params[:opts], params[:width], params[:height])
+      old_initialize(a, params[:pix], params[:opts], params[:width], params[:height], &blk)
     end
   end
 
   class FXTIFIcon
     alias old_initialize initialize
-    def initialize(a, *args)
+    def initialize(a, *args, &blk)
       argument_names = %w{pix clr opts width height}
       default_params = { :pix => nil, :clr => 0, :opts => 0, :width => 1, :height => 1 }
       params = {}
@@ -2219,13 +2423,13 @@ module Fox
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(a, params[:pix], params[:clr], params[:opts], params[:width], params[:height])
+      old_initialize(a, params[:pix], params[:clr], params[:opts], params[:width], params[:height], &blk)
     end
   end
 
   class FXTIFImage
     alias old_initialize initialize
-    def initialize(a, *args)
+    def initialize(a, *args, &blk)
       argument_names = %w{pix opts width height}
       default_params = { :pix => nil, :opts => 0, :width => 1, :height => 1 }
       params = {}
@@ -2233,27 +2437,31 @@ module Fox
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(a, params[:pix], params[:opts], params[:width], params[:height])
+      old_initialize(a, params[:pix], params[:opts], params[:width], params[:height], &blk)
     end
   end
 
   class FXToggleButton
     alias old_initialize initialize
-    def initialize(p, text1, text2, *args)
+    def initialize(p, text1, text2, *args, &blk)
       argument_names = %w{icon1 icon2 target selector opts x y width height padLeft padRight padTop padBottom}
       default_params = { :icon1 => nil, :icon2 => nil, :target => nil, :selector => 0, :opts => TOGGLEBUTTON_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_PAD, :padRight => DEFAULT_PAD, :padTop => DEFAULT_PAD, :padBottom => DEFAULT_PAD }
       params = {}
       params = args.pop if args.last.is_a? Hash
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      if params.key? :padding
+        value = params.delete(:padding)
+        [:padLeft, :padRight, :padTop, :padBottom].each { |s| params[s] ||= value }
+      end
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(p, text1, text2, params[:icon1], params[:icon2], params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom])
+      old_initialize(p, text1, text2, params[:icon1], params[:icon2], params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
     end
   end
 
   class FXToolBarGrip
     alias old_initialize initialize
-    def initialize(p, *args)
+    def initialize(p, *args, &blk)
       argument_names = %w{target selector opts x y width height}
       default_params = { :target => nil, :selector => 0, :opts => TOOLBARGRIP_SINGLE, :x => 0, :y => 0, :width => 0, :height => 0 }
       params = {}
@@ -2261,13 +2469,13 @@ module Fox
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(p, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height])
+      old_initialize(p, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
     end
   end
 
   class FXToolBarShell
     alias old_initialize initialize
-    def initialize(owner, *args)
+    def initialize(owner, *args, &blk)
       argument_names = %w{opts x y width height hSpacing vSpacing}
       default_params = { :opts => FRAME_RAISED|FRAME_THICK, :x => 0, :y => 0, :width => 0, :height => 0, :hSpacing => 4, :vSpacing => 4 }
       params = {}
@@ -2275,13 +2483,13 @@ module Fox
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(owner, params[:opts], params[:x], params[:y], params[:width], params[:height], params[:hSpacing], params[:vSpacing])
+      old_initialize(owner, params[:opts], params[:x], params[:y], params[:width], params[:height], params[:hSpacing], params[:vSpacing], &blk)
     end
   end
 
   class FXToolBarTab
     alias old_initialize initialize
-    def initialize(p, *args)
+    def initialize(p, *args, &blk)
       argument_names = %w{target selector opts x y width height}
       default_params = { :target => nil, :selector => 0, :opts => FRAME_RAISED, :x => 0, :y => 0, :width => 0, :height => 0 }
       params = {}
@@ -2289,13 +2497,13 @@ module Fox
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(p, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height])
+      old_initialize(p, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
     end
   end
 
   class FXToolTip
     alias old_initialize initialize
-    def initialize(app, *args)
+    def initialize(app, *args, &blk)
       argument_names = %w{opts x y width height}
       default_params = { :opts => TOOLTIP_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0 }
       params = {}
@@ -2303,13 +2511,13 @@ module Fox
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(app, params[:opts], params[:x], params[:y], params[:width], params[:height])
+      old_initialize(app, params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
     end
   end
 
   class FXTreeItem
     alias old_initialize initialize
-    def initialize(text, *args)
+    def initialize(text, *args, &blk)
       argument_names = %w{openIcon closedIcon data}
       default_params = { :openIcon => nil, :closedIcon => nil, :data => nil }
       params = {}
@@ -2317,13 +2525,13 @@ module Fox
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(text, params[:openIcon], params[:closedIcon], params[:data])
+      old_initialize(text, params[:openIcon], params[:closedIcon], params[:data], &blk)
     end
   end
 
   class FXTreeList
     alias old_initialize initialize
-    def initialize(p, *args)
+    def initialize(p, *args, &blk)
       argument_names = %w{target selector opts x y width height}
       default_params = { :target => nil, :selector => 0, :opts => TREELIST_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0 }
       params = {}
@@ -2331,41 +2539,49 @@ module Fox
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(p, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height])
+      old_initialize(p, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
     end
   end
 
   class FXTreeListBox
     alias old_initialize initialize
-    def initialize(p, *args)
+    def initialize(p, *args, &blk)
       argument_names = %w{target selector opts x y width height padLeft padRight padTop padBottom}
       default_params = { :target => nil, :selector => 0, :opts => FRAME_SUNKEN|FRAME_THICK|TREELISTBOX_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_PAD, :padRight => DEFAULT_PAD, :padTop => DEFAULT_PAD, :padBottom => DEFAULT_PAD }
       params = {}
       params = args.pop if args.last.is_a? Hash
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      if params.key? :padding
+        value = params.delete(:padding)
+        [:padLeft, :padRight, :padTop, :padBottom].each { |s| params[s] ||= value }
+      end
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(p, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom])
+      old_initialize(p, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
     end
   end
 
   class FXTriStateButton
     alias old_initialize initialize
-    def initialize(p, text1, text2, text3, *args)
+    def initialize(p, text1, text2, text3, *args, &blk)
       argument_names = %w{icon1 icon2 icon3 target selector opts x y width height padLeft padRight padTop padBottom}
       default_params = { :icon1 => nil, :icon2 => nil, :icon3 => nil, :target => nil, :selector => 0, :opts => TOGGLEBUTTON_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_PAD, :padRight => DEFAULT_PAD, :padTop => DEFAULT_PAD, :padBottom => DEFAULT_PAD }
       params = {}
       params = args.pop if args.last.is_a? Hash
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      if params.key? :padding
+        value = params.delete(:padding)
+        [:padLeft, :padRight, :padTop, :padBottom].each { |s| params[s] ||= value }
+      end
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(p, text1, text2, text3, params[:icon1], params[:icon2], params[:icon3], params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom])
+      old_initialize(p, text1, text2, text3, params[:icon1], params[:icon2], params[:icon3], params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
     end
   end
 
   class FXVec4d
     alias old_initialize initialize
-    def initialize(xx, yy, zz, *args)
+    def initialize(xx, yy, zz, *args, &blk)
       argument_names = %w{ww}
       default_params = { :ww => 1.0 }
       params = {}
@@ -2373,13 +2589,13 @@ module Fox
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(xx, yy, zz, params[:ww])
+      old_initialize(xx, yy, zz, params[:ww], &blk)
     end
   end
 
   class FXVec4f
     alias old_initialize initialize
-    def initialize(xx, yy, zz, *args)
+    def initialize(xx, yy, zz, *args, &blk)
       argument_names = %w{ww}
       default_params = { :ww => 1.0 }
       params = {}
@@ -2387,27 +2603,31 @@ module Fox
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(xx, yy, zz, params[:ww])
+      old_initialize(xx, yy, zz, params[:ww], &blk)
     end
   end
 
   class FXVerticalFrame
     alias old_initialize initialize
-    def initialize(p, *args)
+    def initialize(p, *args, &blk)
       argument_names = %w{opts x y width height padLeft padRight padTop padBottom hSpacing vSpacing}
       default_params = { :opts => 0, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_SPACING, :padRight => DEFAULT_SPACING, :padTop => DEFAULT_SPACING, :padBottom => DEFAULT_SPACING, :hSpacing => DEFAULT_SPACING, :vSpacing => DEFAULT_SPACING }
       params = {}
       params = args.pop if args.last.is_a? Hash
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      if params.key? :padding
+        value = params.delete(:padding)
+        [:padLeft, :padRight, :padTop, :padBottom].each { |s| params[s] ||= value }
+      end
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(p, params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], params[:hSpacing], params[:vSpacing])
+      old_initialize(p, params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], params[:hSpacing], params[:vSpacing], &blk)
     end
   end
 
   class FXVisual
     alias old_initialize initialize
-    def initialize(a, flgs, *args)
+    def initialize(a, flgs, *args, &blk)
       argument_names = %w{d}
       default_params = { :d => 32 }
       params = {}
@@ -2415,27 +2635,31 @@ module Fox
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(a, flgs, params[:d])
+      old_initialize(a, flgs, params[:d], &blk)
     end
   end
 
   class FXWizard
     alias old_initialize initialize
-    def initialize(owner, name, image, *args)
+    def initialize(owner, name, image, *args, &blk)
       argument_names = %w{opts x y width height padLeft padRight padTop padBottom hSpacing vSpacing}
       default_params = { :opts => DECOR_TITLE|DECOR_BORDER|DECOR_RESIZE, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => 10, :padRight => 10, :padTop => 10, :padBottom => 10, :hSpacing => 10, :vSpacing => 10 }
       params = {}
       params = args.pop if args.last.is_a? Hash
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      if params.key? :padding
+        value = params.delete(:padding)
+        [:padLeft, :padRight, :padTop, :padBottom].each { |s| params[s] ||= value }
+      end
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(owner, name, image, params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], params[:hSpacing], params[:vSpacing])
+      old_initialize(owner, name, image, params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], params[:hSpacing], params[:vSpacing], &blk)
     end
   end
 
   class FXXBMIcon
     alias old_initialize initialize
-    def initialize(a, *args)
+    def initialize(a, *args, &blk)
       argument_names = %w{pixels mask clr opts width height}
       default_params = { :pixels => nil, :mask => nil, :clr => 0, :opts => 0, :width => 1, :height => 1 }
       params = {}
@@ -2443,13 +2667,13 @@ module Fox
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(a, params[:pixels], params[:mask], params[:clr], params[:opts], params[:width], params[:height])
+      old_initialize(a, params[:pixels], params[:mask], params[:clr], params[:opts], params[:width], params[:height], &blk)
     end
   end
 
   class FXXBMImage
     alias old_initialize initialize
-    def initialize(a, *args)
+    def initialize(a, *args, &blk)
       argument_names = %w{pixels mask opts width height}
       default_params = { :pixels => nil, :mask => nil, :opts => 0, :width => 1, :height => 1 }
       params = {}
@@ -2457,13 +2681,13 @@ module Fox
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(a, params[:pixels], params[:mask], params[:opts], params[:width], params[:height])
+      old_initialize(a, params[:pixels], params[:mask], params[:opts], params[:width], params[:height], &blk)
     end
   end
 
   class FXXPMIcon
     alias old_initialize initialize
-    def initialize(a, *args)
+    def initialize(a, *args, &blk)
       argument_names = %w{pix clr opts width height}
       default_params = { :pix => nil, :clr => 0, :opts => 0, :width => 1, :height => 1 }
       params = {}
@@ -2471,13 +2695,13 @@ module Fox
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(a, params[:pix], params[:clr], params[:opts], params[:width], params[:height])
+      old_initialize(a, params[:pix], params[:clr], params[:opts], params[:width], params[:height], &blk)
     end
   end
 
   class FXXPMImage
     alias old_initialize initialize
-    def initialize(a, *args)
+    def initialize(a, *args, &blk)
       argument_names = %w{pix opts width height}
       default_params = { :pix => nil, :opts => 0, :width => 1, :height => 1 }
       params = {}
@@ -2485,7 +2709,7 @@ module Fox
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(a, params[:pix], params[:opts], params[:width], params[:height])
+      old_initialize(a, params[:pix], params[:opts], params[:width], params[:height], &blk)
     end
   end