wxruby3 0.9.0.pre.beta.10 → 0.9.0.pre.beta.13

data/lib/wx/core/bitmap.rb

@@ -1,66 +1,103 @@
 # A platform-dependent image that can be drawn on the screen
-class Wx::Bitmap
-  # Allow wxRuby to guess the type of an image file from its extension.
-  BITMAP_TYPE_GUESS = { 
-    'bmp'  => Wx::BitmapType::BITMAP_TYPE_BMP,
-    'gif'  => Wx::BitmapType::BITMAP_TYPE_GIF,
-    'ico'  => Wx::BitmapType::BITMAP_TYPE_ICO,
-    'jpeg' => Wx::BitmapType::BITMAP_TYPE_JPEG,
-    'jpg'  => Wx::BitmapType::BITMAP_TYPE_JPEG,
-    'pbm'  => Wx::BitmapType::BITMAP_TYPE_PNM,
-    'pcx'  => Wx::BitmapType::BITMAP_TYPE_PCX,
-    'pgm'  => Wx::BitmapType::BITMAP_TYPE_PNM,
-    'png'  => Wx::BitmapType::BITMAP_TYPE_PNG,
-    'pnm'  => Wx::BitmapType::BITMAP_TYPE_PNM,
-    'ppm'  => Wx::BitmapType::BITMAP_TYPE_PNM,
-    'tga'  => Wx::BitmapType::BITMAP_TYPE_TGA,
-    'tif'  => Wx::BitmapType::BITMAP_TYPE_TIF,
-    'tiff' => Wx::BitmapType::BITMAP_TYPE_TIF,
-    'xbm'  => Wx::BitmapType::BITMAP_TYPE_XBM,
-    'xpm'  => Wx::BitmapType::BITMAP_TYPE_XPM
-  }
+module Wx
 
-  # Constructor copying data from an image
-  def self.from_image(img, depth = -1)
-    new(img, depth)
+  if Wx::PLATFORM == 'WXMSW'
+    ICON_DEFAULT_TYPE = BitmapType::BITMAP_TYPE_ICO
+  elsif Wx::PLATFORM == 'WXGTK'
+    ICON_DEFAULT_TYPE = BitmapType::BITMAP_TYPE_XPM
+  elsif Wx::PLATFORM == 'WXOSX'
+    ICON_DEFAULT_TYPE = BitmapType::BITMAP_TYPE_ICO
+  else
+    ICON_DEFAULT_TYPE = BitmapType::BITMAP_TYPE_XPM
   end
 
-  # Create a new bitmap from an icon
-  def self.from_icon(icon)
-    bmp = self.new
-    bmp.copy_from_icon(icon)
-    bmp
+  if Wx::PLATFORM == 'WXMSW'
+    BITMAP_DEFAULT_TYPE = BitmapType::BITMAP_TYPE_BMP
+  elsif Wx::PLATFORM == 'WXGTK'
+    BITMAP_DEFAULT_TYPE = BitmapType::BITMAP_TYPE_XPM
+  elsif Wx::PLATFORM == 'WXOSX'
+    BITMAP_DEFAULT_TYPE = BitmapType::BITMAP_TYPE_PICT
+  else
+    BITMAP_DEFAULT_TYPE = BitmapType::BITMAP_TYPE_XPM
   end
 
-  # Ruby methods that switch class are conventionally named to_foo
-  alias :to_image :convert_to_image
+  if Wx::PLATFORM == 'WXMSW'
+    CURSOR_DEFAULT_TYPE = BitmapType::BITMAP_TYPE_CUR
+  else
+    CURSOR_DEFAULT_TYPE = BitmapType::BITMAP_TYPE_INVALID # not supported
+  end
 
