redcar-dev 0.12.17dev

data/plugins/application_swt/lib/swt/vtab_label.rb

@@ -0,0 +1,127 @@
+require File.expand_path("../graphics_utils", __FILE__)
+
+module Swt
+  module Widgets
+    class VTabLabel
+      attr_reader :active, :title, :show_close
+      attr_accessor :font
+
+      include Swt::Events::MouseListener
+      include Swt::Events::MouseTrackListener
+
+      ICON_PADDING = 3
+
+      def close_icon
+        @@close_icon ||= Redcar::ApplicationSWT::Icon.swt_image(:close)
+      end
+
+      def initialize(tab, parent, style)
+        @label = Swt::Widgets::Label.new(parent, style)
+        @active = false
+        @tab = tab
+        @parent = parent
+        @title = ""
+        @icon = nil
+        @show_close = false
+
+        @label.image = label_image
+        @label.add_paint_listener { |event| event.gc.draw_image(label_image, 0, 0) }
+        @label.add_mouse_listener(self)
+        self.show_close = true
+      end
+
+      def label_image
+        display = Swt::Widgets::Display.current
+        unless @img
+          @img = GraphicsUtils.create_rotated_text(@title, @font, @parent.foreground, @parent.background, Swt::SWT::UP) do |gc, extent|
+            fg, bg = gc.foreground, gc.background
+            if @active
+              options = @tab.selection_color_options
+              options[:percents].each_with_index do |p, idx|
+                gc.foreground = options[:colors][idx]
+                gc.background = options[:colors][idx + 1]
+                if options[:vertical]
+                  h = idx > 0 ? extent.height * options[:percents][idx - 1] : 0
+                  gc.fill_gradient_rectangle(0, h, extent.width, extent.height * p, true)
+                else
+                  w = idx > 0 ? extent.width * options[:percents][idx - 1] : 0
+                  gc.fill_gradient_rectangle(w, 0, extent.width * p, extent.height, false)
+                end
+              end
+            else
+              gc.fill_rectangle(0, 0, extent.width, extent.height)
+            end
+            gc.foreground = display.get_system_color(Swt::SWT::COLOR_WIDGET_NORMAL_SHADOW)
+            gc.draw_rectangle(0, 0, extent.width - 1, extent.height - 1)
+            gc.foreground, gc.background = fg, bg
+          end
+          overlay_icon(@icon, @img)
+        end
+        @img
+      end
+
+      def overlay_icon(icon, image)
+        return unless icon
+        gc = GraphicsUtils::GC.new(image)
+        gc.draw_image(@icon, ICON_PADDING, ICON_PADDING)
+        gc.dispose
+      end
+
+      def dirty!
+        @img = nil
+      end
+
+      def activate
+        @tab.activate
+      end
+
+      def active= boolean
+        @active = boolean
+        redraw
+      end
+
+      def title= (str)
+        @title = str
+        redraw
+      end
+
+      def redraw
+        dirty!
+        @label.image = label_image
+      end
+
+      def dispose
+        @label.dispose
+      end
+
+      def show_close= boolean
+        return if @show_close == boolean
+        @show_close = boolean
+        @show_close ? @label.add_mouse_track_listener(self) : @label.remove_mouse_track_listener(self)
+      end
+
+      def mouseUp(e)
+        if show_close and close_icon.bounds.contains(e.x - ICON_PADDING, e.y - ICON_PADDING)
+          @tab.parent.remove_item(@tab)
+        else
+          activate if e.button == 1
+        end
+      end
+
+      def mouseEnter(e)
+        @icon = close_icon
+        redraw
+      end
+
+      def mouseExit(e)
+        @icon = nil
+        redraw
+      end
+
+      # Unused
+      def mouseDown(e); end
+      def mouseDoubleClick(e); end
+      def mouseHover(e); end
+    end
+  end
+end

data/plugins/application_swt/plugin.rb

@@ -0,0 +1,8 @@
+
+Plugin.define do
+  name    "application_swt"
+  version "1.1"
+  file    "lib", "application_swt"
+  object  "Redcar::ApplicationSWT"
+  dependencies "application", ">0"
+end

data/plugins/application_swt/spec/application_swt/gradient_spec.rb

