wxruby3 0.9.0.pre.beta.10 → 0.9.0.pre.beta.11

data/lib/wx/core/real_point.rb

@@ -1,4 +1,7 @@
 class Wx::RealPoint
+
+  include Comparable
+
   # More informative output when converted to string
   def to_s
     "#<Wx::RealPoint: (#{x}, #{y})>"
@@ -16,23 +19,26 @@ class Wx::RealPoint
   alias :get_x :x
   alias :get_y :y
 
-  # Compare point values
-  def ==(other)
-    if Wx::RealPoint === other
+  # Correct comparison for RealPoints - same if same x and y
+  def eql?(other)
+    if other.instance_of?(self.class)
       x == other.x and y == other.y
-    elsif Array === other && other.size == 2
-      to_ary == other
     else
-      Kernel.raise TypeError, "Cannot compare RealPoint to #{other}"
+      false
     end
   end
 
-  # Correct comparison for RealPoints - same if same x and y
-  def eql?(other)
+  def hash
+    to_ary.hash
+  end
+
+  def <=>(other)
     if Wx::RealPoint === other
-      x == other.x and y == other.y
+      (x*y) <=> (other.x*other.y)
+    elsif Array === other && other.size == 2
+      (x*y) <=> (other.first.to_f*other.last.to_f)
     else
-      false
+      nil
     end
   end
 
@@ -89,4 +95,9 @@ class Wx::RealPoint
       end
     end
   end
+
+
+  def to_point
+    Wx::Point.new(self.x.to_i, self.y.to_i)
+  end
 end

data/lib/wx/core/rect.rb

@@ -23,12 +23,12 @@ class Wx::Rect
     elsif Array === other && other.size == 4
       to_ary == other
     else
-      Kernel.raise TypeError, "Cannot compare Rect to #{other}"
+      false
     end
   end
 
   def eql?(other)
-    if Wx::Rect === other
+    if other.instance_of?(self.class)
       left == other.left and top == other.top and
         width == other.width and height == other.height
     else

data/lib/wx/core/size.rb

@@ -1,4 +1,7 @@
 class Wx::Size
+
+  include Comparable
+
   # More informative output for inspect etc
   def to_s
     "#<Wx::Size: #{width}x#{height}>"
@@ -14,24 +17,28 @@ class Wx::Size
   end
 
   # Compare with another size value
-  def ==(other)
+  def <=>(other)
     if Wx::Size === other
-      width == other.width and height == other.height
+      (width*height) <=> (other.width*other.height)
     elsif Array === other and other.size == 2
-      to_ary == other
+      (width*height) <=> (other.first*other.last)
     else
-      Kernel.raise TypeError, "Cannot compare Size to #{other}"
+      nil
     end
   end
 
   def eql?(other)
-    if Wx::Size === other
+    if other.instance_of?(self.class)
       width == other.width and height == other.height
     else
       false
     end
   end
 
+  def hash
+    to_ary.hash
+  end
+
   # Return a new Wx::Size with the width and height values both divided
   # by parameter +num+, which should be a Numeric
   def /(num)

data/lib/wx/doc/data_object.rb

