| gvSIG desktop 1

package org.gvsig.tableImport.importfields.ui;

import java.awt.GridBagConstraints;

import java.awt.Insets;

import java.awt.event.FocusEvent;

import java.awt.event.FocusListener;

import java.awt.event.ItemEvent;

import java.awt.event.ItemListener;

import java.awt.event.KeyEvent;

import java.awt.event.KeyListener;

import java.beans.PropertyChangeEvent;

import javax.swing.JCheckBox;

import javax.swing.JComponent;

import javax.swing.JPanel;

import javax.swing.JTextField;

import javax.swing.event.DocumentEvent;

import javax.swing.event.DocumentListener;

public class FieldPanel extends JComponent implements DocumentListener, ItemListener,KeyListener, FocusListener {

	private static final long serialVersionUID = 1L;

	private JCheckBox chkImport = null;

	private JTextField txtSourceField = null;

	private JTextField txtTargetFieldName = null;

	private boolean txtTargetFieldName_changed = false;

	private boolean updating=false;

	/**

	 * This is the default constructor

	 */

	/**

	 * This method initializes this

	 *

	 * @return void

	 */

	protected void loadIn(JPanel panel) {

		GridBagConstraints gridBagConstraints2 = new GridBagConstraints();

		gridBagConstraints2.fill = GridBagConstraints.HORIZONTAL;

//		gridBagConstraints2.gridy = 0;

		gridBagConstraints2.weightx = 1.0;

		gridBagConstraints2.insets = new Insets(2, 2, 2, 2);

		gridBagConstraints2.gridx = 2;

		GridBagConstraints gridBagConstraints1 = new GridBagConstraints();

		gridBagConstraints1.fill = GridBagConstraints.HORIZONTAL;

//		gridBagConstraints1.gridy = 0;

		gridBagConstraints1.weightx = 1.0D;

		gridBagConstraints1.anchor = GridBagConstraints.CENTER;

		gridBagConstraints1.gridwidth = 1;

		gridBagConstraints1.insets = new Insets(2, 2, 2, 2);

		gridBagConstraints1.gridx = 1;

		GridBagConstraints gridBagConstraints = new GridBagConstraints();

		gridBagConstraints.gridx = 0;

		gridBagConstraints.anchor = GridBagConstraints.CENTER;

		//gridBagConstraints.gridy = 0;

		//this.setSize(350, 28);

		//this.setLayout(new GridBagLayout());

		//this.setPreferredSize(new Dimension(350, 28));

		panel.add(getChkImport(), gridBagConstraints);

		panel.add(getTxtSourceField(), gridBagConstraints1);

		panel.add(getTxtTargetFieldName(), gridBagConstraints2);

	}

	protected void removeFrom(JPanel panel) {

		panel.remove(getChkImport());

		panel.remove(getTxtSourceField());

		panel.remove(getTxtTargetFieldName());

	}

	/**

	 * This method initializes chkImport

	 *

	 * @return javax.swing.JCheckBox

	 */

	private JCheckBox getChkImport() {

		if (chkImport == null) {

			chkImport = new JCheckBox();

			chkImport.setName("import");

			chkImport.addItemListener(this);

		}

		return chkImport;

	}

	/**

	 * This method initializes txtSourceField

	 *

	 * @return javax.swing.JTextField

	 */

	private JTextField getTxtSourceField() {

		if (txtSourceField == null) {

			txtSourceField = new JTextField();

			txtSourceField.setName("sourceField");

			txtSourceField.setEditable(false);

		}

		return txtSourceField;

	}

	/**

	 * This method initializes txtTargetFieldName

	 *

	 * @return javax.swing.JTextField

	 */

	private JTextField getTxtTargetFieldName() {

		if (txtTargetFieldName == null) {

			txtTargetFieldName = new JTextField();

			txtTargetFieldName.getDocument().addDocumentListener(this);

			txtTargetFieldName.addFocusListener(this);

			txtTargetFieldName.addKeyListener(this);

		}

		return txtTargetFieldName;

	}

	public boolean isToImport(){

		return this.getChkImport().isSelected();

	}

	public void setToImpor(boolean value){

		this.updating=true;

		this.getChkImport().setSelected(value);

		this.updating=false;

	}

	public String getSourceField(){

		return this.getTxtSourceField().getText();

	}

	public void setSourceField(String fieldName){

		this.updating=true;

		this.getTxtSourceField().setText(fieldName);

		this.updating=false;

	}

	public String getTargetFieldName(){

		return this.getTxtTargetFieldName().getText();

	}

	public void setTargetFieldName(String fieldName){

		this.updating=true;

		this.getTxtTargetFieldName().setText(fieldName);

		this.updating=false;

	}

	public void propertyChange(PropertyChangeEvent evt) {

		if (evt.getSource().equals(this.getTxtTargetFieldName())){

			firePropertyChange("targetFieldName", evt.getOldValue(), evt.getNewValue());

		}

	}

	public void itemStateChanged(ItemEvent e) {

		boolean isSelected =e.getStateChange() == ItemEvent.SELECTED;

		if (e.getSource().equals(this.getChkImport())){

			firePropertyChange("toImport", !isSelected, isSelected);

		}

	}

	public void changedUpdate(DocumentEvent e) {

		// FIXME: Peta porque antes de que termine el evento se hace un setText

//		firePropertyChange("targetFieldName", null, this.getTargetFieldName());

		if (this.updating) return;

		this.txtTargetFieldName_changed=true;

	}

	public void insertUpdate(DocumentEvent e) {

		// FIXME: Peta porque antes de que termine el evento se hace un setText

//		firePropertyChange("targetFieldName", null, this.getTargetFieldName());

		if (this.updating) return;

		this.txtTargetFieldName_changed=true;

	}

	public void removeUpdate(DocumentEvent e) {

		// FIXME: Peta porque antes de que termine el evento se hace un setText

//		firePropertyChange("targetFieldName", null, this.getTargetFieldName());

		if (this.updating) return;

		this.txtTargetFieldName_changed=true;

	}

	public void keyPressed(KeyEvent e) {

		// TODO Auto-generated method stub

	}