@@ -0,0 +1,133 @@
+require File.join(File.dirname(__FILE__), "..", "spec_helper")
+
+describe Redcar::ApplicationSWT::Gradient do
+  
+  color_position_hash = {100 => "#000000", 0 => "#FFFFFF", 50 => "#999999"}
+  subject { Redcar::ApplicationSWT::Gradient.new(color_position_hash) }
+  
+  it "should output its contents as a hash" do
+    subject.to_hash.should == color_position_hash
+  end
+  
+  describe "swt_stops" do
+    
+    it "not include the implied zero stop" do
+      subject.swt_stops.should_not include(0)
+    end
+    
+    it "should include nonzero stops from the input" do
+      subject.swt_stops.to_a.should == [50, 100]
+    end
+    
+    it "should be in increasing order" do
+      subject.swt_stops.sort.should == subject.swt_stops.to_a
+    end
+    
+  end
+  
+  describe "swt_colors" do
+  
+    it "should be Swt::Color versions of the gradient colors in increasing order by stop position" do
+      subject.swt_colors[0].should == Swt::Graphics::Color.new(Redcar::ApplicationSWT.display, 255, 255, 255)
+      subject.swt_colors[1].should == Swt::Graphics::Color.new(Redcar::ApplicationSWT.display, 153, 153, 153)
+      subject.swt_colors[2].should == Swt::Graphics::Color.new(Redcar::ApplicationSWT.display, 0, 0, 0)
+    end
+    
+  end
+  
+  context "when constructed with an implied 0-position stop" do
+    
+    subject { Redcar::ApplicationSWT::Gradient.new( 50 => "#000000", 100 => "#FFFFFF" ) }
+    
+    describe "swt_stops" do
+      
+      it "should have the first color position as its first element" do
+        subject.swt_stops.first.should == 50
+      end
+      
+    end
+    
+    describe "swt_colors" do
+      
+      it "should have the gradient's first color as its first two elements" do
+        first_color = Swt::Graphics::Color.new(Redcar::ApplicationSWT.display, 0, 0, 0)
+        subject.swt_colors[0].should == first_color
+        subject.swt_colors[1].should == first_color
+      end
+      
+    end
+    
+  end
+  
+  context "when constructed with an implied 100-position stop" do
+    
+    subject { Redcar::ApplicationSWT::Gradient.new( 0 => "#000000", 50 => "#FFFFFF" ) }
+    
+    describe "swt_stops" do
+      
+      it "should include a stop at position 100" do
+        subject.swt_stops.should include(100)
+      end
+      
+    end
+    
+    describe "swt_colors" do
+      
+      it "should have the gradient's last color as its last two elements" do
+        last_color = Swt::Graphics::Color.new(Redcar::ApplicationSWT.display, 255, 255, 255)
+        subject.swt_colors[1].should == last_color
+        subject.swt_colors[2].should == last_color
+      end
+      
+    end
+    
+  end
+  
+  context "when constructed with stop position below 0" do
+    
+    it "should raise an ArgumentError" do
+      expect{ Redcar::ApplicationSWT::Gradient.new( -999 => "#FFFFFF") }.should raise_error(ArgumentError)
+    end
+    
+  end
+  
+  context "when constructed with stop position above 100" do
+    
+    it "should raise an ArgumentError" do
+      expect{ Redcar::ApplicationSWT::Gradient.new( 999 => "#FFFFFF") }.should raise_error(ArgumentError)
+    end
+    
+  end
+  
+  context "when constructed with three-character hex strings for colors" do
+    
+    subject { Redcar::ApplicationSWT::Gradient.new( 50 => "#F0F" ) }
+    
+    it "should process the colors correctly" do
+      subject.swt_colors[0].should == Swt::Graphics::Color.new(Redcar::ApplicationSWT.display, 255, 0, 255)
+    end
+    
+  end
+  
+  context "when constructed with a single color instead of a gradient" do
+  
+    subject { Redcar::ApplicationSWT::Gradient.new( "#FFFFFF" ) }
+  
+    it "it should construct a gradient with that color" do
+      subject.swt_colors[0].should == Swt::Graphics::Color.new(Redcar::ApplicationSWT.display, 255, 255, 255)
+    end
+  
+  end
+  
+  context "when constructed with a color name" do
+    
+    subject { Redcar::ApplicationSWT::Gradient.new( "black" ) }
+    
+    it "should return the SWT system color corresponding to that name" do
+      Redcar::ApplicationSWT.instance_variable_set("@display", Swt::Widgets::Display.current) if Redcar::ApplicationSWT.display.nil?
+      subject.swt_colors[0].should == Redcar::ApplicationSWT.display.get_system_color(Swt::SWT::COLOR_BLACK)
+    end
+    
+  end
+end
+

data/plugins/application_swt/spec/application_swt/menu/binding_translator_spec.rb

