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;
}
}
/**
* Create a default object of the given type. Prefers constructors with as few arguments as
* possible. Creates an empty proxy for interfaces.
*
* @param type type to instantiate
* @return default instance
* @throws Exception if the default instance could not be created
*/
private static Object instantiateType(Class<?> type) throws Exception {
if (type.isPrimitive()) return Defaults.defaultValue(type);
else if (type == Void.class) return null;
else if (type.isArray()) return Array.newInstance(type, 0);
else if (type.isInterface())
return Proxy.newProxyInstance(
type.getClassLoader(),
new Class[] {type},
new InvocationHandler() {
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
return null;
}
});
// Take a constructor with as few params as possible
Constructor constructor = type.getDeclaredConstructors()[0];
for (Constructor<?> c : type.getDeclaredConstructors()) {
if (c.getParameterTypes().length < constructor.getParameterTypes().length) constructor = c;
}
Object[] params = new Object[constructor.getParameterTypes().length];
for (int i = 0; i < constructor.getParameterTypes().length; i++) {
params[i] = instantiateType(constructor.getParameterTypes()[i]);
}
return constructor.newInstance(params);
}
/** 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.
}
/**
* Creates a new <code>java.awt.Frame</code>. This frame is the root for the AWT components that
* will be embedded within the composite. In order for the embedding to succeed, the composite
* must have been created with the SWT.EMBEDDED style.
*
* <p>IMPORTANT: As of JDK1.5, the embedded frame does not receive mouse events. When a
* lightweight component is added as a child of the embedded frame, the cursor does not change. In
* order to work around both these problems, it is strongly recommended that a heavyweight
* component such as <code>java.awt.Panel</code> be added to the frame as the root of all
* components.
*
* @param parent the parent <code>Composite</code> of the new <code>java.awt.Frame</code>
* @return a <code>java.awt.Frame</code> to be the parent of the embedded AWT components
* @exception IllegalArgumentException
* <ul>
* <li>ERROR_NULL_ARGUMENT - if the parent is null
* <li>ERROR_INVALID_ARGUMENT - if the parent Composite does not have the SWT.EMBEDDED style
* </ul>
*
* @since 3.0
*/
public static Frame new_Frame(final Composite parent) {
if (parent == null) SWT.error(SWT.ERROR_NULL_ARGUMENT);
if ((parent.getStyle() & SWT.EMBEDDED) == 0) {
SWT.error(SWT.ERROR_INVALID_ARGUMENT);
}
final int /*long*/ handle = parent.view.id;
Class clazz = null;
try {
String className =
embeddedFrameClass != null ? embeddedFrameClass : "apple.awt.CEmbeddedFrame";
if (embeddedFrameClass == null) {
clazz = Class.forName(className, true, ClassLoader.getSystemClassLoader());
} else {
clazz = Class.forName(className);
}
} catch (ClassNotFoundException cne) {
SWT.error(SWT.ERROR_NOT_IMPLEMENTED, cne);
} catch (Throwable e) {
SWT.error(SWT.ERROR_UNSPECIFIED, e, " [Error while starting AWT]");
}
initializeSwing();
Object value = null;
Constructor constructor = null;
try {
constructor = clazz.getConstructor(new Class[] {long.class});
value = constructor.newInstance(new Object[] {new Long(handle)});
} catch (Throwable e) {
SWT.error(SWT.ERROR_NOT_IMPLEMENTED, e);
}
final Frame frame = (Frame) value;
frame.addNotify();
parent.setData(EMBEDDED_FRAME_KEY, frame);
/* Forward the iconify and deiconify events */
final Listener shellListener =
new Listener() {
public void handleEvent(Event e) {
switch (e.type) {
case SWT.Deiconify:
EventQueue.invokeLater(
new Runnable() {
public void run() {
frame.dispatchEvent(new WindowEvent(frame, WindowEvent.WINDOW_DEICONIFIED));
}
});
break;
case SWT.Iconify:
EventQueue.invokeLater(
new Runnable() {
public void run() {
frame.dispatchEvent(new WindowEvent(frame, WindowEvent.WINDOW_ICONIFIED));
}
});
break;
}
}
};
Shell shell = parent.getShell();
shell.addListener(SWT.Deiconify, shellListener);
shell.addListener(SWT.Iconify, shellListener);
/*
* Generate the appropriate events to activate and deactivate
* the embedded frame. This is needed in order to make keyboard
* focus work properly for lightweights.
*/
Listener listener =
new Listener() {
public void handleEvent(Event e) {
switch (e.type) {
case SWT.Dispose:
Shell shell = parent.getShell();
shell.removeListener(SWT.Deiconify, shellListener);
shell.removeListener(SWT.Iconify, shellListener);
parent.setVisible(false);
EventQueue.invokeLater(
new Runnable() {
public void run() {
try {
frame.dispose();
} catch (Throwable e) {
}
}
});
break;
case SWT.FocusIn:
EventQueue.invokeLater(
new Runnable() {
public void run() {
if (frame.isActive()) return;
try {
Class clazz = frame.getClass();
Method method =
clazz.getMethod(
"synthesizeWindowActivation", new Class[] {boolean.class});
if (method != null)
method.invoke(frame, new Object[] {new Boolean(true)});
} catch (Throwable e) {
e.printStackTrace();
}
}
});
break;
case SWT.Deactivate:
EventQueue.invokeLater(
new Runnable() {
public void run() {
if (!frame.isActive()) return;
try {
Class clazz = frame.getClass();
Method method =
clazz.getMethod(
"synthesizeWindowActivation", new Class[] {boolean.class});
if (method != null)
method.invoke(frame, new Object[] {new Boolean(false)});
} catch (Throwable e) {
e.printStackTrace();
}
}
});
break;
}
}
};
parent.addListener(SWT.FocusIn, listener);
parent.addListener(SWT.Deactivate, listener);
parent.addListener(SWT.Dispose, listener);
parent
.getDisplay()
.asyncExec(
new Runnable() {
public void run() {
if (parent.isDisposed()) return;
final Rectangle clientArea = parent.getClientArea();
EventQueue.invokeLater(
new Runnable() {
public void run() {
frame.setSize(clientArea.width, clientArea.height);
frame.validate();
// Bug in Cocoa AWT? For some reason the frame isn't showing up on first
// draw.
// Toggling visibility seems to be the only thing that works.
frame.setVisible(false);
frame.setVisible(true);
}
});
}
});
return frame;
}