-  # Redefine the initialize method so it raises an exception if a
-  # non-existent file is given to the constructor; otherwise, wx Widgets
-  # just carries on with an empty bitmap, which may cause faults
-  # later. Also, be helpful and try to guess the bitmap type from the
-  # filename if it's not specified
-  wx_init = self.instance_method(:initialize)
-  define_method(:initialize) do | *args |
-    # If creating from a file, check it exists
-    if args[0].kind_of? String
-      if not File.exist?( File.expand_path(args[0]) )
-        Kernel.raise(ArgumentError, "Bitmap file does not exist: #{args[0]}")
-      end
-      # If type not specified, try to guess it from the file extension
-      if not args[1] and file_ext = args[0][/\w+$/]
-        args[1] = BITMAP_TYPE_GUESS[file_ext.downcase]
+  class Bitmap
+    # Allow wxRuby to guess the type of an image file from its extension.
+    BITMAP_TYPE_GUESS = {
+      'bmp'  => Wx::BitmapType::BITMAP_TYPE_BMP,
+      'gif'  => Wx::BitmapType::BITMAP_TYPE_GIF,
+      'ico'  => Wx::BitmapType::BITMAP_TYPE_ICO,
+      'jpeg' => Wx::BitmapType::BITMAP_TYPE_JPEG,
+      'jpg'  => Wx::BitmapType::BITMAP_TYPE_JPEG,
+      'pbm'  => Wx::BitmapType::BITMAP_TYPE_PNM,
+      'pcx'  => Wx::BitmapType::BITMAP_TYPE_PCX,
+      'pgm'  => Wx::BitmapType::BITMAP_TYPE_PNM,
+      'png'  => Wx::BitmapType::BITMAP_TYPE_PNG,
+      'pnm'  => Wx::BitmapType::BITMAP_TYPE_PNM,
+      'ppm'  => Wx::BitmapType::BITMAP_TYPE_PNM,
+      'tga'  => Wx::BitmapType::BITMAP_TYPE_TGA,
+      'tif'  => Wx::BitmapType::BITMAP_TYPE_TIF,
+      'tiff' => Wx::BitmapType::BITMAP_TYPE_TIF,
+      'xbm'  => Wx::BitmapType::BITMAP_TYPE_XBM,
+      'xpm'  => Wx::BitmapType::BITMAP_TYPE_XPM
+    }
+
+    # Constructor copying data from an image
+    def self.from_image(img, depth = -1)
+      new(img, depth)
+    end
+
+    # Create a new bitmap from an icon
+    def self.from_icon(icon)
+      bmp = self.new
+      bmp.copy_from_icon(icon)
+      bmp
+    end
+
+    # Ruby methods that switch class are conventionally named to_foo
+    alias :to_image :convert_to_image
+
+    # Redefine the initialize method so it raises an exception if a
+    # non-existent file is given to the constructor; otherwise, wx Widgets
+    # just carries on with an empty bitmap, which may cause faults
+    # later. Also, be helpful and try to guess the bitmap type from the
+    # filename if it's not specified
+    wx_init = self.instance_method(:initialize)
+    define_method(:initialize) do | *args |
+      # If creating from a file, check it exists
+      if args[0].kind_of? String
+        if not File.exist?( File.expand_path(args[0]) )
+          Kernel.raise(ArgumentError, "Bitmap file does not exist: #{args[0]}")
+        end
+        # If type not specified, try to guess it from the file extension
+        if not args[1] and file_ext = args[0][/\w+$/]
+          args[1] = BITMAP_TYPE_GUESS[file_ext.downcase]
+        end
       end
+      wx_init.bind(self).call(*args)
+    end
+
+    # Accepts a block, which will be passed a device context which can be
+    # used to draw upon the Bitmap
+    def draw
+      dc = Wx::MemoryDC.new
+      dc.select_object(self)
+      yield dc
+      dc.select_object( Wx::NULL_BITMAP )
     end
-    wx_init.bind(self).call(*args)
   end
 
-  # Accepts a block, which will be passed a device context which can be
-  # used to draw upon the Bitmap
-  def draw
-    dc = Wx::MemoryDC.new
-    dc.select_object(self)
-    yield dc
-    dc.select_object( Wx::NULL_BITMAP )
+  def self.Bitmap(name, bmp_type = nil)
+    art_path = File.dirname(caller_path = caller_locations(1).first.absolute_path)
+    art_owner = File.basename(caller_path, '.*')
+    art_file = ArtLocator.find_art(name, art_type: :bitmap, art_path: art_path, art_section: art_owner, bmp_type: bmp_type)
+    ::Kernel.raise ArgumentError, "Cannot locate art file for #{name}:Bitmap" unless art_file
+    Bitmap.new(art_file, bmp_type)
   end
 end

data/lib/wx/core/cursor.rb

