wxruby3 0.9.0.pre.beta.8

data/rakelib/lib/director/app.rb

@@ -0,0 +1,420 @@
+###
+# wxRuby3 wxWidgets interface director
+# Copyright (c) M.J.N. Corino, The Netherlands
+###
+
+require_relative './event_handler'
+
+module WXRuby3
+
+  class Director
+
+    class App < EvtHandler
+
+      def setup
+        spec.items << 'wxAppConsole'
+        spec.fold_bases('wxApp' => 'wxAppConsole')
+        spec.override_inheritance_chain('wxApp', %w[wxEvtHandler wxObject])
+        spec.ignore %w{
+          wxApp.ProcessMessage
+          wxAppConsole::OnInit
+          wxAppConsole::OnExit
+          wxAppConsole::OnRun
+          wxAppConsole.OnFatalException
+          wxAppConsole::OnExceptionInMainLoop
+          wxAppConsole::OnUnhandledException
+          wxAppConsole::StoreCurrentException
+          wxAppConsole::RethrowStoredException
+          wxAppConsole::OnEventLoopEnter
+          wxAppConsole::OnEventLoopExit
+          wxAppConsole::OnCmdLineError
+          wxAppConsole::OnCmdLineHelp
+          wxAppConsole::OnCmdLineParsed
+          wxAppConsole::OnInitCmdLine
+          wxAppConsole::MainLoop
+          wxAppConsole::GetMainLoop
+          wxAppConsole::HandleEvent
+          wxAppConsole::ScheduleForDestruction
+          wxAppConsole::IsScheduledForDestruction
+          wxAppConsole::SetInstance
+          wxAppConsole::GetInstance
+          wxAppConsole::argc
+          wxAppConsole::argv
+          wxDECLARE_APP
+          wxIMPLEMENT_APP
+          wxDISABLE_DEBUG_SUPPORT
+          wxTheApp
+          wxGetApp
+          wxHandleFatalExceptions
+          wxInitialize
+          wxUninitialize
+          wxWakeUpIdle
+          wxYield
+          wxSafeYield
+          wxExit
+        }
+        spec.ignore 'wxApp::GetGUIInstance'
+        unless Config.instance.wx_abi_version >= '3.2.1' || Config.instance.wx_version < '3.2.1'
+          spec.ignore 'wxApp::GTKAllowDiagnosticsControl'
+        end
+        spec.add_extend_code 'wxApp', <<~__HEREDOC
+          int main_loop()
+          {
+            return dynamic_cast<wxRubyApp*>(self)->main_loop();
+          }
+          void _wxRuby_Cleanup()
+          {
+            dynamic_cast<wxRubyApp*>(self)->_wxRuby_Cleanup();
+          }
+          bool IsRunning() const
+          {
+            return dynamic_cast<const wxRubyApp*>(self)->IsRunning();
+          }
+          __HEREDOC
+        spec.ignore [
+          'wxEntry(int &,wxChar **)',
+          'wxEntry(HINSTANCE,HINSTANCE,char *,int)'
+        ]
+        spec.no_proxy %w{
+          wxApp::GetDisplayMode
+          wxApp::GetTopWindow
+        }
+        spec.include %w{
+          wx/init.h
+          wx/display.h
+        }
+        spec.gc_never
+        # make Ruby director and wrappers use custom implementation
+        spec.use_class_implementation('wxApp', 'wxRubyApp')
+        spec.add_swig_code <<~__HEREDOC
+          // Leave GC type at GC_NEVER but add a custom marker.
+          // Prevents the App being destroyed prematurely when Ruby exits down with
+          // an exception. Otherwise GC destroys the C++ object, which can still
+          // be needed for final WxWidgets events.
+          %markfunc wxApp "wxRubyApp::mark_wxRubyApp";
+          __HEREDOC
+        spec.add_header_code <<~__HEREDOC
+          extern void GC_SetWindowDeleted(void*);
+          extern "C" void Init_wxRubyStockObjects();
+          extern void wxRuby_MarkProtectedEvtHandlerProcs();
+
+          #ifdef __WXMSW__
+          extern "C"
+          {
+            WXDLLIMPEXP_BASE HINSTANCE wxGetInstance();
+          }
+          #endif
+
+          static wxVector<WXRBMarkFunction> WXRuby_Mark_List;
+
+          WXRUBY_EXPORT void wxRuby_AppendMarker(WXRBMarkFunction marker)
+          {
+            WXRuby_Mark_List.push_back(marker);
+          }
+          
+          class wxRubyApp : public wxApp
+          {
+          private:
+            static wxRubyApp* instance_;
+
+            bool is_running_ = false;
+          public:
+            static wxRubyApp* GetInstance () { return instance_; }
+
+            virtual ~wxRubyApp()
+            {
+          #ifdef __WXTRACE__
+            std::wcout << "~wxRubyApp" << std::endl;
+          #endif
+              // unlink
+              VALUE the_app = rb_const_get(#{spec.package.module_variable}, rb_intern("THE_APP"));
+              if (the_app != Qnil) 
+              {
+                DATA_PTR(the_app) = 0;
+              }
+            }
+          
+            // special event handler for destruction of windows which is done
+            // automatically by wxWidgets. Tag the object as having been destroyed
+            // by WxWidgets.
+            void OnWindowDestroy(wxWindowDestroyEvent &event)
+            {
+              wxObject* wx_obj = event.GetEventObject();
+          #ifdef __WXRB_DEBUG__
+              if (wxRuby_TraceLevel()>0)
+                std::wcout << "<= OnWindowDestroy [" << wx_obj << "]" << std::endl;
+          #endif
+              GC_SetWindowDeleted((void *)wx_obj);
+              event.Skip();
+          #ifdef __WXRB_DEBUG__
+              if (wxRuby_TraceLevel()>0)
+                std::wcout << "=> OnWindowDestroy [" << wx_obj << "]" << std::endl;
+          #endif
+            }
+
+            bool IsRunning() const { return this->is_running_; }
+          
+            // When ruby's garbage collection runs, if the app is still active, it
+            // cycles through all currently known SWIG objects and calls this
+            // function on each to preserve still active Wx::Windows, and also
+            // pending Wx::Events which have been queued from the Ruby side (the
+            // only sort of events that will be in the tracking hash.
+            static void markIterate(void* ptr, VALUE rb_obj)
+            {
+              // Check if it's a valid object (sometimes SWIG doesn't return what we're
+              // expecting), a descendant of Wx::Window (but not a Dialog), and if it has not yet been
+              // deleted by WxWidgets; if so, mark it.
+              if ( TYPE(rb_obj) == T_DATA )
+              {
+                if ( rb_obj_is_kind_of(rb_obj, wxRuby_GetWindowClass()) )
+                {
+                  rb_gc_mark(rb_obj);
+                }
+                else if (rb_obj_is_kind_of(rb_obj, wxRuby_GetDefaultEventClass()) )
+                  rb_gc_mark(rb_obj);
+              }
+              else if (TYPE(rb_obj) == T_ARRAY )
+              {
+                VALUE proc = rb_ary_entry(rb_obj, 0);
+                if (rb_obj_is_kind_of(proc, rb_cProc) || rb_obj_is_kind_of(proc, rb_cMethod))
+                {
+                  // keep the async call alive
+                  rb_gc_mark(rb_obj);
+                }
+              }
+            }
+          
+            // Implements GC protection across wxRuby. Always called because
+            // Wx::THE_APP is a constant so always checked in GC mark phase.
+            static void mark_wxRubyApp(void *ptr)
+            {
+          
+          #ifdef __WXRB_DEBUG__
+              if (wxRuby_TraceLevel()>0)
+                std::wcout << "=== Starting App GC mark phase" << std::endl;
+          #endif
+          
+              // If the App has ended, the ruby object will have been unlinked from
+              // the C++ one; this implies that all Windows have already been destroyed
+              // so there is no point trying to mark them, and doing so may cause
+              // errors.
+              if ( !wxRubyApp::GetInstance() || !wxRubyApp::GetInstance()->IsRunning() )
+              {
+          #ifdef __WXRB_DEBUG__
+                if (wxRuby_TraceLevel()>0)
+                  std::wcout << "=== App has ended, skipping mark phase" << std::endl;
+          #endif
+                return;
+              }
+          
+              // Mark evt handler procs associated with live windows - see
+              // classes/EvtHandler.i
+              wxRuby_MarkProtectedEvtHandlerProcs();
+
+              // run registered markers
+              for (wxVector<WXRBMarkFunction>::iterator it = WXRuby_Mark_List.begin();
+                    it != WXRuby_Mark_List.end() ;++it)
+              {
+                (*it) ();
+              }
+          
+              // To do the main marking, primarily of Windows, iterate over SWIG's
+              // list of tracked objects
+              wxRuby_IterateTracking(&wxRubyApp::markIterate);
+          
+          #ifdef __WXRB_DEBUG__
+              if (wxRuby_TraceLevel()>0)
+                std::wcout << "=== App GC mark phase completed" << std::endl;
+          #endif
+            }
+          
+            // This is the method run when main_loop is called in Ruby
+            // wxEntry calls the C++ App::OnInit method
+            int main_loop()
+            {
+              VALUE rb_app = SWIG_RubyInstanceFor(this);
+              rb_define_const(#{spec.package.module_variable}, "THE_APP", rb_app);
+              this->Connect(wxEVT_DESTROY,
+                    wxWindowDestroyEventHandler(wxRubyApp::OnWindowDestroy));
+          
+          #ifdef __WXRB_DEBUG__
+              if (wxRuby_TraceLevel()>0)
+                std::wcout << "Calling wxEntry, this=" << this << std::endl;
+          #endif
+          
+          #ifdef __WXMSW__
+              extern int wxEntry(HINSTANCE hInstance,
+                         HINSTANCE WXUNUSED(hPrevInstance),
+                         wxCmdLineArgType WXUNUSED(pCmdLine),
+                         int nCmdShow);
+              wxEntry(wxGetInstance(),
+                      (HINSTANCE)0,
+                      (wxCmdLineArgType)"",
+                      (int)true);
+          #else
+              int argc = 1;
+              const char* argv[2] = { "ruby", 0 };
+              wxEntry(argc, const_cast<char**>(&argv[0]));
+          #endif
+          
+              rb_const_remove(#{spec.package.module_variable}, rb_intern("THE_APP"));
+
+          #ifdef __WXRB_DEBUG__
+              if (wxRuby_TraceLevel()>0)
+                std::wcout << "returned from wxEntry..." << std::endl;
+          #endif
+              rb_gc_start();
+          #ifdef __WXRB_DEBUG__
+              if (wxRuby_TraceLevel()>0)
+                std::wcout << "survived gc" << std::endl;
+          #endif
+
+              VALUE exc = rb_iv_get(rb_app, "@exception");
+              if (!NIL_P(exc))
+              {
+                rb_exc_raise(exc);
+              }
+              return 0;
+            }
+          
+            // This method initializes the stock objects (Pens, Brushes, Fonts)
+            // before yielding to ruby by calling the App's on_init method.
+            // Note that as of wxWidget 2.8, the stock fonts in particular cannot
+            // be initialized any earlier than this without crashing
+            bool OnInit() override
+            {
+          #ifdef __WXRB_DEBUG__
+              if (wxRuby_TraceLevel()>0)
+                std::wcout << "OnInit..." << std::endl;
+          #endif
+              // set standard App name
+              this->SetAppName(wxString("wxruby"));
+              // Signal that we've started              
+              wxRubyApp::instance_ = this; // there should ALWAYS EVER be only 1 app instance running/created
+              this->is_running_ = true;
+              // Set up the GDI objects
+              Init_wxRubyStockObjects();
+              // Get the ruby representation of the App object, and call the
+              // ruby on_init method to set up the initial window state
+              VALUE the_app = rb_const_get(#{spec.package.module_variable}, rb_intern("THE_APP"));
+              VALUE result  = wxRuby_Funcall(the_app, rb_intern("on_ruby_init"), 0, 0);
+        
+              // If on_init return any (ruby) true value, signal to wxWidgets to
+              // enter the main event loop by returning true, else return false
+              // which will make wxWidgets exit.
+              if ( result == Qfalse || result == Qnil )
+              {
+                wxRubyApp::instance_ = 0;
+                this->is_running_ = false;
+                return false;
+              }
+              else
+              {
+                return true;
+              }
+            }
+          
+            int OnExit() override
+            {
+          #ifdef __WXRB_DEBUG__
+              if (wxRuby_TraceLevel()>0)
+                std::wcout << "OnExit..." << std::endl;
+          #endif
+
+              // Get the ruby representation of the App object, and call the
+              // ruby on_exit method (if any) for application level cleanup
+              VALUE the_app = rb_const_get(#{spec.package.module_variable}, rb_intern("THE_APP"));
+              ID on_exit_id = rb_intern("on_exit");
+              if (rb_funcall(the_app, rb_intern("respond_to?"), 1, ID2SYM(on_exit_id)) == Qtrue)
+              {
+                wxRuby_Funcall(the_app, on_exit_id, 0, 0);
+              }
+
+              // perform wxRuby cleanup
+              _wxRuby_Cleanup();
+      
+              // execute base wxWidgets functionality 
+              return this->wxApp::OnExit();
+            }
+          
+            // actually implemented in ruby in classes/app.rb
+            virtual void OnAssertFailure(const wxChar *file, int line, const wxChar *func, const wxChar *cond, const wxChar *msg)
+            {
+              std::wcout << "ASSERT fired" << std::endl;
+            }
+
+            void _wxRuby_Cleanup()
+            {
+          #ifdef __WXRB_DEBUG__
+              if (wxRuby_TraceLevel()>0)
+                std::wcout << "wxRuby_Cleanup..." << std::endl;
+          #endif
+              // Note in a global variable that the App has ended, so that we
+              // can skip any GC marking later
+              wxRubyApp::instance_ = 0;
+              this->is_running_ = false;
+      
+              // if a Ruby implemented logger has been installed clean that up
+              // before we exit, otherwise let wxWidgets handle things
+              wxLog *oldlog = wxLog::GetActiveTarget();
+              if (wxRuby_FindTracking(oldlog) != Qnil)
+              {
+                oldlog = wxLog::SetActiveTarget(new wxLogStderr);
+              }
+              else
+              {
+                oldlog = 0;
+              }
+              SetTopWindow(0);
+              if ( oldlog )
+              {
+                SWIG_RubyUnlinkObjects(oldlog);
+                SWIG_RubyRemoveTracking(oldlog);
+                delete oldlog;
+              }
+            }
+          };
+          wxRubyApp* wxRubyApp::instance_ = 0;
+
+          WXRUBY_EXPORT bool wxRuby_IsAppRunning()
+          {
+            return wxRubyApp::GetInstance() != 0 && wxRubyApp::GetInstance()->IsRunning();  
+          }
+
+          WXRUBY_EXPORT void wxRuby_ExitMainLoop(VALUE exception)
+          {
+            if (wxRubyApp::GetInstance() != 0 && wxRubyApp::GetInstance()->IsRunning())
+            {
+              if (!NIL_P(exception))
+              {
+                VALUE the_app = rb_const_get(#{spec.package.module_variable}, rb_intern("THE_APP"));
+                rb_iv_set(the_app, "@exception", exception);
+              }
+              wxRubyApp::GetInstance()->ExitMainLoop();
+            }  
+          }
+
+          WXRUBY_EXPORT void wxRuby_PrintException(VALUE err)
+          {
+            static WxRuby_ID message_id("message");
+            static WxRuby_ID class_id("class");
+            static WxRuby_ID name_id("name");
+            static WxRuby_ID backtrace_id("backtrace");
+            static WxRuby_ID join_id("join");
+          
+            VALUE msg = rb_funcall(err, message_id(), 0);
+            VALUE err_name = rb_funcall(rb_funcall(err, class_id(), 0), name_id(), 0);
+            VALUE bt = rb_funcall(err, backtrace_id(), 0);
+            bt = rb_funcall(bt, join_id(), 1, rb_str_new2("\\n"));
+            std::cerr << std::endl
+                      << ' ' << StringValuePtr(err_name) << ": " << StringValuePtr(msg) << std::endl
+                      << StringValuePtr(bt) << std::endl;
+          }
+          __HEREDOC
+        super
+      end
+    end
+
+  end # class Director
+
+end # module WXRuby3

data/rakelib/lib/director/art_provider.rb

@@ -0,0 +1,124 @@
+###
+# wxRuby3 wxWidgets interface director
+# Copyright (c) M.J.N. Corino, The Netherlands
+###
+
+module WXRuby3
+
+  class Director
+
+    class ArtProvider < Director
+
+      def setup
+        spec.make_concrete('wxArtProvider')
+        # make Ruby director and wrappers use custom implementation
+        spec.use_class_implementation('wxArtProvider', 'wxRubyArtProvider')
+        spec.ignore('wxArtProvider::Insert') # deprecated and problematic
+        spec.ignore('wxArtProvider::Remove') # problematic as adding disowns the art provider, use Delete
+        spec.no_proxy('wxArtProvider')
+        spec.include('wx/artprov.h')
+        spec.add_swig_code <<~__HEREDOC
+          // ArtId and ArtClient are basically just strings ...
+          typedef wxString wxArtID;
+          typedef wxString wxArtClient;
+          __HEREDOC
+        spec.map *%w[wxArtID wxArtClient], as: 'String', swig: false do
+          map_in
+          map_out
+        end
+        spec.map_apply 'SWIGTYPE *DISOWN' => 'wxArtProvider* provider'
+        spec.add_header_code <<~__HEREDOC
+          extern swig_class SwigClassWxSize;
+          extern swig_class SwigClassWxObject;
+          
+          class wxRubyArtProvider : public wxArtProvider
+          {
+          public:
+            wxSize DoGetSizeHint (const wxArtClient &client) override
+            {
+              static WxRuby_ID do_get_size_hint_id("do_get_size_hint");
+
+              VALUE v_client, v_ret;
+              VALUE self = SWIG_RubyInstanceFor(this);
+
+              v_client = WXSTR_TO_RSTR(client);
+              v_ret = rb_funcall(self, do_get_size_hint_id(), 1, v_client);
+              if ( TYPE(v_ret) == T_DATA )
+              {
+                void* ptr;
+                SWIG_ConvertPtr(v_ret, &ptr, SWIGTYPE_p_wxSize, 1);
+                return *reinterpret_cast< wxSize * >(ptr);
+              }
+              else if ( TYPE(v_ret) == T_ARRAY )
+              {
+                return wxSize( NUM2INT( rb_ary_entry(v_ret, 0) ),
+                               NUM2INT( rb_ary_entry(v_ret, 1) ) );
+              }
+              else
+              {
+                return wxSize(-1, -1);
+              }
+            }          
+
+            wxBitmap CreateBitmap(const wxArtID& id, const wxArtClient& client, const wxSize& size) override
+            {
+              static WxRuby_ID create_bitmap_id("create_bitmap");
+
+              VALUE v_id,v_client,v_size,v_ret;
+              VALUE self = SWIG_RubyInstanceFor(this);
+          
+              v_id     = WXSTR_TO_RSTR(id);
+              v_client = WXSTR_TO_RSTR(client);
+              v_size = SWIG_NewPointerObj(SWIG_as_voidptr(&size), SWIGTYPE_p_wxSize, 0);
+              v_ret = rb_funcall(self, create_bitmap_id(), 3, v_id, v_client, v_size);
+          
+              if (v_ret != Qnil) 
+                return *((wxBitmap *)DATA_PTR(v_ret));
+              else
+                return wxNullBitmap;
+            }
+
+            wxBitmapBundle CreateBitmapBundle(const wxArtID& id, const wxArtClient& client, const wxSize& size) override
+            {
+              static WxRuby_ID create_bitmap_bundle_id("create_bitmap_bundle");
+
+              VALUE v_id,v_client,v_size,v_ret;          
+              VALUE self = SWIG_RubyInstanceFor(this);
+          
+              v_id     = WXSTR_TO_RSTR(id);
+              v_client = WXSTR_TO_RSTR(client);
+              v_size = SWIG_NewPointerObj(SWIG_as_voidptr(&size), SWIGTYPE_p_wxSize, 0);
+              v_ret = rb_funcall(self, create_bitmap_bundle_id(), 3, v_id, v_client, v_size);
+          
+              if (v_ret != Qnil) 
+                return *((wxBitmapBundle *)DATA_PTR(v_ret));
+              else
+                return wxBitmapBundle();
+            }
+
+            wxIconBundle CreateIconBundle(const wxArtID &id, const wxArtClient &client) override
+            {
+              static WxRuby_ID create_icon_bundle_id("create_icon_bundle");
+
+              VALUE v_id,v_client,v_ret;          
+              VALUE self = SWIG_RubyInstanceFor(this);
+          
+              v_id     = WXSTR_TO_RSTR(id);
+              v_client = WXSTR_TO_RSTR(client);
+            
+              v_ret = rb_funcall(self, create_icon_bundle_id(), 2, v_id, v_client);
+          
+              if (v_ret != Qnil) 
+                return *((wxIconBundle *)DATA_PTR(v_ret));
+              else
+                return wxIconBundle();
+            }
+          };
+          __HEREDOC
+        super
+      end
+    end # class ArtProvider
+
+  end # class Director
+
+end # module WXRuby3

data/rakelib/lib/director/aui_dock_art.rb

@@ -0,0 +1,23 @@
+###
+# wxRuby3 wxWidgets interface director
+# Copyright (c) M.J.N. Corino, The Netherlands
+###
+
+module WXRuby3
+
+  class Director
+
+    class AuiDockArt < Director
+
+      def setup
+        super
+        spec.items << 'wxAuiDefaultDockArt'
+        spec.gc_as_object
+        spec.include 'wx/aui/framemanager.h'
+        spec.suppress_warning(473, 'wxAuiDockArt::Clone', 'wxAuiDefaultDockArt::Clone')
+      end
+    end # class AuiDockArt
+
+  end # class Director
+
+end # module WXRuby3

data/rakelib/lib/director/aui_floating_frame.rb

@@ -0,0 +1,26 @@
+###
+# wxRuby3 wxWidgets interface director
+# Copyright (c) M.J.N. Corino, The Netherlands
+###
+
+require_relative './frame'
+
+module WXRuby3
+
+  class Director
+
+    class AuiFloatingFrame < Frame
+
+      def setup
+        super
+        spec.no_proxy %w[
+          wxAuiFloatingFrame::CreateStatusBar wxAuiFloatingFrame::CreateToolBar
+          wxAuiFloatingFrame::GetMenuBar wxAuiFloatingFrame::GetStatusBar
+          wxAuiFloatingFrame::GetToolBar]
+        spec.include 'wx/aui/framemanager.h'
+      end
+    end # class AuiFloatingFrame
+
+  end # class Director
+
+end # module WXRuby3