alvinalexander.com | career | drupal | java | mac | mysql | perl | scala | uml | unix  

Glassfish example source code file (CallbackGUIBindings.java)

This example Glassfish source code file (CallbackGUIBindings.java) is included in the DevDaily.com "Java Source Code Warehouse" project. The intent of this project is to help you "Learn Java by Example" TM.

Java - Glassfish tags/keywords

binding, binding, border, gui, jcomponent, jcomponent, jlabel, jlist, jscrollpane, locale, localeentry, map, messagetype, messagetype, override, override, reflection, swing, util

The Glassfish CallbackGUIBindings.java source code

/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright (c) 1997-2010 Oracle and/or its affiliates. All rights reserved.
 *
 * The contents of this file are subject to the terms of either the GNU
 * General Public License Version 2 only ("GPL") or the Common Development
 * and Distribution License("CDDL") (collectively, the "License").  You
 * may not use this file except in compliance with the License.  You can
 * obtain a copy of the License at
 * https://glassfish.dev.java.net/public/CDDL+GPL_1_1.html
 * or packager/legal/LICENSE.txt.  See the License for the specific
 * language governing permissions and limitations under the License.
 *
 * When distributing the software, include this License Header Notice in each
 * file and include the License file at packager/legal/LICENSE.txt.
 *
 * GPL Classpath Exception:
 * Oracle designates this particular file as subject to the "Classpath"
 * exception as provided by Oracle in the GPL Version 2 section of the License
 * file that accompanied this code.
 *
 * Modifications:
 * If applicable, add the following below the License Header, with the fields
 * enclosed by brackets [] replaced by your own identifying information:
 * "Portions Copyright [year] [name of copyright owner]"
 *
 * Contributor(s):
 * If you wish your version of this file to be governed by only the CDDL or
 * only the GPL Version 2, indicate your decision by adding "[Contributor]
 * elects to include this software in this distribution under the [CDDL or GPL
 * Version 2] license."  If you don't indicate a single choice of license, a
 * recipient has the option to distribute your version of this file under
 * either the CDDL, the GPL Version 2 or to extend the choice of license to
 * its licensees as provided above.  However, if you add GPL Version 2 code
 * and therefore, elected the GPL Version 2 license, then the option applies
 * only if the new code is made subject to such option by the copyright
 * holder.
 */

package org.glassfish.appclient.client.acc.callbackhandler;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.util.Arrays;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Locale;
import java.util.Map;
import java.util.Vector;
import javax.security.auth.callback.Callback;
import javax.security.auth.callback.ChoiceCallback;
import javax.security.auth.callback.ConfirmationCallback;
import javax.security.auth.callback.LanguageCallback;
import javax.security.auth.callback.NameCallback;
import javax.security.auth.callback.PasswordCallback;
import javax.security.auth.callback.TextInputCallback;
import javax.security.auth.callback.TextOutputCallback;
import javax.security.auth.callback.UnsupportedCallbackException;
import javax.swing.Box;
import javax.swing.BoxLayout;
import javax.swing.JComponent;
import javax.swing.JLabel;
import javax.swing.JList;
import javax.swing.JOptionPane;
import javax.swing.JPasswordField;
import javax.swing.JScrollPane;
import javax.swing.JTextArea;
import javax.swing.JTextField;
import javax.swing.ListSelectionModel;
import javax.swing.border.EtchedBorder;
import org.glassfish.appclient.client.acc.callbackhandler.CallbackBinding.GUI;

/**
 *
 * @author tjquinn
 */
public class CallbackGUIBindings {

    private static final Map<Class,Class> callbackToBinding = initCallbackToBindingMap();

    private static Map<Class,Class> initCallbackToBindingMap() {
        Map<Class,Class> result = new HashMap();
        result.put(ChoiceCallback.class, Choice.class);
        result.put(ConfirmationCallback.class, Confirmation.class);
        result.put(LanguageCallback.class, Language.class);
        result.put(NameCallback.class, Name.class);
        result.put(PasswordCallback.class, Password.class);
        result.put(TextInputCallback.class, TextInput.class);
        result.put(TextOutputCallback.class, TextOutput.class);
        return result;
    }
    