	public void keyReleased(KeyEvent e) {

		if (this.txtTargetFieldName_changed){

			firePropertyChange("targetFieldName", null, this.getTargetFieldName());

			this.txtTargetFieldName_changed=false;

		}

	}

	public void keyTyped(KeyEvent e) {

		if (this.txtTargetFieldName_changed){

			firePropertyChange("targetFieldName", null, this.getTargetFieldName());

			this.txtTargetFieldName_changed=false;

		}

	}

	public void focusGained(FocusEvent e) {

		// TODO Auto-generated method stub

	}

	public void focusLost(FocusEvent e) {

		if (this.txtTargetFieldName_changed){

			firePropertyChange("targetFieldName", null, this.getTargetFieldName());

			this.txtTargetFieldName_changed=false;

		}

	}

}

package org.gvsig.tableImport.importfields.ui;

import java.awt.Dimension;

import java.awt.GridBagConstraints;

import java.awt.GridBagLayout;

import java.awt.Insets;

import java.awt.event.ItemEvent;

import java.awt.event.ItemListener;

import java.util.ArrayList;

import java.util.Iterator;

import java.util.List;

import javax.swing.DefaultComboBoxModel;

import javax.swing.JComboBox;

import javax.swing.JLabel;

import jwizardcomponent.JWizardComponents;

import jwizardcomponent.JWizardPanel;

import org.gvsig.tableImport.importfields.ImportFieldParams;

import com.hardcode.gdbms.driver.exceptions.ReadDriverException;

import com.hardcode.gdbms.engine.data.driver.DriverException;

import com.iver.andami.PluginServices;

import com.iver.andami.messages.NotificationManager;

import com.iver.cit.gvsig.ProjectExtension;

import com.iver.cit.gvsig.project.Project;

import com.iver.cit.gvsig.project.documents.table.ProjectTable;

import com.iver.cit.gvsig.project.documents.table.ProjectTableFactory;

public class LinkDefinitionPanel extends JWizardPanel implements ItemListener{

	private static final long serialVersionUID = 1L;

	private JLabel lblTable = null;

	private JComboBox cbTable = null;

	private JLabel lblTableLinkField = null;

	private JComboBox cbTableLinkField = null;

	private JLabel lblTableToImport = null;

	private JComboBox cbTableToImport = null;

	private JLabel lblLinkFieldTableToImport = null;

	private JComboBox cbLinkFieldTableToImport = null;

	private JLabel lblMessage = null;

	private JLabel lblSpace = null;

	private ImportFieldParams params = null;

	private DefaultComboBoxModel cbTable_model;

	private DefaultComboBoxModel cbTableLinkField_model;

	private DefaultComboBoxModel cbTableToImport_model;

	private DefaultComboBoxModel cbLinkFieldTableToImport_model;

	private boolean updating;

	private JLabel lblSpace2;

	/**

	 * This is the default constructor

	 */

	public LinkDefinitionPanel(JWizardComponents wizardComponents, ImportFieldParams params) {

		super(wizardComponents);

		this.params = params;

		initialize();

		this.update();

	}

	public LinkDefinitionPanel() {

		super(null);

		initialize();

	}

	public void update() {

		if (this.updating){

			return;

		}

		this.updating= true;

		try{

			if (this.params == null){

				this.updating=false;

				return;

			}

			this.fillFieldsInComboModel(this.cbTableLinkField_model,this.params.getTableFieldList());

			this.cbTableLinkField_model.setSelectedItem(this.params.getTableField());

			this.fillFieldsInComboModel(this.cbLinkFieldTableToImport_model,this.params.getTableToImportFieldList());

			this.cbLinkFieldTableToImport_model.setSelectedItem(this.params.getTableToImportField());

			if (this.params.isValidLinkParams()){

				this.lblMessage.setText(" ");

				this.setNextButtonEnabled(true);

				this.setFinishButtonEnabled(this.params.isValid());

			} else{

				this.lblMessage.setText(params.getValidationMsg());

				this.setNextButtonEnabled(false);

				this.setFinishButtonEnabled(false);

			}

			super.update();

		} finally {

			this.updating=false;

		}

	}

	private void fillFieldsInComboModel(

			DefaultComboBoxModel model,

			ArrayList fieldList) {

		model.removeAllElements();

		if (fieldList == null){

			return;

		}

		Iterator iter = fieldList.iterator();

		while (iter.hasNext()){

			model.addElement(iter.next());

		}

	}

	/**

	 * This method initializes this

	 *

	 * @return void

	 */