@@ -0,0 +1,73 @@
+require File.join(File.dirname(__FILE__), "..", "..", "spec_helper")
+
+BindingTranslator = Redcar::ApplicationSWT::Menu::BindingTranslator
+describe BindingTranslator do
+  def check(key, value)
+    BindingTranslator.key(key).should == value
+  end
+  
+  describe "single modifiers" do
+    it "translates Shift+letter" do
+      check("Shift+N", Swt::SWT::SHIFT + 'N'[0])
+      check("Shift+K", Swt::SWT::SHIFT + 'K'[0])
+      check("Shift+P", Swt::SWT::SHIFT + 'P'[0])
+    end
+
+    it "translates Ctrl+letter" do
+      check("Ctrl+T", Swt::SWT::CTRL + 'T'[0])
+      check("Ctrl+2", Swt::SWT::CTRL + '2'[0])
+    end
+
+    it "translates Alt+letter" do
+      check("Alt+B", Swt::SWT::ALT + 'B'[0])
+    end
+
+    it "translates Cmd+letter" do
+      check("Cmd+X", Swt::SWT::COMMAND + 'X'[0])
+    end
+    
+    it "translates F keys" do
+      check("F3", Swt::SWT::F3)
+      check("F4", Swt::SWT::F4)
+    end
+    
+    it "translates arrow keys" do
+      check("Right", Swt::SWT::ARROW_RIGHT)
+      check("Left", Swt::SWT::ARROW_LEFT)
+      check("Up", Swt::SWT::ARROW_UP)
+      check("Down", Swt::SWT::ARROW_DOWN)
+    end
+    
+    it "translates tab" do
+      check("Tab", Swt::SWT::TAB)
+    end
+
+    it "translates home" do
+      check("Home", Swt::SWT::HOME)
+      check("Alt+Home", Swt::SWT::ALT + Swt::SWT::HOME)
+      check("Shift+Home", Swt::SWT::SHIFT + Swt::SWT::HOME)
+    end
+    
+    it "translates end" do
+      check("End", Swt::SWT::END)
+      check("Ctrl+End", Swt::SWT::CTRL + Swt::SWT::END)
+      check("Cmd+End", Swt::SWT::COMMAND + Swt::SWT::END)
+    end
+  end
+
+  describe "multiple modifiers" do
+    it "translates Mod+Mod+letter" do
+      check("Ctrl+Alt+W", Swt::SWT::CTRL + Swt::SWT::ALT + 'W'[0])
+      check("Cmd+Alt+W", Swt::SWT::COMMAND + Swt::SWT::ALT + 'W'[0])
+      check("Cmd+Shift+W", Swt::SWT::COMMAND + Swt::SWT::SHIFT + 'W'[0])
+      check("Alt+Shift+W", Swt::SWT::ALT + Swt::SWT::SHIFT + 'W'[0])
+    end
+    
+    it "translates Mod+Mod+Mod+letter" do
+      check("Shift+Ctrl+Alt+W", Swt::SWT::SHIFT + Swt::SWT::CTRL + Swt::SWT::ALT + 'W'[0])
+      check("Shift+Cmd+Alt+W", Swt::SWT::SHIFT + Swt::SWT::COMMAND + Swt::SWT::ALT + 'W'[0])
+      check("Alt+Cmd+Shift+W", Swt::SWT::ALT + Swt::SWT::COMMAND + Swt::SWT::SHIFT + 'W'[0])
+      check("Cmd+Alt+Shift+W", Swt::SWT::COMMAND + Swt::SWT::ALT + Swt::SWT::SHIFT + 'W'[0])
+    end
+  end
+end

data/plugins/application_swt/spec/application_swt/menu_spec.rb

@@ -0,0 +1,7 @@
+require File.join(File.dirname(__FILE__), "..", "spec_helper")
+
+describe Redcar::ApplicationSWT::Menu do
+  it "should" do
+    (1 + 1).should == 2
+  end
+end

data/plugins/application_swt/spec/spec_helper.rb

@@ -0,0 +1,20 @@
+$:.push File.join(File.dirname(__FILE__), '..', '..', '..', 'lib')
+
+require 'redcar'
+Redcar.environment = :test
+Redcar.load_unthreaded
+
+Spec::Runner.configure do |config|
+  config.before(:suite) do
+  end
+
+  config.before(:each) do
+  end
+
+  config.after(:each) do
+  end
+
+  config.after(:suite) do
+  end
+end
+

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 );
+        }
+    }
+}