redcar 0.3.4.3 → 0.3.5

data/plugins/application_swt/lib/application_swt/cucumber_patches.rb

@@ -2,7 +2,10 @@
 module Cucumber
   module Ast
     class StepInvocation #:nodoc:# 
-
+      class << self
+        attr_accessor :wait_time
+      end
+      
       def invoke(step_mother, options)
         block = Swt::RRunnable.new do
           find_step_match!(step_mother)
@@ -28,6 +31,8 @@ module Cucumber
         if ENV["SLOW_CUKES"]
           sleep ENV["SLOW_CUKES"].to_f
         end
+        sleep(Cucumber::Ast::StepInvocation.wait_time || 0)
+        Cucumber::Ast::StepInvocation.wait_time = nil
       end
     end
   end

data/plugins/application_swt/lib/application_swt/dialog_adapter.rb

@@ -1,16 +1,16 @@
 module Redcar
   class ApplicationSWT
     class DialogAdapter
-      def open_file(window, options)
-        file_dialog(window, Swt::SWT::OPEN, options)
+      def open_file(options)
+        file_dialog(Swt::SWT::OPEN, options)
       end
       
-      def open_directory(window, options)
-        directory_dialog(window, options)
+      def open_directory(options)
+        directory_dialog(options)
       end
       
-      def save_file(window, options)
-        file_dialog(window, Swt::SWT::SAVE, options)
+      def save_file(options)
+        file_dialog(Swt::SWT::SAVE, options)
       end
       
       MESSAGE_BOX_TYPES = {
@@ -40,14 +40,14 @@ module Redcar
         :abort_retry_ignore => [:abort, :retry, :ignore]
       }
       
-      def message_box(window, text, options)
+      def message_box(text, options)
         styles = 0
         styles = styles | MESSAGE_BOX_TYPES[options[:type]] if options[:type]
         if options[:buttons]
           buttons = MESSAGE_BOX_BUTTON_COMBOS[options[:buttons]]
           buttons.each {|b| styles = styles | BUTTONS[b] }
         end
-        dialog = Swt::Widgets::MessageBox.new(window.controller.shell, styles)
+        dialog = Swt::Widgets::MessageBox.new(parent_shell, styles)
         dialog.set_message(text)
         result = nil
         Redcar.app.protect_application_focus do
@@ -75,12 +75,12 @@ module Redcar
         
         def createShell
           super
-          p [:in, get_shell]
         end
       end
       