@@ -0,0 +1,104 @@
+
+module Wx
+
+  class DataObject
+
+    # Returns the data size of the given format.
+    # Should be overridden in derived classes.
+    # @note **IMPORTANT** Please note that it is necessary to return the **size in bytes** of the data string
+    # returned by #get_data_here (not the size in characters).
+    # @param format [Wx::DataFormat]
+    # @return [Integer]
+    def get_data_size(format) end
+    alias_method :data_size, :get_data_size
+
+  end
+
+  # This is an (abstract in Ruby) base class for the simplest possible custom data objects.
+  # Unlike in C++ in Ruby this class cannot be used to derive custom data objects from but
+  # instead {Wx::DataObjectSimpleBase} (derived from Wx::DataObjectSimple) should be used.
+  # The data object of (a class derived from) this class only supports <b>one format</b>,
+  # so the number of virtual functions to be implemented is reduced.
+  # This class is the base class for {Wx::TextDataObject}, {Wx::FileDataObject}, {Wx::BitmapDataObject},
+  # {Wx::wxCustomDataObject} and others.
+  # ===
+  #
+  # Category:  Clipboard and Drag & Drop
+  # @see Drag and Drop Overview
+  # @see  Drag & Drop Sample
+  class DataObjectSimple < DataObject
+
+    # @overload get_data_size(format)
+    #   Returns the data size of the format for this object.
+    #   @param [Wx::DataFormat] format ignored for this class
+    #   @return [Integer] default always returns 0
+    # @overload get_data_size()
+    #   Returns the data size of the format for this object.
+    #   @return [Integer] default always returns 0
+    def get_data_size(*) end
+
+    # @overload get_data_here(format)
+    #   Returns the data of this object.
+    #   @param [Wx::DataFormat] format ignored for this class
+    #   @return [String,nil] data of this object
+    # @overload get_data_here()
+    #   Returns the data of this object.
+    #   @return [String,nil] data of this object
+    def get_data_here(*) end
+
+    # @overload set_data(format, buf)
+    #   Sets the data for this object and returns true if successful, false otherwise.
+    #   @param [Wx::DataFormat] format ignored for this class
+    #   @param [String] buf non-nil data
+    #   @return [Boolean] default always returns false.
+    # @overload set_data(buf)
+    #   Sets the data for this object and returns true if successful, false otherwise.
+    #   @param [String] buf non-nil data
+    #   @return [Boolean] default always returns false.
+    def set_data(*) end
+
+  end
+
+  # This is the base class for the simplest possible custom data objects.
+  # The data object of (a class derived from) this class only supports <b>one format</b>,
+  # so the number of methods to be implemented is reduced.
+  # To be useful it must be derived. Derived objects supporting rendering the data must
+  # override {Wx::DataObjectSimpleBase#_get_data_size} and {Wx::DataObjectSimpleBase#_get_data}.
+  # By default these methods respectively return <code>0</code> and <code>nil</code>.
+  # The objects which may be set must override {Wx::DataObjectSimpleBase#_set_data} (which
+  # returns <code>false</code>).
+  # Of course, the objects supporting both operations must override all three methods.
+  # ===
+  #
+  # Category:  Clipboard and Drag & Drop
+  # @see Drag and Drop Overview
+  # @see  Drag & Drop Sample
+  # @see  Wx::DataObjectSimple
+  class DataObjectSimpleBase < DataObjectSimple
+
+    # Returns this object's data size.
+    # The default implementation calls #_get_data and determines the size of the returned data string (if any).
+    # As this is not very optimal for more complex (and larger data objects) very often this method will be
+    # overridden in derived classes.
+    # @note **IMPORTANT** Please note that it is necessary to return the **size in bytes** of the data string
+    # returned by #_get_data (not the size in characters).
+    # @return [Integer]
+    def _get_data_size; end
+    protected :_get_data_size
+
+    # Returns this object's data (default implementation returns nil).
+    # Should be overridden in derived classes.
+    # @return [String,nil]
+    def _get_data; end
+    protected :_get_data
+
+    # Sets this object's data (default implementation does nothing and returns false).
+    # Should be overridden in derived classes.
+    # @param [String] buf non-nil data
+    # @return [Boolean]
+    def _set_data(buf); end
+    protected :_set_data
+
+  end
+
+end

data/lib/wx/doc/gdi_common.rb

@@ -56,20 +56,27 @@ module Wx
 
   class Point
 
+    include Comparable
+
     # Returns point array (`[x, y]`)
     # @return [Array(Integer,Integer)] point as array
     def to_ary; end
 
-    # Compare point values (Wx::Point or point array). Throws exception if incompatible.
+    # Compare point values (Wx::Point or point array). Returns -1,0 or 1 to indicate if this point
+    # is smaller, equal or greater than other (comparing <code>x*y</code> with <code>other.x*other.y</code>).
+    # Returns nil if incompatible.
     # @param [Wx::Point,Array(Integer,Integer)] other
-    # @return [Boolean]
-    def ==(other)end
+    # @return [Boolean,nil]
+    def <=>(other)end
 
     # Compare points.
     # @param [Wx::Point] other
     # @return [Boolean]
     def eql?(other)end
 
+    # Returns hash for point
+    def hash; end
+
     # Return a new Wx::Point with the x and y parameters both divided by
     # parameter +num+, which should be a Numeric
     # @param [Numeric] num
@@ -97,11 +104,18 @@ module Wx
     # @param [Wx::Point,Wx::Size,Array(Integer,Integer),Numeric] arg
     # @return [Wx::Point]
     def +(arg) end
