WindowState.java

package org.jtheque.ui.utils.windows;

import org.jtheque.core.Core;
import org.jtheque.core.utils.OSGiUtils;
import org.jtheque.errors.Error;
import org.jtheque.errors.ErrorService;
import org.jtheque.i18n.Internationalizable;
import org.jtheque.i18n.LanguageService;
import org.jtheque.images.ImageService;
import org.jtheque.ui.Controller;
import org.jtheque.ui.constraints.Constraint;
import org.jtheque.utils.StringUtils;
import org.jtheque.utils.collections.ArrayUtils;
import org.jtheque.utils.collections.CollectionUtils;
import org.jtheque.utils.ui.SwingUtils;

import org.jdesktop.jxlayer.JXLayer;
import org.jdesktop.jxlayer.plaf.ext.LockableUI;
import org.osgi.framework.BundleContext;
import org.springframework.context.ApplicationContext;

import javax.swing.JComponent;
import javax.swing.JPanel;
import javax.swing.SwingUtilities;

import java.awt.Component;
import java.awt.Cursor;
import java.awt.Image;
import java.awt.Window;
import java.util.Collection;
import java.util.Map;

/*
 * Copyright JTheque (Baptiste Wicht)
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

/**
 * A Window state implementation. This state manage the state of Dialogs and Frames.
 *
 * @author Baptiste Wicht
 */
public final class WindowState implements org.jtheque.ui.WindowState {
    private String titleKey;
    private Object[] titleReplaces;

    private final Collection<Internationalizable> internationalizables = CollectionUtils.newList();
    private final Map<Object, Constraint> constraintCache = CollectionUtils.newHashMap(5);

    private final Window window;
    private JXLayer<JComponent> content;

    private Controller<?> controller;
    private LockableUI waitUI;

    private BundleContext bundleContext;
    private ApplicationContext applicationContext;

    private boolean builded;

    /**
     * Construct a new WindowState.
     *
     * @param window The window to manage.
     */
    public WindowState(Window window) {
        super();

        this.window = window;
    }

    /**
     * Build the state.
     */
    public void build() {
        content = new JXLayer<JComponent>();

        window.setIconImage(getDefaultWindowIcon());

        builded = true;
    }

    /**
     * Return the default icon for the window icon.
     *
     * @return The default icon.
     */
    protected Image getDefaultWindowIcon() {
        return getService(ImageService.class).getImage(Core.WINDOW_ICON);
    }

    /**
     * Return the service of the given class.
     *
     * @param classz The class to get the service.
     * @param <T>    The type of service.
     *
     * @return The service of the given class if it's exists otherwise null.
     */
    protected <T> T getService(Class<T> classz) {
        return OSGiUtils.getService(bundleContext, classz);
    }

    @Override
    public void startWait() {
        installWaitUIIfNecessary();
        content.setUI(waitUI);
        waitUI.setLocked(true);
        window.setCursor(Cursor.getPredefinedCursor(Cursor.WAIT_CURSOR));
    }

    @Override
    public void stopWait() {
        if (waitUI != null) {
            waitUI.setLocked(false);
            window.setCursor(Cursor.getPredefinedCursor(Cursor.DEFAULT_CURSOR));
            content.setUI(null);
        }
    }

    /**
     * Create the wait UI only if this has not been done before.
     */
    private void installWaitUIIfNecessary() {
        if (waitUI == null) {
            waitUI = new BusyPainterUI(window);
        }
    }

    /**
     * Return the content pane of the view.
     *
     * @return The content pane of the view.
     */
    public JXLayer<JComponent> getContent() {
        return content;
    }

    /**
     * Set a glass pane over the view.
     *
     * @param glassPane The glass pane to set over the view.
     */
    public void setGlassPane(Component glassPane) {
        SwingUtils.inEdt(new GlassPaneSetter(glassPane));
    }

    /**
     * Display the view.
     */
    public void display() {
        if (!builded) {
            SwingUtils.inEdt(new Runnable() {
                @Override
                public void run() {
                    ((ManagedWindow) window).build();
                }
            });
        }

        SwingUtils.inEdt(new Runnable() {
            @Override
            public void run() {
                window.setVisible(true);
            }
        });
    }

    /**
     * Return the controller of the view.
     *
     * @return The controller of the view.
     */
    public Controller<?> getController() {
        return controller;
    }