	private void initialize() {

		GridBagConstraints gridBagConstraints10 = new GridBagConstraints();

		gridBagConstraints10.gridx = 0;

		gridBagConstraints10.insets = new Insets(5, 5, 5, 5);

		gridBagConstraints10.anchor = GridBagConstraints.SOUTHWEST;

		gridBagConstraints10.gridy = 0;

		gridBagConstraints10.fill =GridBagConstraints.VERTICAL;

		gridBagConstraints10.weighty = 1.0;

		GridBagConstraints gridBagConstraints9 = new GridBagConstraints();

		gridBagConstraints9.gridx = 0;

		gridBagConstraints9.insets = new Insets(5, 5, 5, 5);

		gridBagConstraints9.anchor = GridBagConstraints.SOUTHWEST;

		gridBagConstraints9.gridy = 5;

		gridBagConstraints9.fill =GridBagConstraints.VERTICAL;

		gridBagConstraints9.weighty = 1.0;

		GridBagConstraints gridBagConstraints8 = new GridBagConstraints();

		gridBagConstraints8.gridx = 0;

		gridBagConstraints8.insets = new Insets(5, 5, 5, 5);

		gridBagConstraints8.anchor = GridBagConstraints.SOUTHWEST;

		gridBagConstraints8.gridy = 6;

		gridBagConstraints8.fill =GridBagConstraints.HORIZONTAL;

		gridBagConstraints8.weightx = 1;

		gridBagConstraints8.gridwidth=2;

		GridBagConstraints gridBagConstraints7 = new GridBagConstraints();

		gridBagConstraints7.fill = GridBagConstraints.HORIZONTAL;

		gridBagConstraints7.gridy = 4;

		gridBagConstraints7.weightx = 1.0;

		gridBagConstraints7.insets = new Insets(5, 15, 5, 15);

		gridBagConstraints7.anchor = GridBagConstraints.NORTHWEST;

		gridBagConstraints7.gridx = 1;

		GridBagConstraints gridBagConstraints6 = new GridBagConstraints();

		gridBagConstraints6.gridx = 0;

		gridBagConstraints6.insets = new Insets(5, 5, 5, 5);

		gridBagConstraints6.anchor = GridBagConstraints.NORTHEAST;

		gridBagConstraints6.gridy = 4;

		lblLinkFieldTableToImport = new JLabel();

		lblLinkFieldTableToImport.setText(PluginServices.getText(null,"link_field_table_to_import"));

		GridBagConstraints gridBagConstraints5 = new GridBagConstraints();

		gridBagConstraints5.fill = GridBagConstraints.HORIZONTAL;

		gridBagConstraints5.gridy = 3;

		gridBagConstraints5.weightx = 1.0;

		gridBagConstraints5.insets = new Insets(5, 15, 5, 15);

		gridBagConstraints5.anchor = GridBagConstraints.NORTHWEST;

		gridBagConstraints5.gridx = 1;

		GridBagConstraints gridBagConstraints4 = new GridBagConstraints();

		gridBagConstraints4.gridx = 0;

		gridBagConstraints4.anchor = GridBagConstraints.NORTHEAST;

		gridBagConstraints4.insets = new Insets(5, 5, 5, 5);

		gridBagConstraints4.gridy = 3;

		lblTableToImport = new JLabel();

		lblTableToImport.setText(PluginServices.getText(null,"table_to_import"));

		GridBagConstraints gridBagConstraints3 = new GridBagConstraints();

		gridBagConstraints3.fill = GridBagConstraints.HORIZONTAL;

		gridBagConstraints3.gridy = 2;

		gridBagConstraints3.weightx = 1.0;

		gridBagConstraints3.insets = new Insets(5, 15, 5, 15);

		gridBagConstraints3.anchor = GridBagConstraints.NORTHWEST;

		gridBagConstraints3.gridx = 1;

		GridBagConstraints gridBagConstraints2 = new GridBagConstraints();

		gridBagConstraints2.gridx = 0;

		gridBagConstraints2.insets = new Insets(5, 5, 5, 5);

		gridBagConstraints2.anchor = GridBagConstraints.NORTHEAST;

		gridBagConstraints2.gridy = 2;

		lblTableLinkField = new JLabel();

		lblTableLinkField.setText(PluginServices.getText(null,"link_field_of_table"));

		GridBagConstraints gridBagConstraints1 = new GridBagConstraints();

		gridBagConstraints1.fill = GridBagConstraints.HORIZONTAL;

		gridBagConstraints1.gridy = 1;

		gridBagConstraints1.weightx = 1.0;

		gridBagConstraints1.insets = new Insets(5, 15, 5, 15);

		gridBagConstraints1.anchor = GridBagConstraints.NORTHWEST;

		gridBagConstraints1.gridx = 1;

		GridBagConstraints gridBagConstraints = new GridBagConstraints();

		gridBagConstraints.gridx = 0;

		gridBagConstraints.insets = new Insets(5, 5, 5, 5);

		gridBagConstraints.anchor = GridBagConstraints.NORTHEAST;

		gridBagConstraints.gridy = 1;

		lblTable = new JLabel();

		lblTable.setText(PluginServices.getText(null,"table"));

		lblMessage = new JLabel();

		lblSpace = new JLabel();

		lblSpace2 = new JLabel();

		this.setSize(400, 300);

		this.setLayout(new GridBagLayout());

		this.setPreferredSize(new Dimension(400, 300));

		this.add(lblTable, gridBagConstraints);

		this.add(getCbTable(), gridBagConstraints1);

		this.add(lblTableLinkField, gridBagConstraints2);

		this.add(getCbTableLinkField(), gridBagConstraints3);

		this.add(lblTableToImport, gridBagConstraints4);

		this.add(getCbTableToImport(), gridBagConstraints5);

		this.add(lblLinkFieldTableToImport, gridBagConstraints6);

		this.add(getCbLinkFieldTableToImport(), gridBagConstraints7);

		this.add(lblSpace, gridBagConstraints9);

		this.add(lblMessage, gridBagConstraints8);

		this.add(lblSpace2, gridBagConstraints10);

	}

	/**

	 * This method initializes cbTable

	 *

	 * @return javax.swing.JComboBox

	 */

	private JComboBox getCbTable() {

		if (cbTable == null) {

			cbTable = new JComboBox();

			this.cbTable_model = new DefaultComboBoxModel();

			if (this.params.isLockTable()){

				this.cbTable_model.addElement(params.getTable().getName());

				this.cbTable.setEditable(false);

				cbTable.setModel(this.cbTable_model);

				this.cbTable.setSelectedIndex(0);

				this.cbTable.setEditable(false);

			} else{

				this.fillProjectTableComboModel(this.cbTable_model);

				cbTable.addItemListener(this);

				cbTable.setModel(this.cbTable_model);

				cbTable_model.setSelectedItem(null);

			}

		}

		return cbTable;

	}

	private void fillProjectTableComboModel(DefaultComboBoxModel model){

		Project project = ((ProjectExtension)PluginServices.getExtension(ProjectExtension.class)).getProject();

		List ptables= project.getDocumentsByType(ProjectTableFactory.registerName);

		Iterator iter = ptables.iterator();

		ProjectTable ptable;

		while (iter.hasNext()){

			ptable = (ProjectTable) iter.next();

			model.addElement( new ComboElement(ptable,ptable.getName()));

		}

	}

	/**

	 * This method initializes cbTableLinkField

	 *

	 * @return javax.swing.JComboBox

	 */

	private JComboBox getCbTableLinkField() {

		if (cbTableLinkField == null) {

			cbTableLinkField = new JComboBox();

			this.cbTableLinkField_model = new DefaultComboBoxModel();

			cbTableLinkField.addItemListener(this);

			cbTableLinkField.setModel(cbTableLinkField_model);

		}

		return cbTableLinkField;

	}