-    
+
+    # Converts point to Wx::RealPoint
+    # @return [Wx::RealPoint] Wx::RealPoint instance from point coordinates
+    def to_real_point; end
+    alias :to_real :to_real_point
+
   end
 
   class RealPoint
 
+    include Comparable
+
     # Returns point array (`[x, y]`)
     # @return [Array(Float,Float)] point as array
     def to_ary; end
@@ -111,11 +125,21 @@ module Wx
     # @return [Boolean]
     def ==(other)end
 
+    # Compare point values (Wx::RealPoint or point array). Returns -1,0 or 1 to indicate if this point
+    # is smaller, equal or greater than other (comparing <code>x*y</code> with <code>other.x*other.y</code>).
+    # Returns nil if incompatible.
+    # @param [Wx::RealPoint,Array(Float,Float)] other
+    # @return [Boolean,nil]
+    def <=>(other)end
+
     # Compare points.
     # @param [Wx::RealPoint] other
     # @return [Boolean]
     def eql?(other)end
 
+    # Returns hash for point
+    def hash; end
+
     # Return a new Wx::RealPoint with the x and y parameters both divided by
     # parameter +num+, which should be a Numeric
     # @param [Numeric] num
@@ -144,6 +168,10 @@ module Wx
     # @return [Wx::RealPoint]
     def +(arg) end
 
+    # Converts real point to Wx::Point
+    # @return [Wx::Point] Wx::Point instance from real point coordinates
+    def to_point; end
+
   end
 
   class Rect
@@ -152,7 +180,7 @@ module Wx
     # @return [Array(Integer,Integer,Integer,Integer)] rect as array
     def to_ary; end
 
-    # Compare area values (Wx::Rect or 4-element array). Throws exception if incompatible.
+    # Compare area values (Wx::Rect or 4-element array). Returns false if incompatible.
     # @param [Wx::Rect,Array(Integer,Integer,Integer,Integer)] other
     # @return [Boolean]
     def ==(other)end

data/lib/wx/doc/scaled_dc.rb

@@ -0,0 +1,16 @@
+
+class Wx
+
+  class ScaledDC < Wx::DC
+
+    private :initialize
+
+    # Creates a Wx::ScaledDC instance for target and scale and
+    # passes the instance to the given block to draw on.
+    # @param [Wx::DC] target DC to draw on (scaled)
+    # @param [Float] scale scale factor
+    # @yieldparam [Wx::ScaledDC] dc scaled dc to draw on
+    def self.draw_on(target, scale) end
+  end
+
+end

data/lib/wx/global_const.rb

@@ -4,7 +4,7 @@
 module WxGlobalConstants
 
   class << self
-    def search_nested(mod, sym)
+    def search_nested(mod, sym, path = [])
       # check any nested modules and/or (enum) classes
       const_val = nil
       mod.constants.each do |c|
@@ -16,11 +16,12 @@ module WxGlobalConstants
           elsif cv.name.start_with?('Wx::') # only search Wx namespace
             # prevent const_missing being triggered here since that may lead to unexpected results
             const_val = cv.const_get(sym) if cv.constants.include?(sym)
-            const_val = search_nested(cv, sym) unless const_val
+            const_val = search_nested(cv, sym, path+[mod]) unless const_val || path.include?(cv)
           end
         when ::Module
           if cv.name.start_with?('Wx::') # only search Wx namespace
-            const_val = cv.const_get(sym) rescue nil
+            const_val = cv.const_get(sym)  if cv.constants.include?(sym)
+            const_val = search_nested(cv, sym, path+[mod]) unless const_val || path.include?(cv)
           end
         end unless mod == cv # watch out for infinite recursion
         break if const_val

data/lib/wx/version.rb

@@ -1,3 +1,3 @@
 module Wx
-  WXRUBY_VERSION    = '0.9.0-beta.10'
+  WXRUBY_VERSION    = '0.9.0-beta.11'
 end

data/rakelib/lib/core/package.rb

@@ -208,7 +208,7 @@ module WXRuby3
         # next initialize all modules without classes (keeping only those with classes)
         inc_dirs.select! do |dir|
           modreg = Spec.module_registry[dir.spec.module_name]
-          if modreg.nil? || modreg.empty?
+          if !dir.spec.initialize_at_end && (modreg.nil? || modreg.empty?)
             init = "Init_#{dir.spec.module_name}()"
             decls << "extern \"C\" void #{init};"
             init_fn << "  #{init};"
