swingx-master/swingx-core/src/main/java/org/jdesktop/swingx/JXDialog.java
/*
 * $Id$
 *
 * Copyright 2004 Sun Microsystems, Inc., 4150 Network Circle,
 * Santa Clara, California 95054, U.S.A. All rights reserved.
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 * 
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 * 
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */
package org.jdesktop.swingx;

import java.awt.Dialog;
import java.awt.Dimension;
import java.awt.Frame;
import java.awt.Window;
import java.util.Locale;

import javax.swing.Action;
import javax.swing.BorderFactory;
import javax.swing.Box;
import javax.swing.BoxLayout;
import javax.swing.JButton;
import javax.swing.JComponent;
import javax.swing.JDialog;
import javax.swing.JPanel;
import javax.swing.JToolBar;
import javax.swing.plaf.basic.BasicOptionPaneUI;

import org.jdesktop.beans.JavaBean;
import org.jdesktop.swingx.action.BoundAction;
import org.jdesktop.swingx.plaf.LookAndFeelAddons;
import org.jdesktop.swingx.plaf.UIManagerExt;

/**
 * First cut for enhanced Dialog. The idea is to have a pluggable content
 * from which the dialog auto-configures all its "dialogueness". 
 * 
 * <ul>
 * <li> accepts a content and configures itself from content's properties - 
 *  replaces the execute action from the appropriate action in content's action map (if any)
 *  and set's its title from the content's name. 
 * <li> registers stand-in actions for close/execute with the dialog's RootPane
 * <li> registers keyStrokes for esc/enter to trigger the close/execute actions
 * <li> takes care of building the button panel using the close/execute actions.
 * </ul> 
 * 
 * <ul>
 * <li>TODO: add link to forum discussion, wiki summary? 
 * <li>PENDING: add support for vetoing the close.
 * <li>PENDING: add complete set of constructors
 * <li>PENDING: add windowListener to delegate to close action
 * </ul>
 * 
 * @author Jeanette Winzenburg
 * @author Karl Schaefer
 */
@JavaBean
public class JXDialog extends JDialog {

    static {
        // Hack to enforce loading of SwingX framework ResourceBundle
        LookAndFeelAddons.getAddon();
    }
    
    public static final String EXECUTE_ACTION_COMMAND = "execute";
    public static final String CLOSE_ACTION_COMMAND = "close";
    public static final String UIPREFIX = "XDialog.";

    protected JComponent content;
    
    /**
     * Creates a non-modal dialog with the given component as 
     * content and without specified owner.  A shared, hidden frame will be
     * set as the owner of the dialog.
     * <p>
     * @param content the component to show and to auto-configure from.
     */
    public JXDialog(JComponent content) {
        super();
        setContent(content);
    }
    
    
    /**
     * Creates a non-modal dialog with the given component as content and the
     * specified <code>Frame</code> as owner.
     * <p>
     * @param frame the owner
     * @param content the component to show and to auto-configure from.
     */
    public JXDialog(Frame frame, JComponent content) {
        super(frame);
        setContent(content);
    }
    
    /**
     * Creates a non-modal dialog with the given component as content and the
     * specified <code>Dialog</code> as owner.
     * <p>
     * @param dialog the owner
     * @param content the component to show and to auto-configure from.
     */
    public JXDialog(Dialog dialog, JComponent content) {
        super(dialog);
        setContent(content);
    }
    
    /**
     * Creates a non-modal dialog with the given component as content and the
     * specified <code>Window</code> as owner.
     * <p>
     * @param window the owner
     * @param content the component to show and to auto-configure from.
     */
    public JXDialog(Window window, JComponent content) {
        super(window);
        setContentPane(content);
    }

