Application: gvSIG desktop » Library: org.gvsig.tools

/* gvSIG. Geographic Information System of the Valencian Government

 *

 * Copyright (C) 2007-2008 Infrastructures and Transports Department

 * of the Valencian Government (CIT)

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 2

 * of the License, or (at your option) any later version.

 *

 * This program 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 General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,

 * MA  02110-1301, USA.

 *

 */

package org.gvsig.tools.swing.impl.dynobject.set;

import static org.gvsig.tools.dynobject.DynObjectSet.Notification.EDITION_STATUS_CHANGE;

import java.awt.BorderLayout;

import java.awt.event.ActionEvent;

import javax.swing.AbstractAction;

import javax.swing.Action;

import javax.swing.Box;

import javax.swing.Icon;

import javax.swing.JComponent;

import javax.swing.JLabel;

import javax.swing.JOptionPane;

import javax.swing.JPanel;

import javax.swing.JToolBar;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dynobject.DynObject;

import org.gvsig.tools.dynobject.DynObjectSet;

import org.gvsig.tools.dynobject.DynObjectSet.Notification;

import org.gvsig.tools.exception.BaseException;

import org.gvsig.tools.i18n.I18nManager;

import org.gvsig.tools.observer.Observable;

import org.gvsig.tools.observer.Observer;

import org.gvsig.tools.service.Manager;

import org.gvsig.tools.swing.api.ToolsSwingLocator;

import org.gvsig.tools.swing.api.dynobject.DynObjectSwingManager;

import org.gvsig.tools.swing.api.dynobject.JDynObjectComponent;

import org.gvsig.tools.swing.api.dynobject.set.JDynObjectSetComponent;

/**

 * Default {@link JDynObjectSetComponent} implementation using a

 * {@link DynObjectSetModel}.

 * 

 * @author gvSIG Team

 * @version $Id$

 */