@@ -222,7 +222,7 @@ module WXRuby3
         cls_set = ::Set.new
         inc_dirs.select! do |dir|
           modreg = Spec.module_registry[dir.spec.module_name]
-          if modreg && !modreg.empty? && modreg.values.all? {|base| base.nil? || modreg.has_key?(base) }
+          if !dir.spec.initialize_at_end && modreg && !modreg.empty? && modreg.values.all? {|base| base.nil? || modreg.has_key?(base) }
             cls_set.merge modreg.keys # remember classes
             init = "Init_#{dir.spec.module_name}()"
             decls << "extern \"C\" void #{init};"
@@ -235,7 +235,7 @@ module WXRuby3
 
         # next initialize all modules with classes depending (bases AND mixins) on classes in any modules already
         # selected until there are no more modules left or none that are left depend on any selected ones
-        while dir_inx = inc_dirs.find_index { |dir| is_dir_with_fulfilled_deps?(dir, cls_set) }
+        while dir_inx = inc_dirs.find_index { |dir| !dir.spec.initialize_at_end && is_dir_with_fulfilled_deps?(dir, cls_set) }
           dir = inc_dirs[dir_inx]
           modreg = Spec.module_registry[dir.spec.module_name]
           cls_set.merge modreg.keys # remember classes

data/rakelib/lib/core/spec.rb

@@ -77,6 +77,7 @@ module WXRuby3
         @post_processors = processors || [:rename, :fixmodule, :fix_protected_access]
         @requirements = [requirements].flatten
         @type_maps = Typemap::Collection.new
+        @initialize_at_end = false
       end
 
       attr_reader :director, :package, :module_name, :name, :items, :folded_bases, :ignores, :regards, :readonly, :contracts, :event_overrides,
@@ -85,6 +86,7 @@ module WXRuby3
                   :runtime_code, :header_code, :wrapper_code, :extend_code, :init_code, :interface_code,
                   :nogen_sections, :post_processors, :requirements, :type_maps
       attr_writer :interface_file
+      attr_accessor :initialize_at_end
 
       def interface_file
         @interface_file || File.join(Config.instance.classes_path, @name + '.i')

data/rakelib/lib/director/data_object.rb

@@ -56,9 +56,103 @@ module WXRuby3
         # Once a DataObject has been added, it belongs to the wxDataObjectComposite object,
         # and will be freed by it on destruction.
         spec.disown 'wxDataObjectSimple* dataObject'
+
+        # Add GC management for the DataObjectSimple instances added to a DataObjectComposite instance.
+        spec.add_header_code <<~__HEREDOC
+          #include <vector>
+          #include <map>
+
+          typedef std::vector<VALUE> data_object_list_t;
+          typedef std::map<wxDataObjectComposite*, data_object_list_t> composite_data_object_map_t;
+          static composite_data_object_map_t CompositeDataObject_Map;
+
+          static void wxRuby_markCompositeDataObjects()
+          {
+            composite_data_object_map_t::iterator it;
+            for( it = CompositeDataObject_Map.begin(); it != CompositeDataObject_Map.end(); ++it )
+            {
+              data_object_list_t &do_list = it->second;
+              for (VALUE data_obj : do_list)
+              {
+          #ifdef __WXRB_DEBUG__
+                if (wxRuby_TraceLevel()>1)
+                {
+                  void *c_ptr = (TYPE(data_obj) == T_DATA ? DATA_PTR(data_obj) : 0);
+                  std::wcout << "**** wxRuby_markCompositeDataObjects : " << it->first << "|" << (void*)c_ptr << std::endl;
+                }
+          #endif               
+                rb_gc_mark(data_obj);
+              }
+            }
+          }
+
+          // custom implementation for wxRuby so we can handle de-registering composites
+          class WxRuby_DataObjectComposite : public wxDataObjectComposite
+          {
+          public:
+            WxRuby_DataObjectComposite() : wxDataObjectComposite() {}
+            virtual ~WxRuby_DataObjectComposite()
+            {
+              CompositeDataObject_Map.erase(this);
+            } 
+          };
+          __HEREDOC
+        # install GC marker
+        spec.add_init_code 'wxRuby_AppendMarker(wxRuby_markCompositeDataObjects);'
+        # use custom implementation class
+        spec.use_class_implementation 'wxDataObjectComposite', 'WxRuby_DataObjectComposite'
+
+        # disable generating the default Add method (keep docs)
+        spec.ignore 'wxDataObjectComposite::Add', ignore_doc: false
+        # Add custom Add implementation
+        spec.add_extend_code 'wxDataObjectComposite', <<~__HEREDOC
+          void add(VALUE rb_dataObject, bool preferred=false)
+          {
+            // convert simple object
+            wxDataObjectSimple *simple_do;
+            int res = SWIG_ConvertPtr(rb_dataObject, SWIG_as_voidptrptr(&simple_do), SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_DISOWN);
+            if (!SWIG_IsOK(res)) 
+            {
+              rb_raise(rb_eArgError, "Expected Wx::DataObjectSimple for 1");
+            }
+
+            // add new simple instance to registration for this composite
+            CompositeDataObject_Map[$self].push_back(rb_dataObject);
+
+            // add to composite
+            $self->Add(simple_do);
+          }
+          __HEREDOC
+
       end
     end # class DataObject
 