	/**

	 * This method initializes cbTableToImport

	 *

	 * @return javax.swing.JComboBox

	 */

	private JComboBox getCbTableToImport() {

		if (cbTableToImport == null) {

			cbTableToImport = new JComboBox();

			this.cbTableToImport_model = new DefaultComboBoxModel();

			this.fillProjectTableComboModel(this.cbTableToImport_model);

			this.cbTableToImport_model.setSelectedItem(null);

			cbTableToImport.setModel(cbTableToImport_model);

			cbTableToImport.addItemListener(this);

		}

		return cbTableToImport;

	}

	/**

	 * This method initializes cbLinkFieldTableToImport

	 *

	 * @return javax.swing.JComboBox

	 */

	private JComboBox getCbLinkFieldTableToImport() {

		if (cbLinkFieldTableToImport == null) {

			cbLinkFieldTableToImport = new JComboBox();

			this.cbLinkFieldTableToImport_model = new DefaultComboBoxModel();

			cbLinkFieldTableToImport.setModel(cbLinkFieldTableToImport_model);

			cbLinkFieldTableToImport.addItemListener(this);

		}

		return cbLinkFieldTableToImport;

	}

	private class ComboElement {

		private String description;

		private Object value;

		public ComboElement(Object value,String description){

			this.value = value;

			this.description=description;

		}

		public String toString() {

			return this.description;

		}

		public Object getValue(){

			return this.value;

		}

	}

	public void itemStateChanged(ItemEvent e) {

		if (this.updating){

			return;

		}

		if (e.getStateChange() == ItemEvent.DESELECTED){

			return;

		}

		Object src = e.getSource();

		ComboElement element = null;

		String strElement=null;

		try{

			element = (ComboElement) e.getItem();

		} catch (ClassCastException ex){

			strElement= (String) e.getItem();

		}

		if (src == this.cbTable){

			if (this.params.isLockTable()){

				return;

			}

			try {

				this.params.setTable((ProjectTable)element.getValue());

			} catch (ReadDriverException e1) {

				NotificationManager.addError(e1);

			}

		} else if (src == this.cbTableLinkField){

			this.params.setTableField((String)strElement);

		} else if (src == this.cbTableToImport){

			try {

				this.params.setTableToImport((ProjectTable)element.getValue());

			} catch (ReadDriverException e1) {

				NotificationManager.addError(e1);

			}

		} else if (src == this.cbLinkFieldTableToImport){

			this.params.setTableToImportField(strElement);

		}

		this.update();

	}

}

package org.gvsig.tableImport.importfields.ui;

import java.awt.Dimension;

import java.awt.GridBagConstraints;

import java.awt.GridBagLayout;

import java.awt.Insets;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import java.beans.PropertyChangeEvent;

import java.beans.PropertyChangeListener;

import java.util.ArrayList;

import java.util.Iterator;

import javax.swing.JButton;

import javax.swing.JLabel;

import javax.swing.JPanel;

import javax.swing.JScrollPane;

import jwizardcomponent.JWizardComponents;

import jwizardcomponent.JWizardPanel;

import org.gvsig.tableImport.importfields.ImportFieldParams;

import org.gvsig.tableImport.importfields.ImportFieldParams.FielToImport;

import com.iver.andami.PluginServices;

public class ImportFieldPanel extends JWizardPanel implements PropertyChangeListener, ActionListener {

	private static final long serialVersionUID = 1L;

	private JPanel pLista = null;

	private JPanel pButtons = null;

	private JButton bAll = null;

	private JButton bNone = null;

	private JLabel lblSpace = null;

	private JScrollPane jScrollPane = null;

	private JLabel lblMessage = null;

	private boolean updating;

	private ImportFieldParams params = null;

	private GridBagConstraints pLista_gbContraints;

	private ArrayList fields = new ArrayList();

	/**

	 * This is the default constructor

	 */

	public ImportFieldPanel(JWizardComponents wizardComponents, ImportFieldParams params) {

		super(wizardComponents);

		initialize();

		this.params = params;

		initialize();

		this.update();

	}

	public ImportFieldPanel() {

		super(null);

		initialize();

	}

	/**

	 * This method initializes this

	 *

	 * @return void

	 */

	private void initialize() {

		GridBagConstraints gridBagConstraints31 = new GridBagConstraints();

		gridBagConstraints31.gridx = 0;

		gridBagConstraints31.fill = GridBagConstraints.HORIZONTAL;

		gridBagConstraints31.gridy = 1;

		GridBagConstraints gridBagConstraints11 = new GridBagConstraints();

		gridBagConstraints11.fill = GridBagConstraints.BOTH;

		gridBagConstraints11.weighty = 1.0;

		gridBagConstraints11.insets = new Insets(5, 5, 5, 5);

		gridBagConstraints11.weightx = 1.0;

		gridBagConstraints11.anchor = GridBagConstraints.FIRST_LINE_START;

		GridBagConstraints gridBagConstraints = new GridBagConstraints();

		gridBagConstraints.fill = GridBagConstraints.HORIZONTAL;

		gridBagConstraints.gridy = 2;

		gridBagConstraints.weightx = 1.0;

		gridBagConstraints.weighty = 0.0D;

		gridBagConstraints.gridheight = 1;

		gridBagConstraints.gridx = 0;

		this.setSize(400, 300);

		this.setLayout(new GridBagLayout());

		this.setPreferredSize(new Dimension(400, 300));

		this.add(getJScrollPane(), gridBagConstraints11);

		this.add(getPButtons(), gridBagConstraints);

		this.add(lblMessage, gridBagConstraints31);

	}

	/**

	 * This method initializes lLista

	 *

	 * @return javax.swing.JList

	 */

	private JPanel getLLista() {

		if (pLista == null) {

			pLista = new JPanel();

			pLista.setName("lista");

			pLista.setLayout(new GridBagLayout());

			pLista_gbContraints = new GridBagConstraints();

			pLista_gbContraints.anchor = GridBagConstraints.FIRST_LINE_START;

			pLista_gbContraints.fill = GridBagConstraints.HORIZONTAL;

			pLista_gbContraints.weightx = 1;

			pLista_gbContraints.gridx=1;

//			pLista_gbContraints.gridy=GridBagConstraints.REMAINDER;

		}

		return pLista;

	}