public class DefaultJDynObjectSetComponent extends JPanel implements

    JDynObjectSetComponent, Observer {

    private static final long serialVersionUID = -741238766386344850L;

    private static final Logger LOG = LoggerFactory

        .getLogger(DefaultJDynObjectSetComponent.class);

    private final DynObjectSetModel model;

    private final DynObjectSwingManager manager;

    private final I18nManager i18nManager = ToolsLocator.getI18nManager();

    private AbstractEnableAction firstAction;

    private AbstractEnableAction previousAction;

    private JLabel pageCountLabel;

    private AbstractEnableAction nextAction;

    private AbstractEnableAction lastAction;

    private AbstractEnableAction saveAction;

    private AbstractEnableAction deleteAction;

    private JDynObjectComponent component;

    private final boolean writable;

    /**

     * Creates a new {@link DefaultJDynObjectSetComponent}.

     * 

     * @param set

     *            to render

     * @param manager

     *            which manages this component

     * @throws BaseException

     *             if there is an error creating the component

     */

    public DefaultJDynObjectSetComponent(DynObjectSet set,

        DynObjectSwingManager manager) throws BaseException {

        this(set, manager, false);

    }

    /**

     * Creates a new {@link DefaultJDynObjectSetComponent}.

     * 

     * @param set

     *            to render

     * @param manager

     *            which manages this component

     * @param isDoubleBuffered

     *            a boolean, true for double-buffering, which uses additional

     *            memory space to achieve fast, flicker-free updates

     * @throws BaseException

     *             if there is an error creating the component

     */

    public DefaultJDynObjectSetComponent(DynObjectSet set,

        DynObjectSwingManager manager, boolean writable) throws BaseException {

        super(new BorderLayout());

        this.writable = writable;

        this.model = new DynObjectSetModel(set);

        model.addObserver(this);

        set.addObserver(this);

        this.manager = manager;

        initializeGUI();

    }

    /**

     * Initializes the GUI.

     */

    private void initializeGUI() {

        addDynObjectViewer();

        addDynObjectPagerAndButtons();

    }

    private void addDynObjectPagerAndButtons() {

        JToolBar toolBar = new JToolBar();

        toolBar.setRollover(true);

        toolBar.setFloatable(false);

        // Add horizontal glues to center the buttons

        toolBar.add(Box.createHorizontalGlue());

        toolBar.add(getFirstAction());

        toolBar.add(getPreviousAction());

        toolBar.addSeparator();

        toolBar.add(getPageCount());

        toolBar.addSeparator();

        toolBar.add(getNextAction());

        toolBar.add(getLastAction());

        toolBar.add(Box.createHorizontalGlue());

        if (writable) {

            toolBar.add(getSaveAction());

            toolBar.add(getDeleteAction());

        }

        add(toolBar, BorderLayout.SOUTH);

    }

    @SuppressWarnings("serial")

    private Action getFirstAction() {

        if (firstAction == null) {

            // TODO: replace the button text with an Icon

            firstAction = new AbstractEnableAction("<<", null) {

                public void actionPerformed(ActionEvent e) {

                    goFirst();

                }

                public boolean isEnabled() {

                    return model.hasPrevious();

                };

            };

            firstAction.putValue(Action.SHORT_DESCRIPTION,

                getTranslation("Go to the first value"));

            firstAction.checkEnabled();

        }

        return firstAction;

    }

    @SuppressWarnings("serial")

    private Action getPreviousAction() {

        if (previousAction == null) {

            // TODO: replace the button text with an Icon

            previousAction = new AbstractEnableAction("<", null) {

                public void actionPerformed(ActionEvent e) {

                    goPrevious();

                }

                public boolean isEnabled() {

                    return model.hasPrevious();

                };

            };

            previousAction.checkEnabled();

            previousAction.putValue(Action.SHORT_DESCRIPTION,

                getTranslation("Go to the previous value"));

        }

        return previousAction;

    }

    private JLabel getPageCount() {

        if (pageCountLabel == null) {

            pageCountLabel = new JLabel();

            updatePageCountLabel();

        }

        return pageCountLabel;

    }

    /**

     * 

     */

    private void updatePageCountLabel() {

        StringBuffer buffer = new StringBuffer();

        buffer.append(model.getCurrentPosition() + 1).append('/')

            .append(model.getSize());

        pageCountLabel.setText(buffer.toString());

    }

    @SuppressWarnings("serial")

    private Action getNextAction() {

        if (nextAction == null) {

            // TODO: replace the button text with an Icon

            nextAction = new AbstractEnableAction(">", null) {

                public void actionPerformed(ActionEvent e) {

                    goNext();

                }

                public boolean isEnabled() {

                    return model.hasNext();

                };

            };

            nextAction.checkEnabled();

            nextAction.putValue(Action.SHORT_DESCRIPTION,

                getTranslation("Go to the following value"));

        }

        return nextAction;

    }

    @SuppressWarnings("serial")

    private Action getLastAction() {

        if (lastAction == null) {

            // TODO: replace the button text with an Icon

            lastAction = new AbstractEnableAction(">>", null) {

                public void actionPerformed(ActionEvent e) {

                    goLast();

                }

                public boolean isEnabled() {

                    return model.hasNext();

                };

            };

            lastAction.checkEnabled();

            lastAction.putValue(Action.SHORT_DESCRIPTION,

                getTranslation("Go to the last value"));

        }

        return lastAction;

    }

    @SuppressWarnings("serial")

    private Action getSaveAction() {

        if (saveAction == null) {

            // TODO: replace the button text with an Icon

            saveAction = new AbstractEnableAction("Save", null) {

                public void actionPerformed(ActionEvent e) {

                    updateCurrentDynObject();

                }

                public boolean isEnabled() {

                    return model.getDynObjectSet().isUpdateEnabled();

                };

            };

            saveAction.checkEnabled();

            saveAction.putValue(Action.SHORT_DESCRIPTION,

                getTranslation("Save changes"));

        }

        return saveAction;

    }

    @SuppressWarnings("serial")

    private Action getDeleteAction() {

        if (deleteAction == null) {

            // TODO: replace the button text with an Icon

            deleteAction = new AbstractEnableAction("Delete", null) {

                public void actionPerformed(ActionEvent e) {

                    deleteCurrentDynObject();

                }

                public boolean isEnabled() {

                    return model.getDynObjectSet().isDeleteEnabled();

                };

            };

            deleteAction.checkEnabled();

            deleteAction.putValue(Action.SHORT_DESCRIPTION,

                getTranslation("Delete current element"));

        }

        return deleteAction;

    }

    private void addDynObjectViewer() {

        try {

            DynObject dynObject = model.getCurrentDynObject();

            if (dynObject != null) {

                component =

                    ToolsSwingLocator.getDynObjectSwingManager()

                        .createJDynObjectComponent(dynObject, writable);

                add(component.asJComponent(), BorderLayout.CENTER);

            }

        } catch (BaseException e) {

            LOG.error(

                "Error creating the component to view the current DynObject in"

                    + " position: " + model.getCurrentPosition(), e);

        }

    }

    public Manager getManager() {

        return manager;

    }

    public JComponent asJComponent() {

        return this;

    }

    public DynObjectSet getDynObjectSet() {

        return model.getDynObjectSet();

    }

    public void update(Observable observable, Object notification) {

        // The current position has changed, reload UI.

        if (model == observable) {

            reload();

        }

        // If the edition status has changed, update the save & delete buttons

        else

            if (writable

                && model.getDynObjectSet() == observable

                && EDITION_STATUS_CHANGE.equals(((Notification) notification)

                    .getType())) {

                updateEditButtons();

                // Update UI

                revalidate();

                repaint();

            }

    }

    /**

     * Reloads everything.

     */

    private void reload() {

        // Reload everything.

        updateDynObjectPager();

        updateDynObjectViewer();

        if (writable) {

            updateEditButtons();

        }

        // Update UI

        revalidate();

        repaint();

    }

    /**

     * Updates the status of the {@link DynObject} viewer when the model changes

     * the current DynObject.

     */

    private void updateDynObjectViewer() {

        if (component != null) {

            remove(component.asJComponent());

        }

        addDynObjectViewer();

    }

    /**

     * Updates the status of the tool bar when the model changes the current

     * DynObject.

     */

    private void updateDynObjectPager() {

        firstAction.checkEnabled();

        previousAction.checkEnabled();

        nextAction.checkEnabled();

        lastAction.checkEnabled();

        StringBuffer buffer = new StringBuffer();

        long size = model.getSize();

        if (size <= 0) {

            buffer.append("0/0");

        } else {

            buffer.append(model.getCurrentPosition() + 1).append('/')

                .append(model.getSize());

        }

        pageCountLabel.setText(buffer.toString());

    }

    /**

         * 

         */

    private void updateEditButtons() {

        LOG.debug("Updating save & update buttons active status");

        if (saveAction != null) {

            saveAction.checkEnabled();

        }

        if (deleteAction != null) {

            deleteAction.checkEnabled();

        }

    }

    private void updateCurrentDynObject() {

        try {

            component.saveStatus();

            model.getDynObjectSet().update(component.getDynObject());

        } catch (BaseException ex) {

            LOG.error("Error updating the current DynObject in " + "position: "

                + model.getCurrentPosition(), ex);

        }

    }

    private void deleteCurrentDynObject() {

        if (JOptionPane.YES_OPTION == JOptionPane

            .showConfirmDialog(

                this,

                getTranslation("Are you sure you want to delete the current element?"),

                getTranslation("Delete confirmation"),

                JOptionPane.YES_NO_OPTION)) {

            try {

                model.getDynObjectSet().delete(component.getDynObject());

                reload();

            } catch (BaseException ex) {

                LOG.error("Error deleting the current DynObject in "

                    + "position: " + model.getCurrentPosition(), ex);

            }

        }

    }

    /**

     * Utility Action extension which adds a new checkEnabled() method to set

     * enabled or not depending on the isEnabled() method implementation. That

     * will only work as expected if the isEnabled() method implementation is

     * changed.

     * 

     * @author gvSIG Team

     * @version $Id$

     */

    @SuppressWarnings("serial")

    private static abstract class AbstractEnableAction extends AbstractAction {

        /**

         * @see AbstractAction#AbstractAction(String, Icon).

         */

        public AbstractEnableAction(String name, Icon icon) {

            super(name, icon);

        }

        /**

         * Checks if the action must be enabled

         */

        public void checkEnabled() {

            setEnabled(isEnabled());

        }

    }

    public void dispose() {

        model.deleteObserver(this);

        model.getDynObjectSet().deleteObserver(this);

    }

    private String getTranslation(String msg) {

        // return i18nManager.getTranslation("Tools.Swing.".concat(msg));

        return i18nManager.getTranslation(msg);

    }

    private void goFirst() {

        if (!isCurrentModified()) {

            model.first();

        }

    }

    private void goPrevious() {

        if (!isCurrentModified()) {

            model.previous();

        }

    }

    private void goNext() {

        if (!isCurrentModified()) {

            model.next();

        }

    }

    private void goLast() {

        if (!isCurrentModified()) {

            model.last();

        }

    }

    private boolean isCurrentModified() {

        if (component != null) {

            // TODO: check if the component has not saved changes

            // component.

        }

        return false;

    }

}