    /**
     * Set the controller of the view.
     *
     * @param controller The controller of the view.
     */
    public void setController(Controller<?> controller) {
        this.controller = controller;
    }

    /**
     * Return the bundle context.
     *
     * @return The bundle context of the view.
     */
    public BundleContext getBundleContext() {
        return bundleContext;
    }

    /**
     * Return the bundle context.
     *
     * @param bundleContext The bundle context.
     */
    public void setBundleContext(BundleContext bundleContext) {
        this.bundleContext = bundleContext;
    }

    /**
     * Return the application context.
     *
     * @return The application context.
     */
    public ApplicationContext getApplicationContext() {
        return applicationContext;
    }

    /**
     * Return the application context.
     *
     * @param applicationContext The application context.
     */
    public void setApplicationContext(ApplicationContext applicationContext) {
        this.applicationContext = applicationContext;
    }

    /**
     * Add an internationalizable to the container.
     *
     * @param internationalizable The internationalizable to add.
     */
    public void addInternationalizable(Internationalizable internationalizable) {
        internationalizables.add(internationalizable);
    }

    /**
     * Refresh the title of the window.
     *
     * @param languageService The language service to use for i18n.
     */
    public void refreshText(LanguageService languageService) {
        if (StringUtils.isNotEmpty(titleKey)) {
            setTitleKey(titleKey, titleReplaces);
        }

        for (Internationalizable internationalizable : internationalizables) {
            internationalizable.refreshText(languageService);
        }
    }

    /**
     * Set the title key of the window.
     *
     * @param key      The key of the title.
     * @param replaces The replaces of the title.
     */
    public void setTitleKey(String key, Object... replaces) {
        titleKey = key;

        if (!ArrayUtils.isEmpty(replaces)) {
            titleReplaces = ArrayUtils.copyOf(replaces);
        }

        ((ManagedWindow) window).setTitle(getMessage(key, replaces));
    }

    /**
     * Return the internationalized message.
     *
     * @param key The internationalization key.
     *
     * @return The internationalized message.
     */
    protected String getMessage(String key) {
        return getService(LanguageService.class).getMessage(key);
    }

    /**
     * Return the internationalized message.
     *
     * @param key      The internationalization key.
     * @param replaces The replacement objects to use.
     *
     * @return the internationalized message.
     */
    protected String getMessage(String key, Object... replaces) {
        return getService(LanguageService.class).getMessage(key, replaces);
    }

    /**
     * Add a constraint to the view.
     *
     * @param field      The field to validate.
     * @param constraint The constraint to add to the view.
     */
    public void addConstraint(Object field, Constraint constraint) {
        constraintCache.put(field, constraint);

        constraint.configure(field);
    }

    /**
     * Validate the content of the view.
     *
     * @return true if the view content is valid else false.
     */
    public boolean validateContent() {
        Collection<Error> errors = CollectionUtils.newList(5);

        ((ManagedWindow) window).validate(errors);

        ErrorService errorService = getService(ErrorService.class);

        for (Error error : errors) {
            errorService.addError(error);
        }

        return errors.isEmpty();
    }

    /**
     * Validate the view using the setted constraints.
     *
     * @param errors The errors collection to fill.
     */
    public void validate(Collection<Error> errors) {
        for (Map.Entry<Object, Constraint> constraint : constraintCache.entrySet()) {
            constraint.getValue().validate(constraint.getKey(), errors);
        }
    }

    /**
     * A simple runnable to apply a glass pane to the view associated with this state.
     *
     * @author Baptiste Wicht
     */
    private final class GlassPaneSetter implements Runnable {
        private final Component glassPane;

        /**
         * Construct a new GlassPaneSetter for the given glass pane.
         *
         * @param glassPane The glass pane to set on the view.
         */
        private GlassPaneSetter(Component glassPane) {
            this.glassPane = glassPane;
        }

        @Override
        public void run() {
            if (glassPane == null) {
                JPanel glasspane = content.createGlassPane();

                glasspane.setVisible(false);
                glasspane.setOpaque(false);

                content.setGlassPane(glasspane);
            } else {
                content.setGlassPane((JPanel) glassPane);

                glassPane.setVisible(true);
                glassPane.repaint();

                SwingUtilities.updateComponentTreeUI(glassPane);
            }

            SwingUtilities.updateComponentTreeUI(content);
        }
    }
}