	/**

	 * This method initializes pButtons

	 *

	 * @return javax.swing.JPanel

	 */

	private JPanel getPButtons() {

		if (pButtons == null) {

			lblMessage = new JLabel();

			if (this.params == null){

				lblMessage.setText("Message");

			} else{

				lblMessage.setText(" ");

			}

			GridBagConstraints gridBagConstraints4 = new GridBagConstraints();

			gridBagConstraints4.fill = GridBagConstraints.HORIZONTAL;

			gridBagConstraints4.weightx = 1.0D;

			gridBagConstraints4.gridy = 1;

			gridBagConstraints4.gridx = 0;

			lblSpace = new JLabel();

			lblSpace.setText(" ");

			GridBagConstraints gridBagConstraints3 = new GridBagConstraints();

			gridBagConstraints3.anchor = GridBagConstraints.EAST;

			gridBagConstraints3.ipady = 0;

			gridBagConstraints3.insets = new Insets(5, 5, 5, 5);

			gridBagConstraints3.gridy = 1;

			gridBagConstraints3.ipadx = 0;

			GridBagConstraints gridBagConstraints2 = new GridBagConstraints();

			gridBagConstraints2.anchor = GridBagConstraints.EAST;

			gridBagConstraints2.ipady = 0;

			gridBagConstraints2.insets = new Insets(5, 5, 5, 5);

			gridBagConstraints2.gridy = 1;

			gridBagConstraints2.ipadx = 0;

			pButtons = new JPanel();

			pButtons.setLayout(new GridBagLayout());

			pButtons.add(lblSpace, gridBagConstraints4);

			pButtons.add(getBAll(), gridBagConstraints2);

			pButtons.add(getBNone(), gridBagConstraints3);

		}

		return pButtons;

	}

	/**

	 * This method initializes bAll

	 *

	 * @return javax.swing.JButton

	 */

	private JButton getBAll() {

		if (bAll == null) {

			bAll = new JButton();

			bAll.setText(PluginServices.getText(null,"select_all"));

			bAll.setActionCommand("all");

			bAll.setName("all");

			bAll.addActionListener(this);

		}

		return bAll;

	}

	/**

	 * This method initializes bNone

	 *

	 * @return javax.swing.JButton

	 */

	private JButton getBNone() {

		if (bNone == null) {

			bNone = new JButton();

			bNone.setText(PluginServices.getText(null,"clear_selection"));

			bNone.setActionCommand("none");

			bNone.setName("none");

			bNone.addActionListener(this);

		}

		return bNone;

	}

	/**

	 * This method initializes jScrollPane

	 *

	 * @return javax.swing.JScrollPane

	 */

	private JScrollPane getJScrollPane() {

		if (jScrollPane == null) {

			jScrollPane = new JScrollPane();

			jScrollPane.setViewportView(getLLista());

		}

		return jScrollPane;

	}

	public void update() {

		try{

			if (this.updating){

				return;

			}

			this.updating= true;

			if (this.params == null){

				return;

			}

			ArrayList fieldsToImport = this.params.getFieldsToImport();

			if (fieldsToImport == null){

				this.getLLista().removeAll();

				return;

			}

			this.fillList(fieldsToImport);

			if (this.params.isValid()){

				this.setFinishButtonEnabled(true);

				this.lblMessage.setText(" ");

			}else{

				this.setFinishButtonEnabled(false);

				this.lblMessage.setText(params.getValidationMsg());

			}

			super.update();

		} finally {

			this.updating=false;

		}

	}

	private void fillList(ArrayList fieldsToImport) {

		FielToImport fieldDef;

		FieldPanel fieldElement;

		int i;

		for (i=0;i<fieldsToImport.size();i++){

			fieldDef = (FielToImport) fieldsToImport.get(i);

			if (this.fields.size()> i){

				fieldElement = (FieldPanel) this.fields.get(i);

			} else{

				fieldElement = this.addNewFieldPanel();

			}

			fieldElement.setToImpor(fieldDef.toImport);

			fieldElement.setSourceField(fieldDef.originalFieldName);

			fieldElement.setTargetFieldName(fieldDef.fieldNameToUse);

		}

		for (i=this.fields.size()-1;i>=fieldsToImport.size();i--){

			fieldElement= (FieldPanel) this.fields.remove(i);;

			fieldElement.removeFrom(this.getLLista());

		}

	}

	private FieldPanel addNewFieldPanel() {

		FieldPanel fieldElement = new FieldPanel();

		fieldElement.addPropertyChangeListener(this);

		fieldElement.loadIn(this.getLLista());

		this.fields.add(fieldElement);

		this.doLayout();

		return fieldElement;

	}

	public void propertyChange(PropertyChangeEvent evt) {

		if (this.updating){

			return;

		}

		if (!(evt.getSource() instanceof FieldPanel)){

			return;

		}

		String srcField = ((FieldPanel) evt.getSource()).getSourceField();

		Iterator iter = this.params.getFieldsToImport().iterator();

		while (iter.hasNext()){

			FielToImport field = (FielToImport) iter.next();

			if (field.originalFieldName.equals(srcField)){

				if (evt.getPropertyName().equals("toImport")){

					field.toImport = ((Boolean)evt.getNewValue()).booleanValue();

//					System.out.println("set to " +field.toImport +" toImpor of "+ srcField);

				} else if (evt.getPropertyName().equals("targetFieldName")){

					field.fieldNameToUse = (String) evt.getNewValue();

//					System.out.println("set to " +field.fieldNameToUse +" nameToUse of "+ srcField);

				}

				break;

			}

		}

		this.update();

	}

	public void actionPerformed(ActionEvent e) {

		boolean toImpor=false;

		if (e.getActionCommand().equals(this.getBAll().getActionCommand())){

			toImpor=true;

		} else if (e.getActionCommand().equals(this.getBNone().getActionCommand())){

			toImpor=false;

		}

		Iterator iter = this.params.getFieldsToImport().iterator();

		while (iter.hasNext()){

			((FielToImport)iter.next()).toImport=toImpor;

		}

		this.update();

	}

}