@@ -0,0 +1,12 @@
+
+module Wx
+
+  def self.Cursor(name, bmp_type = nil, *rest)
+    art_path = File.dirname(caller_path = caller_locations(1).first.absolute_path)
+    art_owner = File.basename(caller_path, '.*')
+    art_file = ArtLocator.find_art(name, art_type: :icon, art_path: art_path, art_section: art_owner, bmp_type: bmp_type)
+    ::Kernel.raise ArgumentError, "Cannot locate art file for #{name}:Cursor" unless art_file
+    Cursor.new(art_file, bmp_type || Wx::Bitmap::BITMAP_TYPE_GUESS[File.extname(art_file).sub(/\A\./,'')], *rest)
+  end
+
+end

data/lib/wx/core/data_object.rb

@@ -1,10 +1,78 @@
-# Provide some default implementations of these to make life easier
-class Wx::DataObject
-  def get_preferred_format(direction)
-    get_all_formats(direction).first
+
+module Wx
+
+  # Provide some default implementations of these to make life easier
+  class DataObject
+    def get_preferred_format(direction)
+      get_all_formats(direction).first
+    end
+
+    def get_format_count(direction)
+      get_all_formats(direction).size
+    end
   end
 
-  def get_format_count(direction)
-    get_all_formats(direction).size
+  class DataObjectSimple
+
+    # implement the overloads which do not require the format arg
+    # using pure Ruby
+
+    wx_get_data_size = instance_method :get_data_size
+    define_method :get_data_size do |format = nil|
+      wx_get_data_size.bind(self).call(format || self.get_format)
+    end
+
+    wx_get_data_here = instance_method :get_data_here
+    define_method :get_data_here do |format = nil|
+      wx_get_data_here.bind(self).call(format || self.get_format)
+    end
+
+    wx_set_data = instance_method :set_data
+    define_method :set_data do |*args|
+      if args.size>1
+        format, buf = args
+      else
+        format = nil
+        buf = args.first
+      end
+      wx_set_data.bind(self).call(format || self.get_format, buf)
+    end
+
   end
+
+  class DataObjectSimpleBase
+
+    # implement these in pure Ruby for optimization
+    def get_data_size(*)
+      self._get_data_size
+    end
+    def get_data_here(*)
+      self._get_data
+    end
+
+    def set_data(*args)
+      if args.size>1
+        _, buf = args
+      else
+        buf = args.first
+      end
+      self._set_data(buf)
+    end
+
+    def _get_data_size
+      (_get_data || '').bytesize
+    end
+    protected :_get_data_size
+
+  end
+
+  class TextDataObject
+
+    # override this to loose the extra terminating 0 we otherwise get
+    def get_data_here(*)
+      self.get_text
+    end
+
+  end
+
 end

data/lib/wx/core/dataformat.rb

@@ -22,5 +22,7 @@ module Wx
   end
   DF_FILENAME    = DataFormat.new( Wx::DataFormatId::DF_FILENAME )
   DF_UNICODETEXT = DataFormat.new( Wx::DataFormatId::DF_UNICODETEXT )
-  # DF_HTML is only supported on Windows + MSVC, so don't offer it
+  if Wx.has_feature?(:USE_HTML) && Wx::WXWIDGETS_VERSION >= '3.3'
+    DF_HTML        = DataFormat.new( Wx::DataFormatId::DF_HTML )
+  end
 end

data/lib/wx/core/dc.rb

@@ -1,68 +1,92 @@
-# Class for drawing primitives and bitmaps on various outputs (screen, paper)
-class Wx::DC
-  # provide Ruby-style convenience methods supporting wxDCxxxChanger-like functionality
 
-  def with_brush(brush)
-    begin
-      old_brush = self.brush
-      self.brush = brush
-      yield(self) if block_given?
-    ensure
-      self.brush = old_brush
+module Wx
+  # Class for drawing primitives and bitmaps on various outputs (screen, paper)
+  class DC
+    # provide Ruby-style convenience methods supporting wxDCxxxChanger-like functionality
+
+    def with_brush(brush)
+      begin
+        old_brush = self.brush
+        self.brush = brush
+        yield(self) if block_given?
+      ensure
+        self.brush = old_brush
+      end
     end
-  end
 
-  def with_pen(pen)
-    begin
-      old_pen = self.pen
-      self.pen = pen
-      yield(self) if block_given?
-    ensure
-      self.pen = old_pen
+    def with_pen(pen)
+      begin
+        old_pen = self.pen
+        self.pen = pen
+        yield(self) if block_given?
+      ensure
+        self.pen = old_pen
+      end
     end
-  end
 