    /**
     * Factory method for creating the appropriate callback-to-U/I binding
     * object given a callback.
     * @param callback the Callback for which to create the binding
     * @return the CallbackUIBinding suitable for the type of callback provided
     * @throws javax.security.auth.callback.UnsupportedCallbackException if the 
     * type of callback is not recognized
     */
    public Binding createCallbackGUIBinding(Callback callback) 
            throws UnsupportedCallbackException, InstantiationException, IllegalAccessException, NoSuchMethodException, IllegalArgumentException, InvocationTargetException {
        
        Class bindingClass = callbackToBinding.get(callback.getClass());
        if (bindingClass != null) {
            Constructor<Binding> constructor = 
                    bindingClass.getConstructor(
                        new Class[] { CallbackGUIBindings.class });
            Binding binding = constructor.newInstance(new Object[] { this });
            binding.setCallback(callback);
            return binding;
        }
        throw new UnsupportedCallbackException(callback);
    }    

    /**
     * Creates a default ConfirmationCallback binding (because the caller did
     * not provide one).
     * @return the default ConfirmationCallbackUIBinding
     */
    public CallbackGUIBindings.Confirmation getDefaultConfirmationCallbackUIBinding() {
        ConfirmationCallback defaultCallback = new ConfirmationCallback
                (ConfirmationCallback.INFORMATION,
                 ConfirmationCallback.OK_CANCEL_OPTION,
                 ConfirmationCallback.OK);

        CallbackGUIBindings.Confirmation binding = 
                new CallbackGUIBindings.Confirmation();
        binding.setCallback(defaultCallback);
        return binding;
    }
    
    /** number of rows to be visible in JLists used to display information*/
    protected static final int LIST_ROWS = 4;
    
    /** number of rows of text to be visible in text areas */
    protected static final int TEXT_ROWS = 4;
    
    /** number of columns for text areas */
    protected static final int TEXT_COLUMNS = 20;

    public abstract class Binding<C extends Callback> implements GUI {
        private JComponent component = null;

        protected C callback;

        private MessageType messageType;

        protected JComponent createPromptedInputBox(String prompt, JComponent input) {
            Box box = new Box(BoxLayout.X_AXIS);
            JLabel promptLabel = new JLabel(prompt);
            box.add(promptLabel);
            box.add(input);
            return box;
        }

        protected MessageType getMessageType() {
            return null;
        }

        /**
         * Creates a JScrollPane containing the specified component with no
         * column header.
         * @param body the JComponent to enclose in the scroll pane
         * @return the JScrollPane holding the component
         */
        protected JScrollPane prepareScrollPane(JComponent body) {
            return new JScrollPane(body);
        }

        /**
         * Creates a JScrollPane containing a column header and the specified component.
         * @param columnHeader String containing the header text
         * @param body the JComponent to enclose in the scroll pane
         * @return the JScrollPane with the specified header and component 
         */
        protected JScrollPane prepareScrollPane(String columnHeader, JComponent body) {
            JScrollPane scrollPane = new JScrollPane(body);
            JLabel headerLabel = new JLabel(columnHeader);
            headerLabel.setBorder(new EtchedBorder(EtchedBorder.RAISED));
            scrollPane.setColumnHeaderView(headerLabel);
            return scrollPane;
        }

        protected abstract JComponent createComponent();

        public JComponent getComponent() {
            if (component == null) {
                component = createComponent();
            }
            return component;
        }

        @Override
        public void setCallback(C callback) {
            this.callback = callback;
        }
    }
    
    public class Choice extends Binding<ChoiceCallback> {
        /**
         * The binding for ChoiceCallbacks.
         */
        private JList jList;

        @Override
        protected JComponent createComponent() {
            jList = prepareList(
                        callback.getChoices(), 
                        callback.getSelectedIndexes());
            return prepareScrollPane(callback.getPrompt(), jList);
        }

        private JList prepareList(String[] choices, int[] selectedIndexes) {
            JList result = new JList();
            result.setVisibleRowCount(LIST_ROWS);
            result.setListData(choices);
            if (selectedIndexes != null) {
                result.setSelectedIndices(selectedIndexes);
            }
            result.setSelectionMode(this.callback.allowMultipleSelections() ? 
                ListSelectionModel.MULTIPLE_INTERVAL_SELECTION :
                ListSelectionModel.SINGLE_SELECTION);

            return result;
        }

        @Override
        public void finish() {
            if (callback.allowMultipleSelections()) {
                callback.setSelectedIndexes(jList.getSelectedIndices());
            } else {
                callback.setSelectedIndex(jList.getSelectedIndex());
            }
        }
    }