package org.gvsig.tableImport.importfields;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.Iterator;

import java.util.Map;

import javax.swing.ImageIcon;

import org.gvsig.tableImport.importfields.ImportFieldParams.FielToImport;

import org.gvsig.tableImport.importfields.ui.ImportFieldPanel;

import org.gvsig.tableImport.importfields.ui.LinkDefinitionPanel;

import com.hardcode.gdbms.driver.exceptions.ReadDriverException;

import com.hardcode.gdbms.engine.data.driver.DriverException;

import com.hardcode.gdbms.engine.values.Value;

import com.iver.andami.PluginServices;

import com.iver.andami.messages.NotificationManager;

import com.iver.andami.plugins.Extension;

import com.iver.andami.ui.mdiManager.IWindow;

import com.iver.andami.ui.wizard.WizardAndami;

import com.iver.cit.gvsig.EditionUtilities;

import com.iver.cit.gvsig.fmap.core.IRow;

import com.iver.cit.gvsig.fmap.drivers.FieldDescription;

import com.iver.cit.gvsig.fmap.drivers.ILayerDefinition;

import com.iver.cit.gvsig.fmap.edition.DefaultRowEdited;

import com.iver.cit.gvsig.fmap.edition.EditableAdapter;

import com.iver.cit.gvsig.fmap.edition.EditionEvent;

import com.iver.cit.gvsig.fmap.edition.IEditableSource;

import com.iver.cit.gvsig.fmap.edition.IRowEdited;

import com.iver.cit.gvsig.fmap.edition.ISpatialWriter;

import com.iver.cit.gvsig.fmap.edition.IWriteable;

import com.iver.cit.gvsig.fmap.edition.IWriter;

import com.iver.cit.gvsig.fmap.edition.VectorialEditableAdapter;

import com.iver.cit.gvsig.fmap.layers.FLyrVect;

import com.iver.cit.gvsig.fmap.layers.SelectableDataSource;

import com.iver.cit.gvsig.project.documents.table.gui.Table;

/**

 * Extensi?n que permite importar datos en una tabla.

 *

 * @author jmvivo

 */

public class ImportFieldsExtension extends Extension {

	public void initialize() {

		// TODO Auto-generated method stub

	}

    /**

     * @see com.iver.andami.plugins.IExtension#isEnabled()

     */

    public boolean isEnabled() {

        IWindow v = PluginServices.getMDIManager().getActiveWindow();

        if (!(v instanceof Table)) {

            return false;

        }

        IEditableSource ies=((Table)v).getModel().getModelo();

        if (!(ies instanceof IWriteable)){

        	return false;

        }

        IWriter writer =((IWriteable) ies).getWriter();

   	 	if (writer == null){

   	 		return false;

   	 	}

   	 	if (!writer.canAlterTable()){

   	 		return false;

   	 	}

        return true;

    }

    /**

     * @see com.iver.andami.plugins.IExtension#isVisible()

     */

    public boolean isVisible() {

        IWindow v = PluginServices.getMDIManager().getActiveWindow();

        if (v == null) {

            return false;

//        } else if (!(v instanceof Table) && !(v instanceof BaseView)) {

        } else if (!(v instanceof Table) ) {

            return false;

        }

        return true;

    }

	public void execute(String actionCommand) {

    	ImportFieldParams param = new ImportFieldParams();

    	IWindow v = PluginServices.getMDIManager().getActiveWindow();

    	if (v instanceof Table){

    		Table table = (Table) v;

    		param.setLockTable(true);

    		try {

				param.setTable(table.getModel());

			} catch (ReadDriverException e) {

				NotificationManager.showMessageError(PluginServices.getText(null, "Failed_filling_table"), e);

			}

    	}

		ImageIcon logo = new javax.swing.ImageIcon(this.getClass().getClassLoader().getResource("images/package_graphics.png"));

		WizardAndami wizard = new WizardAndami(logo);

		// Adds the wizard panels:

		LinkDefinitionPanel linkPanel = new LinkDefinitionPanel(wizard.getWizardComponents(),param);

		wizard.getWizardComponents().addWizardPanel(linkPanel);

		ImportFieldPanel fieldsPanel = new ImportFieldPanel(wizard.getWizardComponents(),param);

		wizard.getWizardComponents().addWizardPanel(fieldsPanel);

		wizard.getWizardComponents().getFinishButton().setEnabled(false);

		wizard.getWindowInfo().setWidth(640);

		wizard.getWindowInfo().setHeight(350);

		wizard.getWindowInfo().setTitle(PluginServices.getText(this, "import_fields"));

        wizard.getWizardComponents().setFinishAction(new ImportFieldsAction(wizard ,param));

		PluginServices.getMDIManager().addWindow(wizard);

	}

