wxruby3 0.9.0.pre.beta.8-x64-mingw-ucrt

data/lib/wx/core/app.rb

@@ -0,0 +1,89 @@
+# Copyright 2004-2006 by Kevin Smith
+# released under the MIT-style wxruby2 license
+
+require_relative './ext'
+
+# Controller class which creates and manages all windows.
+class Wx::App
+
+  # convenience method to retrieve global Wx::App instance
+  def self.the_app
+    if Wx::const_defined?(:THE_APP) and Wx::THE_APP.is_running
+      Wx::THE_APP
+    else
+      nil
+    end
+  end
+
+  # Ruby init callback.
+  # Initializes delayed load constants and than calls the user defined 'on_init'
+  def on_ruby_init
+    Wx.load_delayed_constants
+    self.respond_to?(:on_init) ? self.on_init : false
+  end
+  private :on_ruby_init
+
+  # Make C-ext main_loop method private
+  private :main_loop
+
+  # App instance run method.
+  # Accepts optional 'on_init' block.
+  # The block will be ignored when the (derived) App class
+  # already has an 'on_init' method defined.
+  def run(&block)
+    if block_given?
+      if self.respond_to?(:on_init)
+        Wx.log_warning("'on_init' block ignored as #{self.class.name} already has an #on_init method defined")
+      else
+        self.singleton_class.class_eval do
+          define_method(:on_init, &block)
+        end
+      end
+    end
+    main_loop # run the main loop (which triggers the call to on_init)
+  end
+
+  # Convenience class method to create simple apps. Starts an
+  # application main_loop, setting up initial windows etc as specified
+  # in the passed block.
+  # block 
+  def self.run(&block)
+    if block_given?
+      app_klass = Class.new(self)
+      app_klass.class_eval do
+        define_method(:on_init, &block)
+      end
+    else
+      app_klass = self
+    end
+    app_klass.new.run
+  end
+
+
+  # This is a class method in Wx, but permit it to be an instance method
+  # in wxRuby
+  def is_main_loop_running
+    Wx::App.is_main_loop_running
+  end
+
+  # This method handles failed assertions from within the WxWidgets C++
+  # code. These messages are only generated by a DEBUG build of
+  # WxRuby. Such messages usually indicate that the API is being used
+  # incorrectly; the file/line reference points to the place in the
+  # WxWidgets source code where the assertion was made.
+  define_method(:on_assert_failure) do | file, line, func, condition, message |
+    warn "Wx WARNING: #{message} (#{func}@#{file}:#{line})"
+  end
+
+  # For use in development only, of no practical use in production code.
+  # This method causes Ruby's garbage collection to run (roughly) at
+  # interval +interval+ (seconds) - the default is 1, i.e. every
+  # second. This should help ferret out bugs in memory management more
+  # quickly.
+  def gc_stress(interval = 1)
+    t = Wx::Timer.new(self, 9999)
+    evt_timer(9999) { Thread.pass }
+    Thread.new { loop { sleep interval; GC.start } }
+    t.start(100)
+  end
+end

data/lib/wx/core/artprovider.rb

@@ -0,0 +1,31 @@
+# Class which can supply icons and bitmaps
+class Wx::ArtProvider
+  # Keep a note of supplied ArtProviders to prevent them being GC'd
+  @__art_provs = []
+
+  class << self 
+    wx_push_back = instance_method(:push_back)
+    define_method(:push_back) do | art_prov |
+      wx_push_back.bind(self).call(art_prov)
+      @__art_provs.unshift(art_prov)
+    end
+
+    wx_pop = instance_method(:pop)
+    define_method(:pop) do
+      wx_pop.bind(self).call
+      @__art_provs.pop
+    end
+
+    wx_push = instance_method(:push)
+    define_method(:push) do | art_prov |
+      wx_push.bind(self).call(art_prov)
+      @__art_provs.push(art_prov)
+    end
+
+    wx_delete = instance_method(:delete)
+    define_method(:delete) do | art_prov |
+      wx_push.bind(self).call(art_prov)
+      @__art_provs.delete(art_prov)
+    end
+  end
+end

data/lib/wx/core/bitmap.rb