-  def with_font(font)
-    begin
-      old_font = self.font
-      self.font = font
-      yield(self) if block_given?
-    ensure
-      self.font = old_font
+    def with_font(font)
+      begin
+        old_font = self.font
+        self.font = font
+        yield(self) if block_given?
+      ensure
+        self.font = old_font
+      end
     end
-  end
 
-  def with_text_foreground(clr)
-    begin
-      old = self.get_text_foreground
-      self.text_foreground = clr
-      yield(self) if block_given?
-    ensure
-      self.text_foreground = old
+    def with_text_foreground(clr)
+      begin
+        old = self.get_text_foreground
+        self.text_foreground = clr
+        yield(self) if block_given?
+      ensure
+        self.text_foreground = old
+      end
     end
-  end
-  alias :with_text_fg :with_text_foreground
+    alias :with_text_fg :with_text_foreground
 
-  def with_text_background(clr)
-    begin
-      old = self.get_text_background
-      self.text_background = clr
-      yield(self) if block_given?
-    ensure
-      self.text_background = old
+    def with_text_background(clr)
+      begin
+        old = self.get_text_background
+        self.text_background = clr
+        yield(self) if block_given?
+      ensure
+        self.text_background = old
+      end
     end
+    alias :with_text_bg :with_text_background
+
+    def with_background_mode(mode)
+      begin
+        old = self.get_background_mode
+        self.background_mode = mode
+        yield(self) if block_given?
+      ensure
+        self.background_mode = old
+      end
+    end
+    alias :with_bg_mode :with_background_mode
+
   end
-  alias :with_text_bg :with_text_background
 
-  def with_background_mode(mode)
-    begin
-      old = self.get_background_mode
-      self.background_mode = mode
-      yield(self) if block_given?
-    ensure
-      self.background_mode = old
+  class MemoryDC
+
+    # convenience method for drawing on a temporary memory DC
+    def self.draw_on(arg)
+      dc = case arg
+           when Wx::Bitmap, Wx::DC
+             self.new(arg)
+           else
+             ::Kernel.raise ArgumentError, 'Expected Wx::Bitmap or Wx::DC'
+           end
+      begin
+        yield(dc) if block_given?
+      ensure
+        dc.select_object(Wx::NULL_BITMAP)
+      end
+      nil
     end
+
   end
-  alias :with_bg_mode :with_background_mode
 
 end

data/lib/wx/core/enum.rb

@@ -25,4 +25,8 @@ class Wx::Enum
     self.to_i == 0
   end
 
+  def hash
+    @value.hash
+  end
+
 end

data/lib/wx/core/event.rb

@@ -1,10 +1,43 @@
-# Base class for all events
-class Wx::Event
-  # Get the Wx id, not Ruby's deprecated Object#id
-  alias :id :get_id
-end
+
+require_relative './evthandler'
 
 module Wx
+
+  # Base class for all events
+  class Event
+
+    # overload the #initialize method to add a check on a
+    # correct match between EventType and event class
+    wx_init = self.instance_method(:initialize)
+    define_method :initialize do |evt_type = Wx::EVT_NULL, *rest|
+      evt_klass = Wx::EvtHandler.event_class_for_type(evt_type)
+      if evt_klass >= self.class
+        wx_init.bind(self).call(evt_type, *rest)
+      else
+        ::Kernel.raise ArgumentError, "Invalid event type #{Wx::EvtHandler.event_name_for_type(evt_type)}:#{evt_type} for class #{self.class}"
+      end
+    end
+
+    # Get the Wx id, not Ruby's deprecated Object#id
+    alias :id :get_id
+  end
+
+  class Wx::CommandEvent
+
+    # overload the #initialize method to add a check on a
+    # correct match between EventType and event class
+    wx_init = self.instance_method(:initialize)
+    define_method :initialize do |evt_type = Wx::EVT_NULL, *rest|
+      evt_klass = Wx::EvtHandler.event_class_for_type(evt_type)
+      if evt_klass >= self.class
+        wx_init.bind(self).call(evt_type, *rest)
+      else
+        ::Kernel.raise ArgumentError, "Invalid event type #{Wx::EvtHandler.event_name_for_type(evt_type)}:#{evt_type} for class #{self.class}"
+      end
+    end
+
+  end
+
   # reduce mapping warnings for this unpublished event class
   NcPaintEvent = Wx::Event
 