    public class Confirmation extends Binding<ConfirmationCallback> {

        @Override
        protected JComponent createComponent() {
            return null;
        }

        @Override
        protected MessageType getMessageType() {
            return MessageType.severityForConfirmation(callback.getMessageType());
        }

        @Override
        public void finish() {
        }

        public int getOptionPaneOptionType() {
            if (callback.getOptionType() == ConfirmationCallback.OK_CANCEL_OPTION) {
                return JOptionPane.OK_CANCEL_OPTION;
            }
            if (callback.getOptionType() == ConfirmationCallback.YES_NO_CANCEL_OPTION) {
                return JOptionPane.YES_NO_CANCEL_OPTION;
            }
            if (callback.getOptionType() == ConfirmationCallback.YES_NO_OPTION) {
                return JOptionPane.YES_NO_OPTION;
            }
            return JOptionPane.OK_CANCEL_OPTION;
        }

        public String[] getOptions() {
            return callback.getOptions();
        }

        public int getDefaultOption() {
            return callback.getDefaultOption();
        }

        public void setResult(int result) {
            int callbackResult = -1;
            if (callback.getOptionType() == ConfirmationCallback.UNSPECIFIED_OPTION) {
                callbackResult = result;
            } else {
                if (callback.getOptionType() == ConfirmationCallback.OK_CANCEL_OPTION) {
                    if (result == JOptionPane.OK_OPTION) {
                        callbackResult = ConfirmationCallback.OK;
                    } else if (result == JOptionPane.CANCEL_OPTION) {
                        callbackResult = ConfirmationCallback.CANCEL;
                    }
                } else if (callback.getOptionType() == ConfirmationCallback.YES_NO_CANCEL_OPTION) {
                    if (result == JOptionPane.YES_OPTION) {
                        callbackResult = ConfirmationCallback.YES;
                    } else if (result == JOptionPane.NO_OPTION) {
                        callbackResult = ConfirmationCallback.NO;
                    } else if (result == JOptionPane.CANCEL_OPTION) {
                        callbackResult = ConfirmationCallback.CANCEL;
                    }
                } else if (callback.getOptionType() == ConfirmationCallback.YES_NO_OPTION) {
                    if (result == JOptionPane.YES_OPTION) {
                        callbackResult = ConfirmationCallback.YES;
                    } else if (result == JOptionPane.NO_OPTION) {
                        callbackResult = ConfirmationCallback.NO;
                    }                    
                }
            }
            callback.setSelectedIndex(callbackResult);
        }
    }

    public class Name extends Binding<NameCallback> {

        private JTextField nameField;

        @Override
        protected JComponent createComponent() {
            JComponent result = createPromptedInputBox(
                        callback.getPrompt(),
                        nameField = new JTextField(callback.getDefaultName()));
            nameField.setColumns(20);
            return result;
        }

        @Override
        public void finish() {
             callback.setName(nameField.getText());
        }

    }

    public class Password extends Binding<PasswordCallback> {
        private JPasswordField passwordField;

        @Override
        public JComponent createComponent() {
            JComponent result = createPromptedInputBox(
                    callback.getPrompt(),
                    passwordField = new JPasswordField());
            passwordField.setColumns(20);
            return result;
        }

        @Override
        public void finish() {
            callback.setPassword(passwordField.getPassword());
            passwordField.setText("");
        }
    }

    public class TextInput extends Binding<TextInputCallback> {

        private JTextArea textArea;

        @Override
        public JComponent createComponent() {
            textArea = new JTextArea(
                    callback.getDefaultText(), 
                    TEXT_ROWS, 
                    TEXT_COLUMNS);
            textArea.setLineWrap(true);
            textArea.setWrapStyleWord(true);
            return prepareScrollPane(callback.getPrompt(), textArea);
        }

        @Override
        public void finish() {
            callback.setText(textArea.getText());
        }

    }

    public class TextOutput extends Binding<TextOutputCallback> {
        private JTextArea textArea;

        @Override
        public JComponent createComponent() {
            String s = callback.getMessage();
            textArea = new JTextArea(this.callback.getMessage());
            textArea.setEditable(false);
            textArea.setWrapStyleWord(true);
            textArea.setLineWrap(true);
            textArea.setBackground(new JLabel().getBackground());
            return textArea;
        }

        @Override
        public void finish() {
        }

