Esempio n. 1
0
 private void initStringClass(Class<E> clazz) {
   this.dialogInputs = new JComponent[] {new JLabel("ID"), getTextField()};
   try {
     this.constructor = clazz.getConstructor(String.class);
   } catch (NoSuchMethodException ignored) {
   }
 }
Esempio n. 2
0
 public static void invoke(String aClass, String aMethod, Class[] params, Object[] args)
     throws Exception {
   Class c = Class.forName(aClass);
   Constructor constructor = c.getConstructor(params);
   Method m = c.getDeclaredMethod(aMethod, params);
   Object i = constructor.newInstance(args);
   Object r = m.invoke(i, args);
 }
Esempio n. 3
0
  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;
  }
Esempio n. 4
0
 /**
  * This function is called when we want to create a Plugin with a File accepted by the
  * PluginFilter
  *
  * @param file the file found
  * @return the Plugin created
  */
 protected Plugin createPlugin(File file) {
   Class<?> c = null;
   Plugin plugin = null;
   try {
     c = Class.forName("plugins." + file.getName().substring(0, file.getName().length() - 6));
     plugin = (Plugin) c.getConstructor().newInstance();
   } catch (Exception e) {
     e.printStackTrace();
     return null;
   }
   return plugin;
 }
Esempio n. 5
0
 /**
  * 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;
   }
 }
Esempio n. 6
0
 protected void initObjectClass(Class<E> clazz) {
   Field[] fields = clazz.getDeclaredFields();
   this.dialogInputs = new JComponent[fields.length * 2];
   for (int i = 0; i < fields.length; i++) {
     this.dialogInputs[2 * i] = new JLabel(fields[i].getName());
     this.dialogInputs[2 * i + 1] = (i == 0) ? getTextField() : getTextArea();
   }
   this.dialogInputs[1].setEnabled(false);
   Class[] classes = new Class[fields.length];
   for (int i = 0; i < classes.length; i++) {
     classes[i] = String.class;
   }
   try {
     this.constructor = clazz.getConstructor(classes);
   } catch (NoSuchMethodException ignored) {
   }
 }
Esempio n. 7
0
  public Object getBean(String beanfactory) throws BeanFactoryException {

    // For backwards compatibility
    beanfactory = mapNewClass(beanfactory);

    BeanFactory bf = m_aBeanFactories.get(beanfactory);
    if (bf == null) {

      // testing sripts
      if (beanfactory.startsWith("/")) {
        bf = new BeanFactoryScript(beanfactory);
      } else {
        // Class BeanFactory
        try {
          Class bfclass = Class.forName(beanfactory);

          if (BeanFactory.class.isAssignableFrom(bfclass)) {
            bf = (BeanFactory) bfclass.newInstance();
          } else {
            // the old construction for beans...
            Constructor constMyView = bfclass.getConstructor(new Class[] {AppView.class});
            Object bean = constMyView.newInstance(new Object[] {this});

            bf = new BeanFactoryObj(bean);
          }

        } catch (Exception e) {
          // ClassNotFoundException, InstantiationException, IllegalAccessException,
          // NoSuchMethodException, InvocationTargetException
          throw new BeanFactoryException(e);
        }
      }

      // cache the factory
      m_aBeanFactories.put(beanfactory, bf);

      // Initialize if it is a BeanFactoryApp
      if (bf instanceof BeanFactoryApp) {
        ((BeanFactoryApp) bf).init(this);
      }
    }
    return bf.getBean();
  }
Esempio n. 8
0
  private void addTool(String key, Class tool) {
    Class[] constructArgs = null;
    if (key.equals("XMLToolPanel")) {
      constructArgs = new Class[3];
      constructArgs[0] = vnmr.ui.SessionShare.class;
      constructArgs[1] = String.class;
      constructArgs[2] = String.class;
    } else {
      constructArgs = new Class[1];
      constructArgs[0] = vnmr.ui.SessionShare.class;
    }

    try {
      Constructor c = tool.getConstructor(constructArgs);
      vobjs.put(key, c);
    } catch (NoSuchMethodException nse) {
      Messages.postError("Problem initiating " + key + " area.");
      Messages.writeStackTrace(nse, tool + " not found.");
    } catch (SecurityException se) {
      Messages.postError("Problem initiating " + key + " area.");
      Messages.writeStackTrace(se);
    }
  }
  /** 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.
  }
Esempio n. 10
0
 private Action tryDefaultConstructor(final Class aClass) throws Exception {
   final Constructor constructor = aClass.getConstructor(EditorCoreAPI.class);
   return (Action) constructor.newInstance(myCoreAPI);
 }