	public void doImportField(ImportFieldParams params) throws Exception{

		if (!params.isValid()){

			//TODO: ver que excepcion a lanzar

			throw new Exception("invalid Paramenters: "+ params.getValidationMsg());

		}

		IEditableSource edSource=null;

		IEditableSource edSourceToImport=params.getTableToImport().getModelo();

		SelectableDataSource rsSourceToImport=edSourceToImport.getRecordset();

		ArrayList fieldsToImport = new ArrayList();

		ArrayList fieldsToImport_des= new ArrayList();

		ArrayList fieldsToImport_pos= new ArrayList();

		Iterator iter;

		Map values;

		int i;

		try{

			rsSourceToImport.start();

			// Cargamos la lista con los campos que vamos a importar

			iter =params.getFieldsToImport().iterator();

			FielToImport fieldToImport;

			while (iter.hasNext()){

				fieldToImport = (FielToImport) iter.next();

				if (fieldToImport.toImport){

					fieldsToImport.add(fieldToImport);

				}

			}

			// Cargamos la lista de la definicio de capos desde la

			// tabla a importar

			iter = fieldsToImport.iterator();

			FieldDescription[] toImportAllFieldsDescription = edSourceToImport.getFieldsDescription();

			FieldDescription tmpFieldDesc, newFieldDesc;

			while (iter.hasNext()){

				fieldToImport = (FielToImport) iter.next();

				for (i=0;i<toImportAllFieldsDescription.length;i++){

					tmpFieldDesc =toImportAllFieldsDescription[i];

					if (tmpFieldDesc.getFieldName().equals(fieldToImport.originalFieldName)){

						newFieldDesc = tmpFieldDesc.cloneField();

						newFieldDesc.setFieldLength(tmpFieldDesc.getFieldLength());

						newFieldDesc.setFieldName(fieldToImport.fieldNameToUse);

						newFieldDesc.setDefaultValue(tmpFieldDesc.getDefaultValue());

						newFieldDesc.setFieldAlias(fieldToImport.fieldNameToUse);

						newFieldDesc.setFieldType(tmpFieldDesc.getFieldType());

						fieldsToImport_des.add(newFieldDesc);

						fieldsToImport_pos.add(new Integer(i));

					}

				}

			}

			//Cagamos los valores en un hash

			values= this.loadValuesFromSource(

					rsSourceToImport,

					params.getTableToImportField(),

					fieldsToImport_pos);

		} catch (Exception e){

			throw e;

		}finally{

			rsSourceToImport.stop();

			rsSourceToImport = null;

			edSourceToImport = null;

		}

		FLyrVect layer=null;

		boolean changeEditing = false;

		// Ponemos en edicion si no lo esta

		if (params.getTable().getAssociatedTable() instanceof FLyrVect){

			// Viene de una capa

			layer = (FLyrVect) params.getTable().getAssociatedTable();

			if (!layer.isEditing()){

				layer.setEditing(true);

				changeEditing=true;

			}

			edSource = (VectorialEditableAdapter)layer.getSource();

		} else {

			// es una tabla normal

			edSource = params.getTable().getModelo();

			if (!edSource.isEditing()){

				edSource.startEdition(EditionEvent.ALPHANUMERIC);

				changeEditing=true;

			}

		}

		edSource.startComplexRow();

		int originalFieldsCount = edSource.getRecordset().getFieldCount();

		int finalFieldsCount = originalFieldsCount + fieldsToImport.size();

		// A?adimos los campos

		iter = fieldsToImport_des.iterator();

		while (iter.hasNext()){

			((EditableAdapter)edSource).addField((FieldDescription) iter.next());

		}

		// Recorremos la fuente y vamos actualizando

		int rowCount = edSource.getRowCount();

		IRowEdited originalRow;

		IRow newRow;

		IRowEdited newRowEdited;

		Value[] finalValues;

		Value[] originalValues;

		Value[] valuesToUse;

		Value key;

		int column;

		int srcKeyPos = edSource.getRecordset().getFieldIndexByName(params.getTableField());

		for (i=0;i<rowCount;i++){

			originalRow = edSource.getRow(i);

			key = originalRow.getAttribute(srcKeyPos);

			valuesToUse = (Value[]) values.get(key);

			if (valuesToUse == null){

				continue;

			}

			newRow = originalRow.getLinkedRow().cloneRow();

			originalValues = newRow.getAttributes();

			finalValues = new Value[finalFieldsCount];

			System.arraycopy(originalValues, 0, finalValues, 0, originalFieldsCount);

			for (column = 0;column < valuesToUse.length;column++){

				finalValues[column+originalFieldsCount]= valuesToUse[column];

			}

			newRow.setAttributes(finalValues);

			newRowEdited = new DefaultRowEdited(newRow,

	    			 IRowEdited.STATUS_MODIFIED, i);

			edSource.modifyRow(newRowEdited.getIndex(), newRowEdited.getLinkedRow(), "",

					 EditionEvent.ALPHANUMERIC);

		}

		edSource.endComplexRow("Import fields");

		if (changeEditing){

			if (layer == null){

				IWriter writer= ((IWriteable)edSource).getWriter();

				writer.initialize(edSource.getTableDefinition());

				edSource.stopEdition(writer, EditionEvent.ALPHANUMERIC);

				edSource.getSelection().clear();

			} else{

				layer.setRecordset(edSource.getRecordset());

				ISpatialWriter spatialWriter = (ISpatialWriter) ((VectorialEditableAdapter)edSource).getWriter();

				ILayerDefinition lyrDef =EditionUtilities.createLayerDefinition(layer);

				spatialWriter.initialize(lyrDef);

				edSource.stopEdition(spatialWriter,EditionEvent.ALPHANUMERIC);

				layer.setEditing(false);

				edSource.getSelection().clear();

			}

		}

	}

	private Map loadValuesFromSource(SelectableDataSource source, String keyFieldName, ArrayList fieldsPositions) throws ReadDriverException{

		HashMap values= new HashMap();

		int row,i;

		Value[] rowValues;

		Value key;

		int keyPos = source.getFieldIndexByName(keyFieldName);

		long rowCount =source.getRowCount();

		for (row=0;row < rowCount;row++){

			key = source.getFieldValue(row, keyPos);

			if (values.containsKey(key)){

				continue;

			}

			rowValues = new Value[fieldsPositions.size()];

			for (i=0;i<fieldsPositions.size();i++){

				rowValues[i]=source.getFieldValue(row, ((Integer)fieldsPositions.get(i)).intValue());

			}

			values.put(key, rowValues);

		}

		return values;

	}

}

package org.gvsig.tableImport.importfields;

import jwizardcomponent.FinishAction;

import com.iver.andami.PluginServices;

import com.iver.andami.messages.NotificationManager;

import com.iver.andami.ui.mdiManager.IWindow;

import com.iver.andami.ui.wizard.WizardAndami;

import com.iver.cit.gvsig.project.documents.table.gui.Table;

public class ImportFieldsAction extends FinishAction {

	private WizardAndami wizard;

	private ImportFieldParams params;

	public ImportFieldsAction(WizardAndami wizard,ImportFieldParams params) {

		super(wizard.getWizardComponents());

		this.wizard = wizard;

		this.params = params;

	}