    /**
     * {@inheritDoc}
     */
    @Override
    protected JXRootPane createRootPane() {
        return new JXRootPane();
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public JXRootPane getRootPane() {
        return (JXRootPane) super.getRootPane();
    }
    
    /**
     * Sets the status bar property on the underlying {@code JXRootPane}.
     * 
     * @param statusBar
     *            the {@code JXStatusBar} which is to be the status bar
     * @see #getStatusBar()
     * @see JXRootPane#setStatusBar(JXStatusBar)
     */
    public void setStatusBar(JXStatusBar statusBar) {
        getRootPane().setStatusBar(statusBar);
    }
    
    /**
     * Returns the value of the status bar property from the underlying
     * {@code JXRootPane}.
     * 
     * @return the {@code JXStatusBar} which is the current status bar
     * @see #setStatusBar(JXStatusBar)
     * @see JXRootPane#getStatusBar()
     */
    public JXStatusBar getStatusBar() {
        return getRootPane().getStatusBar();
    }

    /**
     * Sets the tool bar property on the underlying {@code JXRootPane}.
     * 
     * @param toolBar
     *            the {@code JToolBar} which is to be the tool bar
     * @see #getToolBar()
     * @see JXRootPane#setToolBar(JToolBar)
     */
    public void setToolBar(JToolBar toolBar) {
        getRootPane().setToolBar(toolBar);
    }
    
    /**
     * Returns the value of the tool bar property from the underlying
     * {@code JXRootPane}.
     * 
     * @return the {@code JToolBar} which is the current tool bar
     * @see #setToolBar(JToolBar)
     * @see JXRootPane#getToolBar()
     */
    public JToolBar getToolBar() {
        return getRootPane().getToolBar();
    }
    
    /**
     * PENDING: widen access - this could be public to make the content really 
     * pluggable?
     * 
     * @param content
     */
    private void setContent(JComponent content) {
        if (this.content != null) {
            throw new IllegalStateException("content must not be set more than once");
        }
        initActions();
        Action contentCloseAction = content.getActionMap().get(CLOSE_ACTION_COMMAND);
        if (contentCloseAction != null) {
            putAction(CLOSE_ACTION_COMMAND, contentCloseAction);
        }
        Action contentExecuteAction = content.getActionMap().get(EXECUTE_ACTION_COMMAND);
        if (contentExecuteAction != null) {
            putAction(EXECUTE_ACTION_COMMAND, contentExecuteAction);
        }
        this.content = content;
        build();
        setTitleFromContent();
    }

    /**
     * Infers and sets this dialog's title from the the content. 
     * Does nothing if content is null. 
     * 
     * Here: uses the content's name as title. 
     */
    protected void setTitleFromContent() {
        if (content == null) return;
        setTitle(content.getName());
    }

    /**
     * pre: content != null.
     *
     */
    private void build() {
        JComponent contentBox = new Box(BoxLayout.PAGE_AXIS); 
        contentBox.add(content);
        JComponent buttonPanel = createButtonPanel();
        contentBox.add(buttonPanel);
        contentBox.setBorder(BorderFactory.createEmptyBorder(14, 14, 14, 14));
//        content.applyComponentOrientation(ComponentOrientation.RIGHT_TO_LEFT);
        
//        fieldPanel.setAlignmentX();
//      buttonPanel.setAlignmentX(Component.RIGHT_ALIGNMENT);
        add(contentBox);
        
    }

    /**
     * {@inheritDoc}
     * 
     * Overridden to check if content is available. <p>
     * PENDING: doesn't make sense - the content is immutable and guaranteed
     * to be not null.
     */
    @Override
    public void setVisible(boolean visible) {
        if (content == null) throw 
            new IllegalStateException("content must be built before showing the dialog");
        super.setVisible(visible);
    }

//------------------------ dynamic locale support
    

    /**
     * {@inheritDoc} <p>
     * 
     * Overridden to set the content's Locale and then updated
     * this dialog's internal state. <p>
     * 
     * 
     */
    @Override
    public void setLocale(Locale l) {
        /*
         * NOTE: this is called from super's constructor as one of the
         * first methods (prior to setting the rootPane!). So back out
         * 
         */  
        if (content != null) {
            content.setLocale(l);
            updateLocaleState(l);
        }
        super.setLocale(l);
    }
    
    /**
     * Updates this dialog's locale-dependent state.
     * 
     * Here: updates title and actions.
     * <p>
     * 
     * 
     * @see #setLocale(Locale)
     */
    protected void updateLocaleState(Locale locale) {
        setTitleFromContent();
        for (Object key : getRootPane().getActionMap().allKeys()) {
            if (key instanceof String) {
                Action contentAction = content.getActionMap().get(key);
                Action rootPaneAction = getAction(key);
                if ((!rootPaneAction.equals(contentAction))) {
                    String keyString = getUIString((String) key, locale);
                    if (!key.equals(keyString)) {
                        rootPaneAction.putValue(Action.NAME, keyString);
                    }
                }
            }
        }
    }
    
    /**
     * The callback method executed when closing the dialog. <p>
     * Here: calls dispose. 
     *
     */
    public void doClose() {
        dispose();
    }
    
    private void initActions() {
        Action defaultAction = createCloseAction();
        putAction(CLOSE_ACTION_COMMAND, defaultAction);
        putAction(EXECUTE_ACTION_COMMAND, defaultAction);
    }

    private Action createCloseAction() {
        String actionName = getUIString(CLOSE_ACTION_COMMAND);
        BoundAction action = new BoundAction(actionName,
                CLOSE_ACTION_COMMAND);
        action.registerCallback(this, "doClose");
        return action;
    }

    /**
     * create the dialog button controls.
     * 
     * 
     * @return panel containing button controls
     */
    protected JComponent createButtonPanel() {
        // PENDING: this is a hack until we have a dedicated ButtonPanel!
        JPanel panel = new JPanel(new BasicOptionPaneUI.ButtonAreaLayout(true, 6))
        {
            @Override
            public Dimension getMaximumSize() {
                return getPreferredSize();
            }
        };

        panel.setBorder(BorderFactory.createEmptyBorder(9, 0, 0, 0));
        Action executeAction = getAction(EXECUTE_ACTION_COMMAND);
        Action closeAction = getAction(CLOSE_ACTION_COMMAND);

        JButton defaultButton = new JButton(executeAction);
        panel.add(defaultButton);
        getRootPane().setDefaultButton(defaultButton);
        
        if (executeAction != closeAction) {
            JButton b = new JButton(closeAction);
            panel.add(b);
            getRootPane().setCancelButton(b);
        }
        
        return panel;
    }

    /**
     * convenience wrapper to access rootPane's actionMap.
     * @param key
     * @param action
     */
    private void putAction(Object key, Action action) {
        getRootPane().getActionMap().put(key, action);
    }
    
    /**
     * convenience wrapper to access rootPane's actionMap.
     * 
     * @param key
     * @return root pane's <code>ActionMap</code>
     */
    private Action getAction(Object key) {
        return getRootPane().getActionMap().get(key);
    }

    /**
     * Returns a potentially localized value from the UIManager. The given key
     * is prefixed by this component|s <code>UIPREFIX</code> before doing the
     * lookup. The lookup respects this table's current <code>locale</code>
     * property. Returns the key, if no value is found.
     * 
     * @param key the bare key to look up in the UIManager.
     * @return the value mapped to UIPREFIX + key or key if no value is found.
     */
    protected String getUIString(String key) {
        return getUIString(key, getLocale());
    }

    /**
     * Returns a potentially localized value from the UIManager for the 
     * given locale. The given key
     * is prefixed by this component's <code>UIPREFIX</code> before doing the
     * lookup. Returns the key, if no value is found.
     * 
     * @param key the bare key to look up in the UIManager.
     * @param locale the locale use for lookup
     * @return the value mapped to UIPREFIX + key in the given locale,
     *    or key if no value is found.
     */
    protected String getUIString(String key, Locale locale) {
        String text = UIManagerExt.getString(UIPREFIX + key, locale);
        return text != null ? text : key;
    }
}
