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

/**

 * gvSIG. Desktop Geographic Information System.

 *

 * Copyright (C) 2007-2013 gvSIG Association.

 *

 * 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 3 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.

 *

 * For any additional information, do not hesitate to contact us at info AT

 * gvsig.com, or visit our website www.gvsig.com.

 */

package org.gvsig.tools.dynform.services.dynformfield.File;

import java.awt.BorderLayout;

import java.awt.event.ActionEvent;

import java.awt.event.FocusEvent;

import java.awt.event.FocusListener;

import java.io.File;

import java.util.Objects;

import javax.swing.JButton;

import javax.swing.JFileChooser;

import javax.swing.JPanel;

import javax.swing.event.DocumentEvent;

import javax.swing.event.DocumentListener;

import javax.swing.filechooser.FileFilter;

import javax.swing.filechooser.FileNameExtensionFilter;

import javax.swing.text.JTextComponent;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dynform.DynFormFieldDefinition;

import org.gvsig.tools.dynform.JDynFormField;

import org.gvsig.tools.dynform.spi.DynFormSPIManager;

import org.gvsig.tools.dynform.spi.dynformfield.JDynFormFieldFactory;

import org.gvsig.tools.dynform.spi.dynformfield.AbstractJDynFormField;

import org.gvsig.tools.dynobject.Tags;

public class JDynFormFieldFile extends AbstractJDynFormField implements JDynFormField, FocusListener {

    protected File assignedValue = null;

    protected File currentValue = null;

    protected JTextComponent jtext = null;

    protected JButton jbutton = null;

    protected boolean readonly = false;

    public JDynFormFieldFile(

            DynFormSPIManager serviceManager,

            DynFormSPIManager.ComponentsFactory componentsFactory,

            JDynFormFieldFactory factory,

            DynFormFieldDefinition definition,

            Object value

    ) {

        super(serviceManager, componentsFactory, factory, definition, value);

        this.assignedValue = (File) value;

    }

    @Override

    public void setReadOnly(boolean readonly) {

        super.setReadOnly(readonly);

        if (this.contents != null) {

            if (readonly) {

                this.jtext.setEditable(false);

                this.jbutton.setEnabled(false);

            } else {

                this.jtext.setEditable(true);

                this.jbutton.setEnabled(true);

            }

        }

    }

    @Override

    public Object getAssignedValue() {

        return this.assignedValue;

    }

    @Override

    public void initComponent() {

        this.contents = new JPanel();

        this.contents.setLayout(new BorderLayout());

        JTextComponent text = this.getComponentsFactory().getJTextField(this.getDefinition(), null);

        this.jtext = text;

        this.fixPreferredWidth(text);

        text.addFocusListener(this);

        //this.jtext.setEditable(false);    

        this.jtext.addFocusListener(new FocusListener() {

            @Override

            public void focusGained(FocusEvent e) {

                fireFieldEnterEvent();

            }

            @Override

            public void focusLost(FocusEvent e) {

                fireFieldExitEvent();

            }

        });

        text.getDocument().addDocumentListener(new DocumentListener() {

            @Override

            public void insertUpdate(DocumentEvent e) {

                fireFieldChangedEvent();

            }

            @Override

            public void removeUpdate(DocumentEvent e) {

                fireFieldChangedEvent();

            }

            @Override

            public void changedUpdate(DocumentEvent e) {

                fireFieldChangedEvent();

            }

        });

        this.jbutton = this.getComponentsFactory().getJButton(this.getDefinition(), null);

        this.jbutton.setIcon(this.getIcon("picker-file"));

        if( StringUtils.equals("...", this.jbutton.getText()) ) {

            this.jbutton.setText("");        

        }

        this.jbutton.addActionListener((ActionEvent e) -> {

            fireFieldEnterEvent();

            onClickBrowse();

        });

        this.contents.add(jtext, BorderLayout.CENTER);

        this.contents.add(jbutton, BorderLayout.LINE_END);

        this.contents.setVisible(true);

        if (this.readonly) {

            this.jtext.setEditable(false);

            this.jbutton.setEnabled(false);

        } else {

            this.jtext.setEditable(true);

            this.jbutton.setEnabled(true);

        }

        this.setValue(this.assignedValue);

    }

    public void onClickBrowse() {

        fireFieldEnterEvent();

        File previous = this.currentValue;

        this.problemIndicator().restore();

        File initialPath = null;

        FileFilter filter = null;

        Tags tags = this.getDefinition().getTags();

        if (tags.has("path")) {

            initialPath = new File((String) tags.get("path"));

        }

        if (tags.has("filter")) {

            try {

                String extensions = (String) tags.get("filter");

                String filterDescription = extensions;

                if (tags.has("filterDescription")) {

                    filterDescription = (String) tags.get("filterDescription");

                }

                filter = new FileNameExtensionFilter(filterDescription, extensions.split("[|]"));

            } catch (Exception ex) {

                // Ignore 

            }

        }

        if (this.currentValue != null) {

            initialPath = this.currentValue.getParentFile();

        }

        File[] x = showOpenFileDialog(this.getLabel(), initialPath, filter);

        if (x == null) {

            return;

        }

        this.currentValue = x[0];

        this.jtext.setText(x[0].getPath());

        this.fireFieldChangedEventIfChanged(previous);

    }