	public void performAction() {

		if (params.isValid()){

			ImportFieldsExtension ext = (ImportFieldsExtension) PluginServices.getExtension(ImportFieldsExtension.class);

			try {

				ext.doImportField(this.params);

			} catch (Exception e) {

				NotificationManager.addError(e);

				return;

			}

		}

		PluginServices.getMDIManager().closeWindow(this.wizard);

		//TODO: Cuando la tabla es de una capa y no esta en edici?n no se refresca

		IWindow[] windows = PluginServices.getMDIManager().getAllWindows();

		Table tableWindow;

		for (int i=0;i<windows.length;i++){

			if (windows[i] instanceof Table){

				tableWindow = (Table) windows[i];

				if (tableWindow.getModel().equals(params.getTable())){

					tableWindow.setModel(params.getTable());

					break;

				}

			}

		}

	}

}

package org.gvsig.tableImport.importfields;

import java.util.ArrayList;

import java.util.Iterator;

import com.hardcode.gdbms.driver.exceptions.ReadDriverException;

import com.hardcode.gdbms.engine.data.driver.DriverException;

import com.iver.andami.PluginServices;

import com.iver.cit.gvsig.fmap.layers.SelectableDataSource;

import com.iver.cit.gvsig.project.documents.table.ProjectTable;

public class ImportFieldParams {

	private boolean lockTable=false;

	private ArrayList tableFieldList = null;

	private ArrayList tableFieldList_types = null;

	private ProjectTable table=null;

	private ProjectTable tableToImport=null;

	private ArrayList tableToImportFieldList;

	private ArrayList tableToImportFieldList_types;

	private ArrayList fieldsToImport=null;

	private String tableField=null;

	private String tableToImportField=null;

	public String getTableToImportField() {

		return tableToImportField;

	}

	public void setTableToImportField(String tableToImportField) {

		this.tableToImportField = tableToImportField;

	}

	private String validationMsg="";

	public boolean isValidLinkParams(){

		this.clearValidationMsg();

		if (this.table == null){

			this.validationMsg=PluginServices.getText(null,"missing_table");

			return false;

		}

		if (this.tableFieldList == null){

			this.validationMsg=PluginServices.getText(null,"cant_load_table_fields");

			return false;

		}

		if (this.tableToImport == null){

			this.validationMsg=PluginServices.getText(null,"missing_table_to_import");

			return false;

		}

		if (this.tableToImportFieldList == null){

			this.validationMsg=PluginServices.getText(null,"cant_load_table_to_import_fields");

			return false;

		}

		if (this.tableField == null || this.tableField.length()== 0){

			this.validationMsg=PluginServices.getText(null,"missing_table_field_for_link");

			return false;

		}

		if (this.tableToImportField == null || this.tableToImportField.length()== 0){

			this.validationMsg=PluginServices.getText(null,"missing_table_to_import_field_for_link");

			return false;

		}

		if (!this.tableFieldList.contains(this.tableField)){

			this.validationMsg=PluginServices.getText(null,"field_for_link_not_found_in_table");

			return false;

		}

		if (!this.tableToImportFieldList.contains(this.tableToImportField)){

			this.validationMsg=PluginServices.getText(null,"field_for_link_not_found_in_table_to_import");

			return false;

		}

		if (!this.isCompatibleFieldTypes(

				(Integer)this.tableFieldList_types.get(

						this.tableFieldList.indexOf(this.tableField)),

				(Integer)this.tableToImportFieldList_types.get(

						this.tableToImportFieldList.indexOf(this.tableToImportField))

				)){

			this.validationMsg=PluginServices.getText(null,"incompatible_types_of_link_fields");

			return false;

		}

		return true;

	}

	private boolean isCompatibleFieldTypes(Integer object, Integer object2) {

		// TODO implementar mejor

		return object.intValue() == object2.intValue();

	}

	public boolean isValid(){

		this.clearValidationMsg();

		if (!this.isValidLinkParams())

			return false;

		if(this.fieldsToImport == null){

			this.loadFieldsToImport();

//			this.validationMsg=PluginServices.getText(null,"missing_fields_to_import_list");

			return false;

		}

		boolean isSelectedAField=false;

		boolean haveFieldNameConflict=false;

		Iterator iter = this.fieldsToImport.iterator();

		Iterator iterTable;

		while (iter.hasNext()){

			FielToImport field = (FielToImport) iter.next();

			if (field.toImport){

				isSelectedAField=true;

				iterTable = this.tableFieldList.iterator();

				while (iterTable.hasNext()){

					if (((String)iterTable.next()).equals(field.fieldNameToUse)){

						this.validationMsg=PluginServices.getText(null, "field_name_conflict") +": " +field.fieldNameToUse;

						haveFieldNameConflict=true;

						break;

					}

				}

			}

		}

		if (!isSelectedAField){

			this.validationMsg=PluginServices.getText(null, "missing_field_to_import");

			return false;

		}

		return !haveFieldNameConflict;

	}

	private void loadFieldsToImport() {

		Iterator iter = this.tableToImportFieldList.iterator();

		if (this.fieldsToImport == null){

			this.fieldsToImport = new ArrayList();

		}

		FielToImport field;

		while (iter.hasNext()){

			field = new FielToImport();

			field.originalFieldName = (String) iter.next();

			field.fieldNameToUse= field.originalFieldName;

			this.addFieldsToImportContains(field);

		}

	}

	private void addFieldsToImportContains(FielToImport field){

		Iterator iter = this.fieldsToImport.iterator();

		FielToImport old;

		boolean found=false;

		while (iter.hasNext()){

			old = (FielToImport) iter.next();

			if (old.originalFieldName.equals(field.originalFieldName)){

				found=true;

				break;

			}

		}

		if (!found){

			this.fieldsToImport.add(field);

		}

	}

	public class FielToImport{

		public boolean toImport=false;

		public String originalFieldName=null;

		public String fieldNameToUse=null;

	}

	public ProjectTable getTable() {

		return table;

	}

	public void setTable(ProjectTable table) throws ReadDriverException {

		if (this.table == table)

			return;

		this.table = table;

		this.fieldsToImport=null;

		this.tableFieldList=null;

		this.tableFieldList_types=null;

		this.tableField=null;

		if (this.table == null){

			return;

		}

		try {

			SelectableDataSource ds = this.table.getModelo().getRecordset();

			ds.start();

		String[] names= ds.getFieldNames();

		this.tableFieldList = new ArrayList(names.length);

		this.tableFieldList_types = new ArrayList(names.length);

		for (int i=0;i<names.length;i++){