data/lib/wx/core/evthandler.rb

@@ -195,32 +195,73 @@ class Wx::EvtHandler
   end
 
   # Convenience evt_handler to listen to all mouse events.
-  def evt_mouse_events(&block)
-    evt_left_down(&block)
-    evt_left_up(&block)
-    evt_middle_down(&block)
-    evt_middle_up(&block)
-    evt_right_down(&block)
-    evt_right_up(&block)
-    evt_motion(&block)
-    evt_left_dclick(&block)
-    evt_middle_dclick(&block)
-    evt_right_dclick(&block)
-    evt_leave_window(&block)
-    evt_enter_window(&block)
-    evt_mousewheel(&block)
+  def evt_mouse_events(*args, &block)
+    evt_left_down(*args, &block)
+    evt_left_up(*args, &block)
+    evt_middle_down(*args, &block)
+    evt_middle_up(*args, &block)
+    evt_right_down(*args, &block)
+    evt_right_up(*args, &block)
+    evt_motion(*args, &block)
+    evt_left_dclick(*args, &block)
+    evt_middle_dclick(*args, &block)
+    evt_right_dclick(*args, &block)
+    evt_leave_window(*args, &block)
+    evt_enter_window(*args, &block)
+    evt_mousewheel(*args, &block)
   end
 
   # Convenience evt handler to listen to all scrollwin events.
-  def evt_scrollwin(&block)
-    evt_scrollwin_top(&block)
-    evt_scrollwin_bottom(&block)
-    evt_scrollwin_lineup(&block)
-    evt_scrollwin_linedown(&block)
-    evt_scrollwin_pageup(&block)
-    evt_scrollwin_pagedown(&block)
-    evt_scrollwin_thumbtrack(&block)
-    evt_scrollwin_thumbrelease(&block)
+  def evt_scrollwin(meth = nil, &block)
+    evt_scrollwin_top(meth, &block)
+    evt_scrollwin_bottom(meth, &block)
+    evt_scrollwin_lineup(meth, &block)
+    evt_scrollwin_linedown(meth, &block)
+    evt_scrollwin_pageup(meth, &block)
+    evt_scrollwin_pagedown(meth, &block)
+    evt_scrollwin_thumbtrack(meth, &block)
+    evt_scrollwin_thumbrelease(meth, &block)
+  end
+
+  # Convenience evt handler to listen to all scroll events (Wx::Slider and Wx::ScrollBar)
+  def evt_scroll(meth = nil, &block)
+    evt_scroll_top(meth, &block)
+    evt_scroll_bottom(meth, &block)
+    evt_scroll_lineup(meth, &block)
+    evt_scroll_linedown(meth, &block)
+    evt_scroll_pageup(meth, &block)
+    evt_scroll_pagedown(meth, &block)
+    evt_scroll_thumbtrack(meth, &block)
+    evt_scroll_thumbrelease(meth, &block)
+    evt_scroll_changed(meth, &block)
+  end
+
+  # Convenience evt handler to listen to all scroll command events.
+  def evt_command_scroll(id, meth = nil, &block)
+    evt_command_scroll_top(id, meth, &block)
+    evt_command_scroll_bottom(id, meth, &block)
+    evt_command_scroll_lineup(id, meth, &block)
+    evt_command_scroll_linedown(id, meth, &block)
+    evt_command_scroll_pageup(id, meth, &block)
+    evt_command_scroll_pagedown(id, meth, &block)
+    evt_command_scroll_thumbtrack(id, meth, &block)
+    evt_command_scroll_thumbrelease(id, meth, &block)
+    evt_command_scroll_changed(id, meth, &block)
+  end
+
+  # add missing constants (these are redefinitions of other constants which are not documented themselves)
+  %i[EVT_COMMAND_SCROLL_TOP
+     EVT_COMMAND_SCROLL_BOTTOM
+     EVT_COMMAND_SCROLL_LINEUP
+     EVT_COMMAND_SCROLL_LINEDOWN
+     EVT_COMMAND_SCROLL_PAGEUP
+     EVT_COMMAND_SCROLL_PAGEDOWN
+     EVT_COMMAND_SCROLL_THUMBTRACK
+     EVT_COMMAND_SCROLL_THUMBRELEASE
+     EVT_COMMAND_SCROLL_CHANGED].each do |const|
+    unless Wx.const_defined?(const)
+      Wx.const_set(const, Wx.const_get(const.to_s.sub('EVT_COMMAND_', 'EVT_').to_sym))
+    end
   end
 
   if Wx.const_defined?(:EVT_DESTROY)