+    def doc_generator
+      DataObjectDocGenerator.new(self)
+    end
+
   end # class Director
 
+  class DataObjectDocGenerator < DocGenerator
+
+    def get_class_doc(clsdef)
+      if clsdef.name == 'wxDataObjectSimple'
+        []
+      else
+        super
+      end
+    end
+    protected :get_class_doc
+
+    def get_method_doc(mtd)
+      if Extractor::MethodDef === mtd && mtd.class_name == 'wxDataObject' && mtd.name == 'GetDataSize'
+        {}
+      else
+        super
+      end
+    end
+    protected :get_method_doc
+
+  end
+
 end # module WXRuby3

data/rakelib/lib/director/data_object_simple_base.rb

@@ -0,0 +1,123 @@
+###
+# wxRuby3 wxWidgets interface director
+# Copyright (c) M.J.N. Corino, The Netherlands
+###
+
+module WXRuby3
+
+  class Director
+
+    class DataObjectSimpleBase < Director
+
+      include Typemap::DataFormat
+      include Typemap::DataObjectData
+
+      def setup
+        super
+        spec.items.clear
+        # insert literal code as #gc_as_xx does not work without parsed class items
+        spec.add_swig_code 'GC_MANAGE_AS_OBJECT(wxDataObjectSimpleBase);'
+        spec.initialize_at_end = true
+
+        spec.swig_import 'ext/wxruby3/swig/classes/include/wxDataObject.h'
+
+        spec.add_header_code <<~__HEREDOC
+          class wxDataObjectSimpleBase : public wxDataObjectSimple
+          {
+          public:
+            wxDataObjectSimpleBase(const wxDataFormat &format=wxFormatInvalid)
+              : wxDataObjectSimple(format) {}
+            virtual ~wxDataObjectSimpleBase() { }
+          
+            virtual size_t GetDataSize() const { return _GetDataSize(); }
+            virtual size_t GetDataSize(const wxDataFormat &) const { return _GetDataSize(); }
+            virtual bool GetDataHere(const wxDataFormat &, void *buf) const { return _GetData(buf); }
+            virtual bool GetDataHere(void *data_buffer) const { return _GetData(data_buffer); }
+            virtual bool SetData(const wxDataFormat &, size_t len, const void *buf) { return _SetData(len, buf); }
+            virtual bool SetData(size_t len, const void *buf) { return _SetData(len, buf); }
+          
+          protected:
+            virtual size_t _GetDataSize() const { return 0; }
+            virtual bool _GetData(void *data_buffer) const { return false; }
+            virtual bool _SetData(size_t len, const void *buf) { return false; }
+          };
+          __HEREDOC
+
+        spec.add_interface_code <<~__HEREDOC
+          class wxDataObjectSimpleBase : public wxDataObjectSimple
+          {
+          public:
+            wxDataObjectSimpleBase(const wxDataFormat &format=wxFormatInvalid);
+          
+            virtual void GetAllFormats(wxDataFormat *formats, Direction dir=Get) const;
+            virtual size_t GetFormatCount(Direction dir=Get) const;
+            virtual wxDataFormat GetPreferredFormat(Direction dir=Get) const;
+          
+          protected:
+            virtual size_t _GetDataSize() const;
+            %feature("numoutputs", "0") _GetData;
+            virtual VOID_BOOL _GetData(void *data_buffer) const;
+            virtual bool _SetData(size_t len, const void *buf);
+          };
+          __HEREDOC
+
+        # For wxDataObjectSimpleBase::GetDataHere/_GetData : the ruby method should
+        # return either a string containing the
+        # data, or nil if the data cannot be provided for some reason.
+        spec.map 'void *data_buffer' do
+
+          map_in ignore: true, code: ''
+
+          # "misuse" the 'check' typemap to initialize the ignored argument
+          # since this is inserted after any non-ignored arguments have been converted we can use these
+          # here
+          map_check temp: 'std::unique_ptr<char[]> data_buf, size_t data_size', code: <<~__CODE
+            data_size = arg1->GetDataSize();
+            data_buf = std::make_unique<char[]>(data_size);
+            $1 = data_buf.get ();
+          __CODE
+
+          # ignore C defined return value entirely (also affects directorout)
+          map_out ignore: 'bool'
+
+          map_argout as: {type: 'String', index: 1}, code: <<~__CODE
+            if (result)
+            {
+              $result = rb_utf8_str_new( (const char*)data_buf$argnum.get(), data_size$argnum);
+            }
+            else
+              $result = Qnil;
+          __CODE
+
+          # ignore the buffer pointer for now
+          map_directorin code: ''
+
+          map_directorargout code: <<~__CODE
+            if (RTEST(result))
+            {
+              if (TYPE(result) == T_STRING)
+              {
+                memcpy(data_buffer, StringValuePtr(result), RSTRING_LEN(result) );
+                c_result = true;
+              }
+              else
+              {
+                Swig::DirectorTypeMismatchException::raise(rb_eTypeError, 
+                                                           "get_data_here should return a string, or nil on failure");
+              }
+            }
+            else
+              c_result = false;
+          __CODE
+
+        end
+
+        # Once a DataObject has been added, it belongs to the wxDataObjectComposite object,
+        # and will be freed by it on destruction.
+        # spec.disown 'wxDataObjectSimple* dataObject'
+      end
+    end # class DataObject
+
+  end # class Director
+
+end # module WXRuby3