-      def input(window, title, message, initial_value, &block)
-        dialog = JFace::Dialogs::InputDialog.new(window.controller.shell,
+      def input(title, message, initial_value, &block)
+        dialog = JFace::Dialogs::InputDialog.new(
+                   parent_shell,
                    title, message, initial_value) do |text|
           block ? block[text] : nil
         end
@@ -89,16 +89,16 @@ module Redcar
         {:button => button, :value => dialog.getValue}
       end
       
-      def tool_tip(window, message)
-        tool_tip = Swt::Widgets::ToolTip.new(window.controller.shell, Swt::SWT::ICON_INFORMATION)
+      def tool_tip(message)
+        tool_tip = Swt::Widgets::ToolTip.new(parent_shell, Swt::SWT::ICON_INFORMATION)
         tool_tip.set_message(message)
         tool_tip.set_visible(true)
       end
       
       private
       
-      def file_dialog(window, type, options)
-        dialog = Swt::Widgets::FileDialog.new(window.controller.shell, type)
+      def file_dialog(type, options)
+        dialog = Swt::Widgets::FileDialog.new(parent_shell, type)
         if options[:filter_path]
           dialog.set_filter_path(options[:filter_path])
         end
@@ -107,8 +107,8 @@ module Redcar
         end
       end
       
-      def directory_dialog(window, options)
-        dialog = Swt::Widgets::DirectoryDialog.new(window.controller.shell)
+      def directory_dialog(options)
+        dialog = Swt::Widgets::DirectoryDialog.new(parent_shell)
         if options[:filter_path]
           dialog.set_filter_path(options[:filter_path])
         end
@@ -116,6 +116,14 @@ module Redcar
           dialog.open
         end
       end
+      
+      def parent_shell
+        if focussed_window = Redcar.app.focussed_window
+          focussed_window.controller.shell
+        else
+          Redcar.app.controller.fake_shell
+        end
+      end
     end
   end
 end

data/plugins/application_swt/lib/application_swt/dialogs/filter_list_dialog_controller.rb

@@ -2,7 +2,13 @@ module Redcar
   class ApplicationSWT
     class FilterListDialogController
       include ReentryHelpers
-        
+      
+      class << self
+        # when set, the FilterListDialog is non-modal for testing
+        attr_writer :test_mode
+        def test_mode?; @test_mode; end
+      end
+      
       class FilterListDialog < Dialogs::NoButtonsDialog
         attr_reader :list, :text
         attr_accessor :controller
@@ -14,12 +20,13 @@ module Redcar
 
           @text = Swt::Widgets::Text.new(composite, Swt::SWT::SINGLE | Swt::SWT::LEFT | Swt::SWT::ICON_CANCEL)
           @text.set_layout_data(Swt::Layout::RowData.new(400, 20))
-          @list = Swt::Widgets::List.new(composite, Swt::SWT::SINGLE)
+          @list = Swt::Widgets::List.new(composite, Swt::SWT::V_SCROLL | Swt::SWT::H_SCROLL | Swt::SWT::SINGLE)
           @list.set_layout_data(Swt::Layout::RowData.new(400, 200))
           controller.attach_listeners
-          controller.update_list
+          controller.update_list_sync
           get_shell.add_shell_listener(ShellListener.new(controller))
           ApplicationSWT.register_shell(get_shell)
+          ApplicationSWT.register_dialog(get_shell, self)
 
           @list.set_selection(0)
         end
@@ -57,6 +64,10 @@ module Redcar
         @model = model
         @dialog = FilterListDialog.new(Redcar.app.focussed_window.controller.shell)
         @dialog.controller = self
+        if FilterListDialogController.test_mode?
+          @dialog.setBlockOnOpen(false)
+          @dialog.setShellStyle(Swt::SWT::DIALOG_TRIM)
+        end
         attach_model_listeners
       end
       
@@ -81,42 +92,69 @@ module Redcar
         end
         
         def key_pressed(e)
-          e.doit = @controller.key_pressed(e)
+          @controller.key_pressed(e)
         end
         
         def key_released(e)
         end
       end
       
+      class SelectionListener
+        def initialize(controller)
+          @controller = controller
+        end
+        
+        def widgetDefaultSelected(e)
+          @controller.selected
+        end
+        
+        def widgetSelected(e)
+          @controller.text_focus
+        end
+      end
+      
       def attach_listeners
         @dialog.text.add_modify_listener(ModifyListener.new(self))
         @dialog.text.add_key_listener(KeyListener.new(self))
+        @dialog.list.add_selection_listener(SelectionListener.new(self))
       end
       
       def open
         @dialog.open
-        @dialog = nil
+        @dialog = nil unless FilterListDialogController.test_mode?
       end
       
       def close
         @dialog.close
+        ApplicationSWT.unregister_dialog(@dialog)
+        @dialog = nil
       end
       
       def update_list
         @last_keypress = Time.now
         pause_time = FilterListDialogController.storage['pause_before_update_seconds']
-        Swt::Widgets::Display.getCurrent.timerExec(pause_time*1000, Swt::RRunnable.new { 
-          if @dialog and @last_keypress and (Time.now - @last_keypress + pause_time) > pause_time
+        Swt::Widgets::Display.getCurrent.timerExec(pause_time*1000, Swt::RRunnable.new {
+          if @last_keypress and (Time.now - @last_keypress + pause_time) > pause_time
             @last_keypress = nil
-            s = Time.now
-            list = @model.update_list(@dialog.text.get_text)
-            puts "update list took #{Time.now - s}s"
-            populate_list(list)
-            @dialog.list.set_selection(0)
+            update_list_sync
           end
         })
       end
       
+      def update_list_sync
+        if @dialog
+          s = Time.now
+          list = @model.update_list(@dialog.text.get_text)
+          populate_list(list)
+          @dialog.list.set_selection(0)
+          text_focus
+        end
+      end
+      
+      def text_focus
+        @dialog.text.set_focus
+      end
+      
       def selected
         @model.selected(@dialog.list.get_selection.first, @dialog.list.get_selection_index)
       end

data/plugins/application_swt/lib/application_swt/html_tab.rb

@@ -20,6 +20,7 @@ module Redcar
         end
         @widget = @browser
         @item.control = @widget
+        add_listeners
       end
       
       # Focuses the Browser tab within the CTabFolder, and gives the keyboard
@@ -34,6 +35,25 @@ module Redcar
         @browser.dispose
         super
       end
+      
+      class LocationListener
+        def initialize(html_tab)
+          @html_tab = html_tab
+        end
+        
+        def changing(event)
+          if event.location =~ %r{file:///controller/([^/]*)(/(.*))?}
+            event.doit = false
+            @html_tab.controller_action($1, $2)
+          end
+        end
+
+        def changed(*_); end
+      end
+      
+      def add_listeners
+        @browser.add_location_listener(LocationListener.new(@model))
+      end
     end
   end
 end

data/plugins/application_swt/lib/application_swt/menu.rb

@@ -16,17 +16,20 @@ module Redcar
       end
       
       def initialize(window, menu_model, keymap, type, options={})
+        s = Time.now
         unless Menu.menu_types.include?(type)
           raise "type should be in #{Menu.menu_types.inspect}"
         end
         @window = window
         @keymap = keymap
         @menu_bar = Swt::Widgets::Menu.new(window.shell, type)
+        @menu_bar.set_visible(false)
         return unless menu_model
         @handlers = []
         @use_numbers = options[:numbers]
         @number = 1
         add_entries_to_menu(@menu_bar, menu_model)
+        #puts "ApplicationSWT::Menu initialize took #{Time.now - s}s"
       end
       
       def show
@@ -47,7 +50,16 @@ module Redcar
 
       def add_entries_to_menu(menu, menu_model)
         menu_model.each do |entry|
-          if entry.is_a?(Redcar::Menu)
+          if entry.is_a?(Redcar::Menu::LazyMenu)
+            menu_header = Swt::Widgets::MenuItem.new(menu, Swt::SWT::CASCADE)
+            menu_header.text = entry.text
+            new_menu = Swt::Widgets::Menu.new(@window.shell, Swt::SWT::DROP_DOWN)
+            menu_header.menu = new_menu
+            menu_header.add_arm_listener do
+              new_menu.get_items.each {|i| i.dispose }
+              add_entries_to_menu(new_menu, entry)
+            end
+          elsif entry.is_a?(Redcar::Menu)
             menu_header = Swt::Widgets::MenuItem.new(menu, Swt::SWT::CASCADE)
             menu_header.text = entry.text
             new_menu = Swt::Widgets::Menu.new(@window.shell, Swt::SWT::DROP_DOWN)
@@ -67,6 +79,18 @@ module Redcar
           end
         end
       end
+
+      class ProcSelectionListener
+        def initialize(entry)
+          @entry = entry
+        end
+        
+        def widget_selected(e)
+          @entry.command.call
+        end
+        
+        alias :widget_default_selected :widget_selected
+      end
       
       def connect_proc_to_item(item, entry)
         if use_numbers? and Redcar.platform == :osx
@@ -75,7 +99,7 @@ module Redcar
         else
           item.text = entry.text
         end
-        item.add_selection_listener { entry.command.call }
+        item.addSelectionListener(ProcSelectionListener.new(entry))
       end
       
       class SelectionListener

data/plugins/application_swt/lib/application_swt/notebook.rb

@@ -6,17 +6,16 @@ module Redcar
       attr_reader :tab_folder
       
       class CTabFolder2Listener
-        include ListenerHelpers
-        
         def initialize(controller)
           @controller = controller
         end
         
         def close(event)
-          ignore_within_self do
-            event.doit = false
-            if event.item
-              @controller.tab_widget_to_tab_model(event.item).close
+          if event.item
+            tab = @controller.tab_widget_to_tab_model(event.item)
+            unless Redcar.app.events.ignore?(:tab_close, tab)
+              event.doit = false
+              Redcar.app.events.create(:tab_close, tab)
             end
           end
         end
@@ -28,17 +27,16 @@ module Redcar
       end
       
       class SelectionListener
-        include ListenerHelpers
-        
         def initialize(controller)
           @controller = controller
         end
         
         def widgetSelected(event)
-          ignore_within_self do
-            event.doit = false
-            if event.item
-              @controller.tab_widget_to_tab_model(event.item).focus
+          if event.item
+            tab = @controller.tab_widget_to_tab_model(event.item)
+            unless Redcar.app.events.ignore?(:tab_focus, tab)
+              event.doit = false
+              Redcar.app.events.create(:tab_focus, tab)
             end
           end
         end

data/plugins/application_swt/lib/application_swt/window.rb

@@ -5,23 +5,21 @@ module Redcar
       attr_reader :shell, :window, :shell_listener
       
       class ShellListener
-        include ReentryHelpers
-        
         def initialize(controller)
-          @controller = controller
+          @win = controller.window
         end
         
         def shell_closed(e)
-          @controller.window.close
-          @controller.window.ignore(:closing) do
+          unless Redcar.app.events.ignore?(:window_close, @win)
             e.doit = false
+            Redcar.app.events.create(:window_close, @win)
           end
         end
 
         def shell_activated(e)
-          @controller.window.focus
-          @controller.window.ignore(:focussing) do
+          unless Redcar.app.events.ignore?(:window_focus, @win)
             e.doit = false
+            Redcar.app.events.create(:window_focus, @win)
           end
         end
         
@@ -112,14 +110,16 @@ module Redcar
       end
       
       def refresh_menu
-        @menu_controller = ApplicationSWT::Menu.new(self, @window.menu, @window.keymap, Swt::SWT::BAR)
+        old_menu_bar = shell.menu_bar
+        @menu_controller = ApplicationSWT::Menu.new(self, Redcar.app.main_menu, Redcar.app.main_keymap, Swt::SWT::BAR)
         shell.menu_bar = @menu_controller.menu_bar
+        old_menu_bar.dispose if old_menu_bar
       end
       
       def set_icon(path)
-         icon = Swt::Graphics::Image.new(ApplicationSWT.display, path)
-         shell.image = icon
-       end
+        icon = Swt::Graphics::Image.new(ApplicationSWT.display, path)
+        shell.image = icon
+      end
 
       def bring_to_front
         @shell.set_minimized(false) # unminimize, just in case

data/plugins/application_swt/src/com/redcareditor/application_swt/CocoaUIEnhancer.java

@@ -0,0 +1,313 @@
+
+package com.redcareditor.application_swt;
+
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+
+import org.eclipse.swt.SWT;
+import org.eclipse.swt.internal.C;
+import org.eclipse.swt.internal.Callback;
+import org.eclipse.swt.widgets.Display;
+import org.eclipse.swt.widgets.Listener;
+
+/**
+ * Provide a hook to connecting the Preferences, About and Quit menu items of the Mac OS X
+ * Application menu when using the SWT Cocoa bindings.
+ * <p>
+ * This code does not require the Cocoa SWT JAR in order to be compiled as it uses reflection to
+ * access the Cocoa specific API methods. It does, however, depend on JFace (for IAction), but you
+ * could easily modify the code to use SWT Listeners instead in order to use this class in SWT only
+ * applications.
+ * </p>
+ * <p>
+ * This code was influenced by the <a
+ * href="http://www.simidude.com/blog/2008/macify-a-swt-application-in-a-cross-platform-way/"
+ * >CarbonUIEnhancer from Agynami</a> with the implementation being modified from the <a href="http://dev.eclipse.org/viewcvs/index.cgi/org.eclipse.ui.cocoa/src/org/eclipse/ui/internal/cocoa/CocoaUIEnhancer.java"
+ * >org.eclipse.ui.internal.cocoa.CocoaUIEnhancer</a>.
+ * </p>
+ * <p>
+ * This class works with both the 32-bit and 64-bit versions of the SWT Cocoa bindings.
+ * <p>
+ * <p>
+ * This class is released under the Eclipse Public License (<a href="http://www.eclipse.org/legal/epl-v10.html">EPL</a>).
+ */
+public class CocoaUIEnhancer {
+
+    private static final long kAboutMenuItem = 0;
+    private static final long kPreferencesMenuItem = 2;
+    // private static final long kServicesMenuItem = 4;
+    // private static final long kHideApplicationMenuItem = 6;
+    private static final long kQuitMenuItem = 10;
+
+    static long sel_toolbarButtonClicked_;
+    static long sel_preferencesMenuItemSelected_;
+    static long sel_aboutMenuItemSelected_;
+    static Callback proc3Args;
+
+    final private String appName;
+
+    /**
+     * Class invoked via the Callback object to run the about and preferences actions.
+     * <p>
+     * If you don't use JFace in your application (SWT only), change the
+     * {@link org.eclipse.jface.action.IAction}s to {@link org.eclipse.swt.widgets.Listener}s.
+     * </p>
+     */
+    private static class MenuHookObject {
+        final Listener about;
+        final Listener pref;
+
+        public MenuHookObject( Listener about, Listener pref ) {
+            this.about = about;
+            this.pref = pref;
+        }
+
+        /**
+         * Will be called on 32bit SWT.
+         */
+        @SuppressWarnings( "unused" )
+        public int actionProc( int id, int sel, int arg0 ) {
+            return (int) actionProc( (long) id, (long) sel, (long) arg0 );
+        }
+
+        /**
+         * Will be called on 64bit SWT.
+         */
+        public long actionProc( long id, long sel, long arg0 ) {
+            if ( sel == sel_aboutMenuItemSelected_ ) {
+                about.handleEvent(null);
+            } else if ( sel == sel_preferencesMenuItemSelected_ ) {
+                pref.handleEvent(null);
+            } else {
+                // Unknown selection!
+            }
+            // Return value is not used.
+            return 99;
+        }
+    }
+
+    /**
+     * Construct a new CocoaUIEnhancer.
+     * 
+     * @param appName
+     *            The name of the application. It will be used to customize the About and Quit menu
+     *            items. If you do not wish to customize the About and Quit menu items, just pass
+     *            <tt>null</tt> here.
+     */
+    public CocoaUIEnhancer( String appName ) {
+        this.appName = appName;
+    }
+
+    /**
+     * Hook the given Listener to the Mac OS X application Quit menu and the IActions to the About
+     * and Preferences menus.
+     * 
+     * @param display
+     *            The Display to use.
+     * @param quitListener
+     *            The listener to invoke when the Quit menu is invoked.
+     * @param aboutListener
+     *            The listener to invoke when the About menu is invoked.
+     * @param preferencesListener
+     *            The listener to invoke when the Preferences menu is invoked.
+     */
+    public void hookApplicationMenu( Display display, Listener quitListener, Listener aboutListener,
+                                     Listener preferencesListener ) {
+        // This is our callbackObject whose 'actionProc' method will be called when the About or
+        // Preferences menuItem is invoked.
+        MenuHookObject target = new MenuHookObject( aboutListener, preferencesListener );
+
+        try {
+            // Initialize the menuItems.
+            initialize( target );
+        } catch ( Exception e ) {
+            throw new IllegalStateException( e );
+        }
+
+        // Connect the quit/exit menu.
+        if ( !display.isDisposed() ) {
+            display.addListener( SWT.Close, quitListener );
+        }
+
+        // Schedule disposal of callback object
+        display.disposeExec( new Runnable() {
+            public void run() {
+                invoke( proc3Args, "dispose" );
+            }
+        } );
+    }
+
+    private void initialize( Object callbackObject )
+            throws Exception {
+
+        Class<?> osCls = classForName( "org.eclipse.swt.internal.cocoa.OS" );
+
+        // Register names in objective-c.
+        if ( sel_toolbarButtonClicked_ == 0 ) {
+            // sel_toolbarButtonClicked_ = registerName( osCls, "toolbarButtonClicked:" ); //$NON-NLS-1$
+            sel_preferencesMenuItemSelected_ = registerName( osCls, "preferencesMenuItemSelected:" ); //$NON-NLS-1$
+            sel_aboutMenuItemSelected_ = registerName( osCls, "aboutMenuItemSelected:" ); //$NON-NLS-1$
+        }
+
+        // Create an SWT Callback object that will invoke the actionProc method of our internal
+        // callbackObject.
+        proc3Args = new Callback( callbackObject, "actionProc", 3 ); //$NON-NLS-1$
+        Method getAddress = Callback.class.getMethod( "getAddress", new Class[0] );
+        Object object = getAddress.invoke( proc3Args, (Object[]) null );
+        long proc3 = convertToLong( object );
+        if ( proc3 == 0 ) {
+            SWT.error( SWT.ERROR_NO_MORE_CALLBACKS );
+        }
+
+        Class<?> nsmenuCls = classForName( "org.eclipse.swt.internal.cocoa.NSMenu" );
+        Class<?> nsmenuitemCls = classForName( "org.eclipse.swt.internal.cocoa.NSMenuItem" );
+        Class<?> nsstringCls = classForName( "org.eclipse.swt.internal.cocoa.NSString" );
+        Class<?> nsapplicationCls = classForName( "org.eclipse.swt.internal.cocoa.NSApplication" );
+
+        // Instead of creating a new delegate class in objective-c,
+        // just use the current SWTApplicationDelegate. An instance of this
+        // is a field of the Cocoa Display object and is already the target
+        // for the menuItems. So just get this class and add the new methods
+        // to it.
+        object = invoke( osCls, "objc_lookUpClass", new Object[] { "SWTApplicationDelegate" } );
+        long cls = convertToLong( object );
+
+        // Add the action callbacks for Preferences and About menu items.
+        invoke( osCls, "class_addMethod", new Object[] {
+                                                        wrapPointer( cls ),
+                                                        wrapPointer( sel_preferencesMenuItemSelected_ ),
+                                                        wrapPointer( proc3 ),
+                                                        "@:@" } ); //$NON-NLS-1$
+        invoke( osCls, "class_addMethod", new Object[] {
+                                                        wrapPointer( cls ),
+                                                        wrapPointer( sel_aboutMenuItemSelected_ ),
+                                                        wrapPointer( proc3 ),
+                                                        "@:@" } ); //$NON-NLS-1$
+
+        // Get the Mac OS X Application menu.
+        Object sharedApplication = invoke( nsapplicationCls, "sharedApplication" );
+        Object mainMenu = invoke( sharedApplication, "mainMenu" );
+        Object mainMenuItem = invoke( nsmenuCls, mainMenu, "itemAtIndex", new Object[] { wrapPointer( 0 ) } );
+        Object appMenu = invoke( mainMenuItem, "submenu" );
+
+        // Create the About <application-name> menu command
+        Object aboutMenuItem =
+            invoke( nsmenuCls, appMenu, "itemAtIndex", new Object[] { wrapPointer( kAboutMenuItem ) } );
+        if ( appName != null ) {
+            Object nsStr = invoke( nsstringCls, "stringWith", new Object[] { "About " + appName } );
+            invoke( nsmenuitemCls, aboutMenuItem, "setTitle", new Object[] { nsStr } );
+        }
+        // Rename the quit action.
+        if ( appName != null ) {
+            Object quitMenuItem =
+                invoke( nsmenuCls, appMenu, "itemAtIndex", new Object[] { wrapPointer( kQuitMenuItem ) } );
+            Object nsStr = invoke( nsstringCls, "stringWith", new Object[] { "Quit " + appName } );
+            invoke( nsmenuitemCls, quitMenuItem, "setTitle", new Object[] { nsStr } );
+        }
+
+        // Enable the Preferences menuItem.
+        Object prefMenuItem =
+            invoke( nsmenuCls, appMenu, "itemAtIndex", new Object[] { wrapPointer( kPreferencesMenuItem ) } );
+        invoke( nsmenuitemCls, prefMenuItem, "setEnabled", new Object[] { true } );
+
+        // Set the action to execute when the About or Preferences menuItem is invoked.
+        //
+        // We don't need to set the target here as the current target is the SWTApplicationDelegate
+        // and we have registerd the new selectors on it. So just set the new action to invoke the
+        // selector.
+        invoke( nsmenuitemCls, prefMenuItem, "setAction",
+                new Object[] { wrapPointer( sel_preferencesMenuItemSelected_ ) } );
+        invoke( nsmenuitemCls, aboutMenuItem, "setAction",
+                new Object[] { wrapPointer( sel_aboutMenuItemSelected_ ) } );
+    }
+
+    private long registerName( Class<?> osCls, String name )
+            throws IllegalArgumentException, SecurityException, IllegalAccessException,
+            InvocationTargetException, NoSuchMethodException {
+        Object object = invoke( osCls, "sel_registerName", new Object[] { name } );
+        return convertToLong( object );
+    }
+
+    private long convertToLong( Object object ) {
+        if ( object instanceof Integer ) {
+            Integer i = (Integer) object;
+            return i.longValue();
+        }
+        if ( object instanceof Long ) {
+            Long l = (Long) object;
+            return l.longValue();
+        }
+        return 0;
+    }
+
+    private static Object wrapPointer( long value ) {
+        Class<?> PTR_CLASS = C.PTR_SIZEOF == 8 ? long.class : int.class;
+        if ( PTR_CLASS == long.class ) {
+            return new Long( value );
+        } else {
+            return new Integer( (int) value );
+        }
+    }
+
+    private static Object invoke( Class<?> clazz, String methodName, Object[] args ) {
+        return invoke( clazz, null, methodName, args );
+    }
+
+    private static Object invoke( Class<?> clazz, Object target, String methodName, Object[] args ) {
+        try {
+            Class<?>[] signature = new Class<?>[args.length];
+            for ( int i = 0; i < args.length; i++ ) {
+                Class<?> thisClass = args[i].getClass();
+                if ( thisClass == Integer.class )
+                    signature[i] = int.class;
+                else if ( thisClass == Long.class )
+                    signature[i] = long.class;
+                else if ( thisClass == Byte.class )
+                    signature[i] = byte.class;
+                else if ( thisClass == Boolean.class )
+                    signature[i] = boolean.class;
+                else
+                    signature[i] = thisClass;
+            }
+            Method method = clazz.getMethod( methodName, signature );
+            return method.invoke( target, args );
+        } catch ( Exception e ) {
+            throw new IllegalStateException( e );
+        }
+    }
+
+    private Class<?> classForName( String classname ) {
+        try {
+            Class<?> cls = Class.forName( classname );
+            return cls;
+        } catch ( ClassNotFoundException e ) {
+            throw new IllegalStateException( e );
+        }
+    }
+
+    private Object invoke( Class<?> cls, String methodName ) {
+        return invoke( cls, methodName, (Class<?>[]) null, (Object[]) null );
+    }
+
+    private Object invoke( Class<?> cls, String methodName, Class<?>[] paramTypes, Object... arguments ) {
+        try {
+            Method m = cls.getDeclaredMethod( methodName, paramTypes );
+            return m.invoke( null, arguments );
+        } catch ( Exception e ) {
+            throw new IllegalStateException( e );
+        }
+    }
+
+    private Object invoke( Object obj, String methodName ) {
+        return invoke( obj, methodName, (Class<?>[]) null, (Object[]) null );
+    }
+
+    private Object invoke( Object obj, String methodName, Class<?>[] paramTypes, Object... arguments ) {
+        try {
+            Method m = obj.getClass().getDeclaredMethod( methodName, paramTypes );
+            return m.invoke( obj, arguments );
+        } catch ( Exception e ) {
+            throw new IllegalStateException( e );
+        }
+    }
+}