How to open a JPanel

Question

Hi
I have created a JPanel in JDeveloper 10.1.3. It has a main method with (see below) but when opened from my application I must use something else than JUTestFrame but what? How should the JPanel be opened the right way?
public static void main(String [] args) {
try {
UIManager.setLookAndFeel("com.jgoodies.looks.plastic.PlasticXPLookAndFeel");
} catch (ClassNotFoundException cnfe) {
try {
UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
} catch (Exception exemp) {
exemp.printStackTrace();
} catch (Exception exemp) {
exemp.printStackTrace();
CurrencyRateEdit panel = new CurrencyRateEdit();
panel.setBindingContext(JUTestFrame.startTestFrame("mypackage.DataBindings.cpx", "null", panel, panel.getPanelBinding(), new Dimension(400,300)));
panel.revalidate();
}

Answer 1

Thanks for the input, unfortunately using the JFrame provided by the JDev wizard is what we are trying to avoid. We do not want a JFrame of any kind.
I have it working now with a JPanel as the top level container for the ADF plumbing. This allows me to place the ADF bindings virtually anywhere without any type of boarders. Here is how I did it. (by the way I am still testing out Erik's recommendation)
1) create a default application with an empty runable panel. (the main() can be moved out later but makes it easy for testing) The code here assumes you are using all the default naming in the wizard. If not you will have to make the appropriate changes.
2) Just under the class definition create an instance of a class named "appPanel". This class will be defined below and is a gutted/modified version of JUTestFrame which extends JPanel instead of JFrame. It should look something like this:
public class Panel1 extends JPanel implements JUPanel {       
public appPanel canvas = new appPanel();
3) In the main() function change
panel.setBindingContext(JUTestFrame.startTestFrame( ...
to:
panel.setBindingContext(panel.canvas.startTestFrame( ... //canvas is the name I chose in step 2.
4) If, in this test app, you don't already have a container (JForm or other) for the ADF JPanel you can create one for testing like this:
At the bottom of the main() function put :
JFrame xx = new JFrame();
xx.add(panel);
xx.setVisible(true);
5) Create the class file appPanel (menu: new >simple file > Java Class. and replace all of the contents with: (excuse the formatting. I don't know why they don't make developer forums more code friendly)
package mypackage;
import java.awt.Dimension;
import java.awt.Toolkit;
import java.awt.GridLayout;
import java.awt.event.KeyEvent;
import java.beans.PropertyVetoException;
import javax.swing.JPanel;
import javax.swing.JInternalFrame;
import javax.swing.JScrollPane;
import java.util.HashMap;
import oracle.jbo.uicli.UIMessageBundle;
import oracle.jbo.uicli.jui.JUPanelBinding;
import oracle.jbo.uicli.jui.JUEnvInfoProvider;
import oracle.jbo.uicli.controls.JUErrorHandlerDlg;
import oracle.jbo.uicli.controls.JClientPanel;
import oracle.jbo.uicli.binding.JUApplication;
import oracle.jbo.uicli.mom.JUMetaObjectManager;
import oracle.adf.model.BindingContext;
import oracle.adf.model.DataControlFactory;
import oracle.adf.model.binding.DCDataControl;
import oracle.jbo.uicli.controls.*;
public class appPanel extends JPanel
private JUPanelBinding panelBinding = null;
private DCDataControl dataControl;
private BindingContext mCtx;
appPanel frame;
public appPanel() {
try {
jbInit();
} catch (Exception e) {
e.printStackTrace();
public BindingContext startTestFrame(String cpxName, String dcName, JPanel panel, JUPanelBinding panelBinding, Dimension size)
if (!(panel instanceof JUPanel))
System.err.println(UIMessageBundle.getResString(UIMessageBundle.STR_TUI_ERROR_JCLIENTPANEL));
return null;
frame = new appPanel(cpxName, dcName, panelBinding, panel);
frame.adjustFrameSize(size);
return frame.getBindingContext();
public appPanel(JUPanelBinding designTimePanelBinding, JPanel panel)
this.setLayout(new GridLayout());
JScrollPane scPane = new JScrollPane(panel);
this.add(scPane);
JUMetaObjectManager.setBaseErrorHandler(new JUErrorHandlerDlg());
//mom will pass properties in case it's null
JUApplication app = JUMetaObjectManager.createApplicationObject(designTimePanelBinding.getApplicationName(), null, new JUEnvInfoProvider());
panelBinding = new JUPanelBinding(designTimePanelBinding.getApplicationName(), panel);
panelBinding.setApplication(app);
((JClientPanel)panel).setPanelBinding(panelBinding);
panelBinding.execute();
dataControl = app;
public appPanel(String cpxName, String dcName, JUPanelBinding panelBinding, JPanel panel)
this.setLayout(new GridLayout());
JScrollPane scPane = new JScrollPane(panel);
this.add(scPane);
createBindingCtxAndSetUpMenu(cpxName, dcName, panelBinding);
private void createBindingCtxAndSetUpMenu(String cpxName, String dcName, JUPanelBinding panelBinding)
JUMetaObjectManager.setBaseErrorHandler(new JUErrorHandlerDlg());
JUMetaObjectManager.getJUMom().setJClientDefFactory(null);
mCtx = new BindingContext();
HashMap map = new HashMap(4);
map.put(DataControlFactory.APP_PARAMS_BINDING_CONTEXT, mCtx);
JUMetaObjectManager.loadCpx(cpxName, map);
DCDataControl app = (DCDataControl)mCtx.get(dcName);
if (app != null)
dataControl = app;
app.setClientApp(DCDataControl.JCLIENT);
else
mCtx.setClientAppType(DCDataControl.JCLIENT);
panelBinding = panelBinding.setup(mCtx, null);
public DCDataControl getDataControl()
return dataControl;
public BindingContext getBindingContext()
return mCtx;
void adjustFrameSize(Dimension size)
setSize(size);
Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize();
if (size.height > screenSize.height)
size.height = screenSize.height;
if (size.width > screenSize.width)
size.width = screenSize.width;
setLocation((screenSize.width - size.width) / 2, (screenSize.height - size.height) / 2);
setVisible(true);
private static final char MNEMONICINDICATOR = '&';
public static final int MNEMONIC_INDEX_NONE = -1;
* Returns the key code for the mnemonic in the string. Returns
* VK_UNDEFINED if the string does not contain a mnemonic.
public int getMnemonicKeyCode(String string)
if (string == null)
return KeyEvent.VK_UNDEFINED;
// Minus one, because a trailing ampersand doesn't count
int lengthMinusOne = string.length() - 1;
int i = 0; // Index in the source sting
while (i < lengthMinusOne)
int index = string.indexOf(_MNEMONIC_INDICATOR, i);
// Are we at the end of the string?
if ((index == -1) || (index >= lengthMinusOne))
break;
char ch = string.charAt(index + 1);
// if this isn't a double ampersand, return
if (ch != MNEMONICINDICATOR)
// VK_* constants are all for upper case characters
return(int) Character.toUpperCase(ch);
// Skip over the double ampersand
i = index + 2;
return KeyEvent.VK_UNDEFINED;
* Removes non-displayable inline mnemonic characters.
* In order to specify a mnemonic character in a translatable string
* (eg. in a resource file), a special character is used to indicate which
* character in the string should be treated as the mnemonic. This method
* assumes that an ampersand ('&') character is used as the mnemonic
* indicator, and removes (single) ampersands from the input string. A
* double ampersand sequence is used to indicate that an ampersand should
* actually appear in the output stream, in which case one of the ampersands
* is removed.
* Clients should call this method after calling
* StringUtils.getMnemonicIndex() and before displaying the string. The
* returned string should be used in place of the input string when
* displaying the string to the end user. The returned string may be the
* same as the input string if no mnemonic indicator characters are found,
* but this is not guaranteed.
* @see #getMnemonicIndex
public String stripMnemonic(String string)
if (string == null)
return null;
int length = string.length();
// Single character (or empty) strings can't have a mnemonic
if (length <= 1)
return string;
StringBuffer buffer = null;
int i = 0;
while (i < length)
int index = string.indexOf(_MNEMONIC_INDICATOR, i);
// We've reached the append. Append the rest of the
// string to the buffer, if one exists, then exit
if ((index < 0) || (index >= length - 1))
if (buffer != null)
buffer.append(string.substring(i));
break;
if (buffer == null)
// If the string starts with an ampersand, but not a double
// ampersand, then we just want to return
// stripMnemonic(string.substring(1)). This is basically
// what we do here, only I've optimized the tail recursion away.
if ((index == 0) && (string.charAt(1) != MNEMONICINDICATOR))
string = string.substring(1);
length--;
continue;
else
// Allocate the buffer. We can reserve only space
// (length - 1), because, by now, we know there's at least
// 1 ampersand
buffer = new StringBuffer(length - 1);
// Append the bits of the string before the ampersand
buffer.append(string.substring(i, index));
// And append the character after the ampersand
buffer.append(string.charAt(index + 1));
// And skip to after that character
i = index + 2;
// If we never allocated a buffer, then there's no mnemonic
// at all, and we can just return the whole string
if (buffer == null)
return string;
return new String(buffer);
private void jbInit() throws Exception {
And now you have an ADF implementation that exists purely in a JPanel to be placed anywhere.
Again I am still testing Erik's recomendation which may prove to be a better implementation; but I wanted to share what I have working.
I hope this helps someone out. Good luck.
SMartel