data/rakelib/lib/director/derived_dc.rb

@@ -52,6 +52,44 @@ module WXRuby3
                       'wxSVGFileDC::EndPage'
         elsif spec.module_name == 'wxGCDC'
           spec.ignore 'wxGCDC::wxGCDC(const wxEnhMetaFileDC &)'
+        elsif spec.module_name == 'wxScaledDC'
+          spec.items.clear # wxRuby extension; no XML docs
+          spec.override_inheritance_chain('wxScaledDC', %w[wxDC wxObject])
+          # as there are no dependencies parsed from XML make sure we're initialized after Wx::DC
+          spec.initialize_at_end = true
+          spec.gc_as_temporary 'wxScaledDC'
+          spec.no_proxy 'wxScaledDC'
+          spec.include 'wxruby-ScaledDC.h'
+          # wxScaledDc should ever only be used in a restricted scope
+          # to be destructed directly after use therefor we make it abstract
+          # and provide a class factory method #draw_on with accepts a block.
+          # (as we there no classes defined in XML we cannot use add_extend_code
+          #  so we use a workaround here)
+          spec.add_swig_code <<~__HEREDOC
+            %extend wxScaledDC {
+            static void draw_on(wxDC& target, double scale)
+            {
+              if (rb_block_given_p())
+              {
+                wxScaledDC scaled_dc(target, scale);
+                wxScaledDC* p_scaled_dc = &scaled_dc;                        
+                VALUE rb_scaled_dc = SWIG_NewPointerObj(SWIG_as_voidptr(p_scaled_dc), SWIGTYPE_p_wxScaledDC, 0);
+                rb_yield(rb_scaled_dc);
+              }
+              return ;
+            }
+            };
+            __HEREDOC
+          spec.swig_import %w[ext/wxruby3/swig/classes/include/wxObject.h
+                              ext/wxruby3/swig/classes/include/wxDC.h]
+          spec.add_interface_code <<~__HEREDOC
+            class wxScaledDC : public wxDC
+            {
+            public:
+              wxScaledDC(wxDC& target, double scale);
+              virtual ~wxScaledDC() = 0;
+            };
+            __HEREDOC
         else
           # ctors of all other derived DC require a running App
           spec.require_app spec.module_name