@@ -0,0 +1,59 @@
+# 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
+  }
+
+  # Constructor copying data from an image
+  def self.from_image(img, depth = -1)
+    new(img, depth)
+  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
+end

data/lib/wx/core/busycursor.rb

@@ -0,0 +1,12 @@
+# Emulates the wxWidgets BusyCursor class, by providing a scope within
+# which a busy cursor will be shown
+class Wx::BusyCursor
+  # Only one class method, optionally accepting a cursor that should be
+  # shown, defaulting to an hour glass cursor.
+  def self.busy(cursor = Wx::HOURGLASS_CURSOR)
+    Wx::begin_busy_cursor(cursor)
+    yield
+  ensure
+    Wx::end_busy_cursor
+  end
+end

data/lib/wx/core/choice.rb

@@ -0,0 +1,4 @@
+class Wx::Choice
+  alias :get_item_data :get_client_data
+  alias :set_item_data :set_client_data
+end

data/lib/wx/core/choicedlg.rb

@@ -0,0 +1,54 @@
+
+module Wx
+
+  # get the user selection as a string
+  def self.get_single_choice(message,
+                             caption,
+                             choices,
+                             parent = nil,
+                             initial_selection: 0,
+                             x:  Wx::DEFAULT_COORD,
+                             y:  Wx::DEFAULT_COORD)
+    dialog = Wx::SingleChoiceDialog.new(parent, message, caption, choices, nil, Wx::CHOICEDLG_STYLE, [x, y])
+
+    dialog.selection = initial_selection
+    return dialog.show_modal == Wx::ID_OK ? dialog.get_string_selection : ''
+  end
+
+  # get the user selection as an index
+  def self.get_single_choice_index(message,
+                                   caption,
+                                   choices,
+                                   parent = nil,
+                                   initial_selection: 0,
+                                   x:  Wx::DEFAULT_COORD,
+                                   y:  Wx::DEFAULT_COORD)
+    dialog = Wx::SingleChoiceDialog.new(parent, message, caption, choices, nil, Wx::CHOICEDLG_STYLE, [x, y])
+
+    dialog.selection = initial_selection
+    return dialog.show_modal == Wx::ID_OK ? dialog.get_selection : -1
+  end
+
+  # return an array with the indices of the chosen items, it will be empty
+  # if no items were selected or Cancel was pressed
+  def self.get_selected_choices(message,
+                                caption,
+                                choices,
+                                parent = nil,
+                                initial_selections: [],
+                                x:  Wx::DEFAULT_COORD,
+                                y:  Wx::DEFAULT_COORD)
+    dialog = Wx::MultiChoiceDialog.new(parent, message, caption, choices, Wx::CHOICEDLG_STYLE, [x, y])
+
+    # call this even if selections array is empty and this then (correctly)
+    # deselects the first item which is selected by default
+    dialog.selections = initial_selections
+
+    if dialog.show_modal != Wx::ID_OK
+      return []
+    end
+
+    dialog.get_selections
+  end
+
+end

data/lib/wx/core/clientdc.rb

@@ -0,0 +1,13 @@
+# Device Context to paint on a window outside an on_paint handler. It is
+# recommended that PaintDC is used in preference to this class.
+class Wx::ClientDC
+  # This class should not be instantiated directly in wxRuby; it should
+  # always be used via Window#paint, which takes a block receiving the
+  # DC. This ensures that the DC is cleaned up at the correct time,
+  # avoiding errors and segfaults on exit.
+  define_method(:initialize) do | *args |
+    Kernel.raise RuntimeError,
+                 "Do not instantiate ClientDC directly; use Window#paint",
+                 caller[1..-1]
+  end
+end

data/lib/wx/core/clipboard.rb

