public static Object loadFrame( JopSession session, String className, String instance, boolean scrollbar) throws ClassNotFoundException { if (className.indexOf(".pwg") != -1) { GrowFrame frame = new GrowFrame( className, session.getGdh(), instance, new GrowFrameCb(session), session.getRoot()); frame.validate(); frame.setVisible(true); } else { Object frame; if (instance == null) instance = ""; JopLog.log( "JopSpider.loadFrame: Loading frame \"" + className + "\" instance \"" + instance + "\""); try { Class clazz = Class.forName(className); try { Class argTypeList[] = new Class[] {session.getClass(), instance.getClass(), boolean.class}; Object argList[] = new Object[] {session, instance, new Boolean(scrollbar)}; System.out.println("JopSpider.loadFrame getConstructor"); Constructor constructor = clazz.getConstructor(argTypeList); try { frame = constructor.newInstance(argList); } catch (Exception e) { System.out.println( "Class instanciation error: " + className + " " + e.getMessage() + " " + constructor); return null; } // frame = clazz.newInstance(); JopLog.log("JopSpider.loadFrame openFrame"); openFrame(frame); return frame; } catch (NoSuchMethodException e) { System.out.println("NoSuchMethodException: Unable to get frame constructor " + className); } catch (Exception e) { System.out.println( "Exception: Unable to get frame class " + className + " " + e.getMessage()); } } catch (ClassNotFoundException e) { System.out.println("Class not found: " + className); throw new ClassNotFoundException(); } return null; } return null; }
/** * Create the default projection for the default class * * @return a default projection */ private ProjectionImpl makeDefaultProjection() { // the default constructor try { Constructor c = projClass.getConstructor(VOIDCLASSARG); return (ProjectionImpl) c.newInstance(VOIDOBJECTARG); } catch (Exception ee) { System.err.println( "ProjectionManager makeDefaultProjection failed to construct class " + projClass); System.err.println(" " + ee); return null; } }
/** Try to create a Java object using a one-string-param constructor. */ public static Object newStringConstructor(String type, String param) throws Exception { Constructor c = Utils.getClass(type).getConstructor(String.class); try { return c.newInstance(param); } catch (InvocationTargetException e) { Throwable t = e.getTargetException(); if (t instanceof Exception) { throw (Exception) t; } else { throw e; } } }
/** Look on disk for an editor with the class name 'ocName'. */ PluggableEditor loadEditorFromDisk(String ocName) { // if here, we need to look on disk for a pluggable editor class... log.finer("looking for ocName: " + ocName); try { Class c = myLoader.loadClass(ocName); Constructor constructor = c.getConstructor(new Class[0]); // XXX If the pluggable editor has an error in the constructor, under some // XXX circumstances it can fail so badly that this call never returns, and // XXX the thread hangs! It doesn't even get to the exception handler below... // XXX but sometimes if the constructor fails everything works as expected. Wierd. PluggableEditor editor = (PluggableEditor) constructor.newInstance(new Object[0]); editors.put(ocName, editor); // add the new editor to our list return editor; } catch (Exception e) // expected condition - just means no pluggable editor available { if (e instanceof InvocationTargetException) // rare exception - an error was encountered in the plugin's // constructor. { log.warning("unable to load special editor for: '" + ocName + "' " + e); if (JXConfig.debugLevel >= 1) { log.warning("Error loading plugin class: "); ((InvocationTargetException) e).getTargetException().printStackTrace(); } } log.log(Level.FINEST, "'Expected' Error loading " + ocName, e); editors.put(ocName, NONE); // add a blank place holder - we can't load // an editor for this, and there's no point looking again. (change if want dynamic loading, // i.e. look *every* time) } return null; // only here if an error has occured. }