        @Override
        public MessageType getMessageType() {
            return MessageType.severityForTextOutput(callback.getMessageType());
        }
    }

    public class Language extends Binding<LanguageCallback> {
        private JList languageList;

        @Override
        public JComponent createComponent() {

            Vector<LocaleEntry> entries = new Vector();
            Locale defaultLocale = Locale.getDefault();
            LocaleEntry defaultEntry = null;
            Locale [] sortedLocales = Locale.getAvailableLocales();
            Arrays.sort(sortedLocales, 
                    new Comparator<Locale>() {
                        @Override
                        public int compare(Locale l1, Locale l2) {
                            return l1.getDisplayName().compareTo(l2.getDisplayName());
                        }
                });
            for (Locale locale : sortedLocales) {
                LocaleEntry newEntry = new LocaleEntry(locale);
                entries.add(newEntry);
                if (locale.equals(defaultLocale)) {
                    defaultEntry = newEntry;
                }
            }

            languageList = new JList(entries);
            languageList.setVisibleRowCount(LIST_ROWS);
            languageList.setSelectedValue(defaultEntry, true);
            return prepareScrollPane(languageList);
        }

        @Override
        public void finish() {
            callback.setLocale(((LocaleEntry) languageList.getSelectedValue()).locale);
        }

        private class LocaleEntry {
            private Locale locale;

            private LocaleEntry(Locale locale) {
                this.locale = locale;
            }

            @Override
            public String toString() {
                return locale.getDisplayName();
            }


        }        
    }

    /**
     * Simplifies converting between option pane message types and callback
     * message types.
     */
    protected enum MessageType {
        /*
         * The message types must be defined in order of increasing severity.
         */
        PLAIN(JOptionPane.PLAIN_MESSAGE),
        INFORMATION(
                JOptionPane.INFORMATION_MESSAGE, 
                ConfirmationCallback.INFORMATION,
                TextOutputCallback.INFORMATION),
        QUESTION(JOptionPane.QUESTION_MESSAGE),
        WARNING(
                JOptionPane.WARNING_MESSAGE,
                ConfirmationCallback.WARNING,
                TextOutputCallback.WARNING),
        ERROR(
                JOptionPane.ERROR_MESSAGE,
                ConfirmationCallback.ERROR,
                TextOutputCallback.ERROR);
        
        private int optionPaneMessageType;
        private int confirmationCallbackMessageType;
        private int textOutputCallbackMessageType;
        private boolean mapsToCallback;
        
        private MessageType(int optionPaneMessageType) {
            this.optionPaneMessageType = optionPaneMessageType;
            mapsToCallback = false;
        }
        
        private MessageType(
                int optionPaneMessageType,
                int confirmationCallbackMessageType,
                int textOutputCallbackMessageType) {
            mapsToCallback = true;
            this.optionPaneMessageType = optionPaneMessageType;
            this.confirmationCallbackMessageType = confirmationCallbackMessageType;
            this.textOutputCallbackMessageType = textOutputCallbackMessageType;
        }
        
        public int getOptionPaneMessageType() {
            return optionPaneMessageType;
        }
        
        public boolean exceeds(MessageType ms) {
            return (ms == null) || ordinal() > ms.ordinal();
        }
        
        public static MessageType severityForConfirmation(
                int confirmationCallbackMessageType) {
            for (MessageType ms : values()) {
                if (ms.mapsToCallback && ms.confirmationCallbackMessageType == confirmationCallbackMessageType) {
                    return ms;
                }
            }
            throw new IllegalArgumentException(Integer.toString(confirmationCallbackMessageType));
        }
        
        public static MessageType severityForTextOutput(
                int textOutputCallbackMessageType) {
            for (MessageType ms : values()) {
                if (ms.mapsToCallback && ms.textOutputCallbackMessageType == textOutputCallbackMessageType) {
                    return ms;
                }
            }
            throw new IllegalArgumentException(Integer.toString(textOutputCallbackMessageType));
        }
    }
}

Other Glassfish examples (source code examples)

Here is a short list of links related to this Glassfish CallbackGUIBindings.java source code file:

... this post is sponsored by my books ...

#1 New Release!

FP Best Seller

 

new blog posts

 

Copyright 1998-2021 Alvin Alexander, alvinalexander.com
All Rights Reserved.

A percentage of advertising revenue from
pages under the /java/jwarehouse URI on this website is
paid back to open source projects.