@@ -0,0 +1,56 @@
+class Wx::Clipboard
+  class << self
+    # This is provided internally by the SWIG interface file, but all
+    # public access should be via Clipboard.open; see below
+    private :get_global_clipboard
+
+    # Class method to provide access to the clipboard within a ruby
+    # block. Tests that the clipboard could be accessed, and ensures
+    # that it is closed when the block is finished.
+    def open
+      clip = nil
+      # Trying to access the segfault outside main_loop will segfault on
+      # some platforms (eg, GTK)
+      unless Wx::const_defined?(:THE_APP)
+        raise RuntimeError, 
+              "The clipboard can only be accessed when the App is running"
+      end
+
+      clip = get_global_clipboard
+      unless clip.open
+        Kernel.raise "Could not open clipboard"
+      end
+      yield clip
+     ensure
+       clip.close if clip
+    end
+  end
+
+  # Need to do some internal record-keeping to protect data objects on
+  # the clipboard from garbage collection
+  @@__clip_data = []
+
+  # These methods affect the clipboard contents; each time, update the
+  # record with the changed data contents
+  wx_add_data = instance_method(:add_data)
+  define_method(:add_data) do | the_data |
+    @@__clip_data << the_data
+    wx_add_data.bind(self).call(the_data)
+  end
+
+  wx_clear = instance_method(:clear)
+  define_method(:clear) do 
+    wx_clear.bind(self).call
+    @@__clip_data.clear
+  end
+
+  wx_set_data = instance_method(:set_data)
+  define_method(:set_data) do | the_data |
+    @@__clip_data = [ the_data ]
+    wx_set_data.bind(self).call(the_data)
+  end
+
+  # Aliases, more clearly expressive?
+  alias :place :set_data
+  alias :fetch :get_data
+end

data/lib/wx/core/collapsible_pane.rb

@@ -0,0 +1,12 @@
+# WxRuby Extensions - CollapsiblePane platform dependent alias
+# Copyright (c) M.J.N. Corino, The Netherlands
+
+module Wx
+
+  if Wx.has_feature?(:USE_COLLPANE) && (!Wx.has_feature?(:WXGTK20) || Wx.has_feature?(:WXUNIVERSAL))
+    
+    GenericCollapsiblePane = CollapsiblePane
+    
+  end
+  
+end

data/lib/wx/core/colour.rb

@@ -0,0 +1,34 @@
+class Wx::Colour
+  # Redefine the initialize method so it raises an exception if an
+  # invalid colour value is given. This might be an unknown colour
+  # string (eg 'dark blue') or out-of-bounds integer values (<0 or >255)
+  wx_init = self.instance_method(:initialize)
+  define_method(:initialize) do | *args |
+    begin
+      wx_init.bind(self).call(*args)
+    # Invalid integer values raise SWIG 'no matching func'
+    rescue ArgumentError, TypeError
+      Kernel.raise ArgumentError, "Invalid colour values #{args.inspect}"
+    end
+  end
+
+  # Missing Standard colour
+  Wx::MAGENTA = new(255, 0, 255)
+
+  # Colours are equal to one another if they have the same red, green
+  # and blue intensity, and the same alpha
+  def ==(other)
+    case other
+    when Wx::Colour
+      [  self.red,  self.green,  self.blue,  self.alpha ] == 
+      [ other.red, other.green, other.blue, other.alpha ]
+    else
+      false
+    end
+  end
+
+  # More informative output for inspect etc
+  def to_s
+    "#<Wx::Colour: (#{red}, #{green}, #{blue} *#{alpha})>"
+  end
+end

data/lib/wx/core/combobox.rb

@@ -0,0 +1,4 @@
+class Wx::ComboBox
+  alias :get_item_data :get_client_data
+  alias :set_item_data :set_client_data
+end

data/lib/wx/core/controlwithitems.rb

@@ -0,0 +1,10 @@
+# Superclass of a variety of controls that display lists of items (eg
+# Choice, ListBox, CheckListBox)
+class Wx::ControlWithItems
+  # Make these ruby enumerables so find, find_all, map etc are available 
+  include Enumerable
+  # Passes each valid item index into the passed block
+  def each
+    0.upto(get_count - 1) { | i | yield i }
+  end
+end

data/lib/wx/core/data_object.rb

@@ -0,0 +1,10 @@
+# Provide some default implementations of these to make life easier
+class Wx::DataObject
+  def get_preferred_format(direction)
+    get_all_formats(direction).first
+  end
+
+  def get_format_count(direction)
+    get_all_formats(direction).size
+  end
+end

data/lib/wx/core/dataformat.rb

