Client.java :  » Workflow-Engines » osbl-1_0 » org » osbl » client » wings » shell » Java Open Source

package org.osbl.client.wings.shell;

import java.util.*;

import org.conform.BeanMetaProvider;
import org.osbl.client.action.ActionProvider;
import org.osbl.client.ClientResourceProvider;
import org.osbl.client.ClientServiceProvider;
import org.osbl.client.wings.devtools.DevelopmentTool;
import org.wings.*;
import org.wings.session.*;

import javax.swing.*;
import javax.swing.event.*;

/**
 * @author hengels
 * @version $Revision$
 */
public abstract class Client
{
    private BeanMetaProvider beanMetaProvider;
    private ActionProvider actionProvider;
    private ClientServiceProvider serviceProvider;
    private ClientResourceProvider resourceProvider;
    private static List<ClientInitializer> initializers = new LinkedList<ClientInitializer>();
    protected DevelopmentTool developmentTool;
    protected ContextHelpTool contextHelpTool;

    protected Client() {
        getSession().setProperty("Client", this);

        for (Iterator<ClientInitializer> iterator = initializers.iterator(); iterator.hasNext();) {
            ClientInitializer clientInitializer = iterator.next();
            clientInitializer.preInitialization(this);
        }

        initialize();

        for (Iterator<ClientInitializer> iterator = initializers.iterator(); iterator.hasNext();) {
            ClientInitializer clientInitializer = iterator.next();
            clientInitializer.postInitialization(this);
        }

        new URLNavigation();
    }

    protected abstract void initialize();

    public static void addInitializer(ClientInitializer clientInitializer) {
        initializers.add(clientInitializer);
    }

    public static Client getInstance() {
        return (Client)SessionManager.getSession().getProperty("Client");
    }

    public BeanMetaProvider getBeanMetaProvider() {
        return beanMetaProvider;
    }

    public void setBeanMetaProvider(BeanMetaProvider beanMetaProvider) {
        this.beanMetaProvider = beanMetaProvider;
    }

    public ActionProvider getActionProvider() {
        return actionProvider;
    }

    public void setActionProvider(ActionProvider actionProvider) {
        this.actionProvider = actionProvider;
    }

    public ClientServiceProvider getServiceProvider() {
        return serviceProvider;
    }

    public void setServiceProvider(ClientServiceProvider serviceProvider) {
        this.serviceProvider = serviceProvider;
    }

    public ClientResourceProvider getResourceProvider() {
        return resourceProvider;
    }

    public void setResourceProvider(ClientResourceProvider resourceProvider) {
        this.resourceProvider = resourceProvider;
    }

    protected Session getSession() {
        return SessionManager.getSession();
    }

    public abstract void addNavigation(String character, String title, SIcon icon, SComponent component);
    public abstract void removeNavigation(String character);
    public abstract void removeNavigation(SComponent component);
    public abstract SComponent getNavigation(String character);
    public abstract void clearNavigations();

    @Deprecated
    public abstract void show(String character, SComponent component);
    @Deprecated
    public abstract void hide(String character, SComponent component);
    @Deprecated
    public abstract void showMessage(Message message);
    @Deprecated
    public abstract void hideMessage(Message message);
    @Deprecated
    public abstract void clearMessages();
    @Deprecated
    public abstract void refreshTitle();
    @Deprecated
    public abstract void refreshActions();
    @Deprecated
    public abstract void refreshTools();

    protected boolean isIE() {
        System.out.println("getSession().getUserAgent() = " + getSession().getUserAgent());
        return BrowserType.IE.equals(getSession().getUserAgent().getBrowserType());
    }

    public abstract void showDetailHelp(String key);

    public abstract SComponent getShownComponent();

    public abstract void addHeaderComponent(SComponent component);