data/lib/wx/core/icon.rb

@@ -1,46 +1,61 @@
 # Specific type of platform-dependent image used for frames on Windows and
 # Linux. Normally Bitmap is used
-class Wx::Icon
-  # Load the type-guessing hash from Wx::Bitmap
-  require 'wx/core/bitmap'
-  BITMAP_TYPE_GUESS = Wx::Bitmap::BITMAP_TYPE_GUESS
-
-  # Analogous to Image.from_bitmap
-  def self.from_bitmap(bmp)
-    ico = new
-    ico.copy_from_bitmap(bmp)
-    ico
-  end
 
-  def to_bitmap
-    # for WXMSW platform Icon is not derived from Bitmap
-    return self unless Wx::PLATFORM == 'WXMSW' || Wx::PLATFORM == 'WXOSX'
-    bm = Wx::Bitmap.new
-    bm.copy_from_icon(self)
-    bm
-  end
+require_relative './art_locator'
+
+module Wx
 
-  if Wx::PLATFORM == 'WXMSW' || Wx::PLATFORM == 'WXOSX'
-    def convert_to_image
-      to_bitmap.convert_to_image
+  class Icon
+    # Load the type-guessing hash from Wx::Bitmap
+    require 'wx/core/bitmap'
+    BITMAP_TYPE_GUESS = Wx::Bitmap::BITMAP_TYPE_GUESS
+
+    # Analogous to Image.from_bitmap
+    def self.from_bitmap(bmp)
+      ico = new
+      ico.copy_from_bitmap(bmp)
+      ico
+    end
+
+    def to_bitmap
+      # for WXMSW platform Icon is not derived from Bitmap
+      return self unless Wx::PLATFORM == 'WXMSW' || Wx::PLATFORM == 'WXOSX'
+      bm = Wx::Bitmap.new
+      bm.copy_from_icon(self)
+      bm
     end
-  end
 
-  # Redefine the initialize method so it raises an exception if a
-  # non-existent file is given to the constructor; otherwise, wx Widgets
-  # just carries on with an empty icon, which may cause faults
-  # later. Also guess icon type from filename, if not specified.
-  wx_init = self.instance_method(:initialize)
-  define_method(:initialize) do | *args |
-    if args[0].kind_of? String
-      if not File.exist?( File.expand_path(args[0]) )
-        Kernel.raise(ArgumentError, "Icon file does not exist: #{args[0]}")
+    if Wx::PLATFORM == 'WXMSW' || Wx::PLATFORM == 'WXOSX'
+      def convert_to_image
+        to_bitmap.convert_to_image
       end
-      # If type not specified, try to guess it from the file extension
-      if not args[1] and ( file_ext = args[0][/\w+$/] )
-        args[1] = BITMAP_TYPE_GUESS[file_ext.downcase]
+    end
+
+    # Redefine the initialize method so it raises an exception if a
+    # non-existent file is given to the constructor; otherwise, wx Widgets
+    # just carries on with an empty icon, which may cause faults
+    # later. Also guess icon type from filename, if not specified.
+    wx_init = self.instance_method(:initialize)
+    define_method(:initialize) do | *args |
+      if args[0].kind_of? String
+        if not File.exist?( File.expand_path(args[0]) )
+          Kernel.raise(ArgumentError, "Icon file does not exist: #{args[0]}")
+        end
+        # If type not specified, try to guess it from the file extension
+        if not args[1] and ( file_ext = args[0][/\w+$/] )
+          args[1] = BITMAP_TYPE_GUESS[file_ext.downcase]
+        end
       end
+      wx_init.bind(self).call(*args)
     end
-    wx_init.bind(self).call(*args)
   end
+
+  def self.Icon(name, bmp_type = nil, *rest)
+    art_path = File.dirname(caller_path = caller_locations(1).first.absolute_path)
+    art_owner = File.basename(caller_path, '.*')
+    art_file = ArtLocator.find_art(name, art_type: :icon, art_path: art_path, art_section: art_owner, bmp_type: bmp_type)
+    ::Kernel.raise ArgumentError, "Cannot locate art file for #{name}:Icon" unless art_file
+    Icon.new(art_file, bmp_type, *rest)
+  end
+
 end