@@ -0,0 +1,26 @@
+# Make this easier to use for multi-typed data objects. Comparison
+# doesn't work correctly in the SWIG binding
+class Wx::DataFormat
+  def ==(other)
+    if self.get_type > Wx::DataFormatId::DF_INVALID
+      self.get_type == other.get_type
+    else
+      self.id == other.id
+    end
+  end
+end
+
+# Provide pre-cooked data formats for the standard types
+module Wx
+  DF_TEXT        = DataFormat.new( Wx::DataFormatId::DF_TEXT )
+  DF_BITMAP      = DataFormat.new( Wx::DataFormatId::DF_BITMAP )
+  if Wx::PLATFORM != 'WXGTK'
+    DF_METAFILE    = DataFormat.new( Wx::DataFormatId::DF_METAFILE )
+  end
+  if Wx::PLATFORM == 'WXMSW'
+    DF_DIB         = DataFormat.new( Wx::DataFormatId::DF_DIB )
+  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
+end

data/lib/wx/core/dc.rb

@@ -0,0 +1,68 @@
+# 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
+    end
+  end
+
+  def with_pen(pen)
+    begin
+      old_pen = self.pen
+      self.pen = pen
+      yield(self) if block_given?
+    ensure
+      self.pen = old_pen
+    end
+  end
+
+  def with_font(font)
+    begin
+      old_font = self.font
+      self.font = font
+      yield(self) if block_given?
+    ensure
+      self.font = old_font
+    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
+    end
+  end
+  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
+    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

data/lib/wx/core/dialog.rb

@@ -0,0 +1,50 @@
+# WxRuby Extensions - Dialog functors for wxRuby3
+# Copyright (c) M.J.N. Corino, The Netherlands
+
+class Wx::Dialog
+
+  module Functor
+    def self.included(klass)
+      scope = klass.name.split('::')
+      functor_nm = scope.pop
+      code = <<~__CODE
+        def #{functor_nm}(*args, &block)
+          dlg = #{klass.name}.new(*args)
+          begin
+            if block_given?
+              return block.call(dlg)
+            else
+              return dlg.show_modal
+            end
+          rescue Exception
+            Wx.log_debug "\#{$!}\\n\#{$!.backtrace.join("\\n")}"
+            raise
+          ensure
+            dlg.destroy
+          end
+        end
+        __CODE
+      if scope.empty?
+        ::Kernel.module_eval code
+      else
+        scope.inject(::Object) { |mod, nm| mod.const_get(nm) }.singleton_class.module_eval code
+      end
+      klass.class_eval do
+        def self.inherited(sub)
+          sub.include Wx::Dialog::Functor
+        end
+      end
+    end
+  end
+
+  include Functor
+
+  def self.setup_dialog_functors(mod)
+    # find all Dialog descendants in mod and setup the dialog Functor for them
+    mod.constants.select do |c|
+      ::Class === (const = mod.const_get(c)) && const < Wx::Dialog
+    end.each { |c| mod.const_get(c).include Wx::Dialog::Functor }
+  end
+
+  setup_dialog_functors(Wx)
+end

data/lib/wx/core/enum.rb

@@ -0,0 +1,28 @@
+
+class Wx::Enum
+
+  def |(other)
+    if other.instance_of?(self.class)
+      self.class.new(to_i | other.to_i)
+    else
+      to_i | other.to_i
+    end
+  end
+
+  def &(other)
+    if other.instance_of?(self.class)
+      self.class.new(to_i & other.to_i)
+    else
+      to_i & other.to_i
+    end
+  end
+
+  def ~
+    self.class.new(~self.to_i)
+  end
+
+  def !
+    self.to_i == 0
+  end
+
+end

data/lib/wx/core/event.rb

@@ -0,0 +1,16 @@
+# Base class for all events
+class Wx::Event
+  # Get the Wx id, not Ruby's deprecated Object#id
+  alias :id :get_id
+end
+
+module Wx
+  # reduce mapping warnings for this unpublished event class
+  NcPaintEvent = Wx::Event
+
+  EvtHandler.register_event_type EvtHandler::EventType[
+    'evt_nc_paint', 0,
+    Wx::EVT_NC_PAINT,
+    Wx::NcPaintEvent
+  ]
+end