    public void addHeaderButton(Action action) {
        if (action != null && action.isEnabled()) {
            SButton button = new SButton(action);
            button.setToolTipText(button.getText());
            button.setText(null);
            button.setStyle("borderless_form");
            addHeaderComponent(button);
        }
    }

    public void setDevelopmentTool(DevelopmentTool developmentTool) {
        this.developmentTool = developmentTool;
    }

    public void setContextHelpTool(ContextHelpTool contextHelpTool) {
        this.contextHelpTool = contextHelpTool;
    }

    private WindowStacksModel windowStacksModel = new WindowStacksModel();
    {
        windowStacksModel.addChangeListener(new ChangeListener() {
            public void stateChanged(ChangeEvent e) {
                int i = windowStacksModel.getActiveStack();
                activateStack(i != -1 ? windowStacksModel.getElementAt(i) : null);
            }
        });
    }

    public WindowStacksModel getWindowStacksModel() {
        return windowStacksModel;
    }

    public void pushWindow(Window window) {
        if (!activateStack(window))
            pushWindow(null, window);
    }

    public void pushWindow(Window parent, Window window) {
        if (parent != null) {
            window.setParent(parent);

            for (Stack<Window> stack : windowStacksModel) {
                if (stack.contains(parent)) {
                    stack.peek().setVisible(false);

                    stack.push(window);
                    window.setVisible(true);
                    window.setActive(windowStacksModel.getStacks().indexOf(stack) == windowStacksModel.getActiveStack());

                    break;
                }
            }
        }
        else {
            Stack<Window> stack = new Stack<Window>();
            windowStacksModel.add(stack);
            windowStacksModel.setActiveStack(windowStacksModel.getSize() - 1);

            stack.push(window);
            window.setVisible(true);
            window.setActive(true);
        }
    }

    public void popWindow(Window window) {
        for (Stack<Window> stack : windowStacksModel) {
            if (stack.peek() == window) {
                window.setActive(false);
                window.setVisible(false);
                stack.pop();
                if (stack.size() > 0)
                    stack.peek().setVisible(true);
                else {
                    windowStacksModel.remove(stack);
                }
                return;
            }
        }
        throw new IllegalArgumentException("Can't pop this window. It is not lying on top of any window stack!");
    }

    public boolean activateStack(Window window) {
        int i=0;
        for (Stack<Window> stack : windowStacksModel) {
            if (stack.contains(window)) {
                activateStack(stack);
                windowStacksModel.setActiveStack(i);
                return true;
            }
            i++;
        }
        return false;
    }

    Stack<Window> activeStack = null;

    private void activateStack(Stack<Window> activeStack) {
        if (this.activeStack == activeStack)
            return;

        if (this.activeStack != null)
            for (Window window : this.activeStack)
                window.setActive(false);

        this.activeStack = activeStack;

        if (this.activeStack != null)
            for (Window window : this.activeStack)
                window.setActive(true);
        else {
            setTitle(null);
            setContent(null);
            setStatusMessage(null);
            setControls(null);
            setTools(null);
            setDevelopmentActions(null);
            setDefaultButton(null);
        }
    }

    protected abstract void setContent(SComponent contentPane);
    protected void setTitle(String title) {
        if (windowStacksModel.getActiveStack() != -1)
            windowStacksModel.changed(windowStacksModel.getActiveStack());
    }
    protected abstract void setControls(List<SComponent> controls);
    protected abstract void setTools(List<Tool> tools);
    protected abstract void setStatusMessage(Message statusMessage);
    protected abstract void setDevelopmentActions(List<Action> developmentActions);
    protected abstract void setHelpCode(String helpCode);
    protected abstract void setDefaultButton(SButton button);

    protected abstract Window currentWindow(SComponent component);

    public Locale getLocale() {
        return getSession().getLocale();
    }

    public static class Message {
        public static final int TYPE_INFO = javax.swing.JOptionPane.INFORMATION_MESSAGE;
        public static final int TYPE_WARNING = javax.swing.JOptionPane.WARNING_MESSAGE;
        public static final int TYPE_ERROR = javax.swing.JOptionPane.ERROR_MESSAGE;