    private void fireFieldChangedEventIfChanged(File previous) {

        if (previous == null) {

            if (this.currentValue == null) {

                return;

            }

            this.fireFieldChangedEvent();

            return;

        }

        if (this.currentValue == null) {

            this.fireFieldChangedEvent();

            return;

        }

        if (previous.getPath().equals(this.currentValue.getPath())) {

            this.fireFieldChangedEvent();

        }

    }

    @Override

    public void setValue(Object value) {

        File previous = this.currentValue;

        if (value == null) {

            this.jtext.setText("");

        } else {

            if (!(value instanceof File)) {

                LOGGER.info("setValue invoked with non File value (" + value.toString() + ").");

                return;

            }

            this.jtext.setText(((File) value).getPath());

            this.fixPreferredWidth(this.jtext);

        }

        this.assignedValue = (File) value;

        this.currentValue = this.assignedValue;

        this.fireFieldChangedEventIfChanged(previous);

    }

    public Object getValue() {

        File value = null;

        String s = "";

        s = this.jtext.getText();

        if (StringUtils.isBlank(s)){

            return null;

        }

//        if (s.trim().length() == 0) {

//            Object x = this.getDefinition().getDefaultValue();

//            if ((x != null && x instanceof File)) {

//                value = new File(x.toString());

//            } else {

//                value = null;

//            }

//        } else {

        value = new File(s);

//        }

        return value;

    }

    public boolean hasValidValue() {

        return true;

    }

    public File[] showOpenFileDialog(String title, File initialPath, FileFilter filter) {

        return showChooserDialog(title, JFileChooser.OPEN_DIALOG, JFileChooser.FILES_ONLY, false, initialPath, filter, true);

    }

    public File[] showChooserDialog(

            final String title,

            final int type, // SAVE_DIALOG / OPEN_DIALOG

            final int selectionMode, //    JFileChooser.FILES_ONLY, JFileChooser.DIRECTORIES_ONLY, JFileChooser.FILES_AND_DIRECTORIES

            final boolean multiselection,

            final File initialPath,

            final FileFilter filter,

            final boolean fileHidingEnabled

    ) {

        File[] returnValue = null;

        JFileChooser fc = new JFileChooser();

        fc.setDialogTitle(title);

        fc.setDialogType(type);

        fc.setFileSelectionMode(selectionMode);

        fc.setMultiSelectionEnabled(multiselection);

        fc.setCurrentDirectory(initialPath);

        fc.setFileFilter(filter);

        fc.setFileHidingEnabled(fileHidingEnabled);

        int r = JFileChooser.CANCEL_OPTION;

        switch (type) {

            case JFileChooser.SAVE_DIALOG:

                r = fc.showSaveDialog(this.contents);

                break;

            case JFileChooser.OPEN_DIALOG:

            default:

                r = fc.showOpenDialog(this.contents);

                break;

        }

        if (r != JFileChooser.APPROVE_OPTION) {

            returnValue = null;

        } else {

            if (fc.isMultiSelectionEnabled()) {

                returnValue = fc.getSelectedFiles();

            } else {

                returnValue = new File[]{fc.getSelectedFile()};

            }

        }

        return returnValue;

    }

    public void focusGained(FocusEvent arg0) {

        fireFieldEnterEvent();

        this.problemIndicator().restore();

    }

    public void focusLost(FocusEvent arg0) {

        fireFieldExitEvent();

    }

    public void clear() {

        Object value = this.getDefinition().getDefaultValue();

        if (value != null) {

            value = value.toString();

        } else {

            value = "";

        }

        this.jtext.setText((String) value);

    }

    protected Object getAbsoluteFile(Object value) {

        if (!(value instanceof File)) {

            return value;

        }

        File f = (File) value;

        if (!f.isAbsolute()) {

            Tags tags = this.getDefinition().getTags();

            if (tags.has("path")) {

                File folder;

                if (tags.get("path") instanceof File) {

                    folder = (File) tags.get("path");

                } else {

                    folder = new File(Objects.toString(tags.get("path"), null));

                }

                File f2 = new File(folder, f.getPath());

                if (f2.exists()) {

                    f = f2;

                } else {

                    folder = ToolsLocator.getFoldersManager().get("Project");

                    if (folder != null) {

                        f = new File(folder, f.getPath());

                    }

                }

            }

        }

        return f;

    }

    @Override

    public boolean isModified() {

        String s = this.jtext.getText();

        File assigned = (File) getAssignedValue();

        if (StringUtils.isBlank(s)) {

            return assigned != null;

        }

        try {

            File value = new File(s);

            return !Objects.equals(value, assigned);

        } catch (Exception ex) {

            return false;

        }

    }

}