        private int type;
        private String message;
        private String detail;

        public Message() {
        }

        public Message(int type, String message, String detail) {
            if (type < 0 || type > 2)
                throw new IllegalArgumentException("Illegal type");
            this.type = type;
            this.message = message;
            this.detail = detail;
        }

        public Message(int type, String message) {
            if (type < 0 || type > 2)
                throw new IllegalArgumentException("Illegal type");
            this.type = type;
            this.message = message;
        }

        public int getType() {
            return type;
        }

        public void setType(int type) {
            this.type = type;
        }

        public String getMessage() {
            return message;
        }

        public void setMessage(String message) {
            this.message = message;
        }

        public String getDetail() {
            return detail;
        }

        public void setDetail(String detail) {
            this.detail = detail;
        }

        public boolean equals(Object o) {
            if (this == o) return true;
            if (o == null || getClass() != o.getClass()) return false;

            Message message1 = (Message)o;

            if (type != message1.type) return false;
            if (detail != null ? !detail.equals(message1.detail) : message1.detail != null) return false;
            if (message != null ? !message.equals(message1.message) : message1.message != null) return false;

            return true;
        }

        public int hashCode() {
            int result;
            result = type;
            result = 31 * result + (message != null ? message.hashCode() : 0);
            result = 31 * result + (detail != null ? detail.hashCode() : 0);
            return result;
        }

        public String toString() {
            switch (type) {
                case TYPE_INFO:
                    return "[I] " + message;
                case TYPE_WARNING:
                    return "[W] " + message;
                case TYPE_ERROR:
                    return "[E] " + message;
                default:
                    return message;
            }
        }
    }

    protected class WindowStacksModel
        extends AbstractListModel
        implements Iterable<Stack<Window>>
    {
        private List<Stack<Window>> stacks = new ArrayList<Stack<Window>>();
        private int activeStack;

        private EventListenerList listeners = new EventListenerList();
        private ChangeEvent changeEvent = new ChangeEvent(this);

        public List<Stack<Window>> getStacks() {
            return stacks;
        }

        public int getSize() {
            return stacks.size();
        }

        public Stack<Window> getElementAt(int index) {
            return stacks.get(index);
        }

        public void changed(int activeStack) {
            fireContentsChanged(this, activeStack, activeStack);
        }

        public int getActiveStack() {
            return activeStack;
        }

        public void setActiveStack(int activeStack) {
            this.activeStack = activeStack;
            fireChangeEvent();
        }

        private void fireChangeEvent() {
            for (ChangeListener changeListener : listeners.getListeners(ChangeListener.class)) {
                changeListener.stateChanged(changeEvent);
            }
        }

        public void addChangeListener(ChangeListener listener) {
            listeners.add(ChangeListener.class, listener);
        }
        public void removeChangeListener(ChangeListener listener) {
            listeners.remove(ChangeListener.class, listener);
        }

        public void add(Stack<Window> stack) {
            stacks.add(stack);
            fireIntervalAdded(this, stacks.size(), stacks.size());
        }

        public void remove(Stack<Window> stack) {
            Stack<Window> selected = activeStack != -1 && activeStack < stacks.size() ? stacks.get(activeStack) : null;

            int removedIndex = stacks.indexOf(stack);
            stacks.remove(removedIndex);
            fireIntervalRemoved(this, removedIndex, removedIndex);

            // try to keep active stack selected
            int index = stacks.indexOf(selected);
            // active stack has been removed -> select stack at same index
            if (index == -1)
                index = activeStack;
            // index out of bounds -> select last
            if (index > stacks.size() - 1)
                index = stacks.size() - 1;

            setActiveStack(index);
        }

        public Iterator<Stack<Window>> iterator() {
            return stacks.iterator();
        }
    }
}