Application: gvSIG desktop

<?xml version="1.0" encoding="UTF-8"?>

<classpath>

	<classpathentry kind="src" path="src"/>

	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/>

	<classpathentry combineaccessrules="false" kind="src" path="/libIverUtiles"/>

	<classpathentry combineaccessrules="false" kind="src" path="/libFMap"/>

	<classpathentry combineaccessrules="false" kind="src" path="/_fwAndami"/>

	<classpathentry combineaccessrules="false" kind="src" path="/appgvSIG"/>

	<classpathentry kind="src" path="test"/>

	<classpathentry kind="con" path="org.eclipse.jdt.junit.JUNIT_CONTAINER/3.8.1"/>

	<classpathentry kind="lib" path="/libFMap/lib/gdbms-0.8-SNAPSHOT.jar" sourcepath="/libGDBMS"/>

	<classpathentry kind="output" path="bin"/>

</classpath>

<?xml version="1.0" encoding="UTF-8"?>

<projectDescription>

	<name>libAnimation</name>

	<comment></comment>

	<projects>

	</projects>

	<buildSpec>

		<buildCommand>

			<name>org.eclipse.jdt.core.javabuilder</name>

			<arguments>

			</arguments>

		</buildCommand>

	</buildSpec>

	<natures>

		<nature>org.eclipse.jdt.core.javanature</nature>

	</natures>

</projectDescription>

package com.iver.cit.gvsig.animation.test;

import com.iver.cit.gvsig.animation.IAnimationType;

public class Animation3D implements IAnimationType {

	private String className;

	private String Description;

	private String Name;

	private int typeTrack = IAnimationType.TIME_TYPE_TRACK;

	public String getClassName() {

		return className;

	}

	public String getDescription() {

		return Description;

	}

	public String getName() {

		return Name;

	}

	public void setClassName(String className) {

		this.className = className;

	}

	public void setDescription(String description) {

		Description = description;

	}

	public void setName(String name) {

		Name = name;

	}

	public void AppliesToObject(Object animated) {

		// TODO Auto-generated method stub

	}

	public int getTypeTrack() {

		return typeTrack;

	}

	public void setTypeTrack(int typeTrack) {

		this.typeTrack = typeTrack;

	}

	public Object getAnimatedObject() {

		// TODO Auto-generated method stub

		return null;

	}

	public void setAnimatedObject(Object object) {

		// TODO Auto-generated method stub

	}

}

package com.iver.cit.gvsig.animation.test;

import com.iver.cit.gvsig.animation.AnimationFactory;

public class AnimationTypeFactory3D extends AnimationFactory {

	public static String registerName = "Animation3D";

	public static Animation3D animation3D;

	static {

		if (animation3D == null) {

			animation3D = new Animation3D();

			animation3D.setClassName("Animation3D");

			animation3D.setName("Animation3D");

			animation3D.setDescription("Hola caracola");

		}

	}

	public Object create() {

       return animation3D;

	}

	/**

	 * Registers in the points of extension the Factory with alias.

	 * 

	 */

	public static void register() {

		register(registerName, new AnimationTypeFactory3D(), "com.iver.cit.gvsig.animation.test.Animation3D");

	}

	public String getRegisterName() {

		return registerName;

	}

}

package com.iver.cit.gvsig.animation.timer;

public interface IUpdateCallBack {

	public void update();

}

package com.iver.cit.gvsig.animation.timer;

import java.util.ArrayList;

import java.util.List;

// this class is only an example. it isn?t used in librarys

public class AnimationTimer  implements Runnable {

	double milis;

	private boolean finish;

	private List callBackList;

	private Thread thread;

    /**

     * Lanza un timer cada segundo.

     */

    public AnimationTimer()

    {

    }

	public void run() {

		while (true) {

			try {

				Thread.sleep((long) milis);

				synchronized (this) {

					if (finish) {

						break;

					}

				}

			} catch (InterruptedException e) {

				e.printStackTrace();

			}

			//Updating 

			Update();

		}		

	}

	public synchronized void end() {

		finish = true;

		thread.stop();

	}

	private void Update() {

		// TODO Auto-generated method stub

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

			IUpdateCallBack element = (IUpdateCallBack) callBackList.get(i);

			element.update();		

		}

	}

	public void start(double milis) {

		this.milis = milis;

		// Create the thread supplying it with the runnable object

		thread = new Thread(this);

		// Start the thread

		thread.start();

	}

	public void addCallBackObject(IUpdateCallBack object) {

		if (callBackList == null)

			callBackList =  new ArrayList(); 

		callBackList.add(object);

	}

}

package com.iver.cit.gvsig.animation;

import java.util.ArrayList;

import java.util.List;

import com.iver.cit.gvsig.animation.traks.AnimationDatedTrack;

import com.iver.cit.gvsig.animation.traks.AnimationTimeTrack;

import com.iver.cit.gvsig.animation.traks.IAnimationTrack;

import com.iver.utiles.IPersistence;

import com.iver.utiles.XMLEntity;

public class AnimationContainer implements IPersistence {

	// IAnimationTrakc List

	public List AnimationTrackList;

	private String className;

	private static AnimationPlayer animationPlayer = new AnimationPlayer();

	public AnimationContainer() {

		List aniTrackList = this.getAnimationTrackList();

		aniTrackList = new ArrayList();

		this.setAnimationTrackList(aniTrackList);

	}

	/**

	 * @param animationType

	 * @return

	 */

	public List getTackListOfType(IAnimationType animationType) {

		List typeList = new ArrayList();

		for (int i = 0; i < this.AnimationTrackList.size(); i++) {

			IAnimationTrack trackElement = (IAnimationTrack) this.AnimationTrackList

					.get(i);

			if (animationType.getClassName().equals(

					trackElement.getAnimationType().getClassName())) {

				typeList.add(trackElement);

			}

		}

		return typeList;

	}

	/**

	 * @param animationType

	 * @return

	 */

	public IAnimationTrack CreateDatedTrack(IAnimationType animationType) {

		List aniTrackList = this.getAnimationTrackList();

		if (aniTrackList == null) {

			aniTrackList = new ArrayList();

		}

		AnimationDatedTrack ADTrack = new AnimationDatedTrack(animationType);

		aniTrackList.add(ADTrack);

		this.setAnimationTrackList(aniTrackList);

		return ADTrack;

	}

	public IAnimationTrack CreateTimeTrack(IAnimationType animationType) {

		List aniTrackList = this.getAnimationTrackList();

		if (aniTrackList == null) {

			aniTrackList = new ArrayList();

		}

		AnimationTimeTrack ADTrack = new AnimationTimeTrack(animationType);

		aniTrackList.add(ADTrack);

		this.setAnimationTrackList(aniTrackList);

		return ADTrack;

	}

	/**

	 * @param animationTrack

	 */

	public void addTrack(IAnimationTrack animationTrack) {

		IAnimationTrack track = findTrack(animationTrack.getName());

		if (track == null) {

			this.AnimationTrackList.add(animationTrack);

		}

	}

	/**

	 * @param name

	 * @return

	 */

	public IAnimationTrack findTrack(String name) {

		IAnimationTrack IAT = null;

		for (int i = 0; i < this.AnimationTrackList.size(); i++) {

			IAnimationTrack trackElement = (IAnimationTrack) this.AnimationTrackList

					.get(i);

			if (trackElement.getName().equals(name)) {

				IAT = trackElement;

			}

		}

		return IAT;

	}

	/**

	 * @param animationTrack

	 */

	public void removeTrack(IAnimationTrack animationTrack) {

		animationTrack.removeAllIntervals();

		this.AnimationTrackList.remove(animationTrack);

	}

	/**

	 * 

	 */

	public void removeAllTrack() {

		this.AnimationTrackList.clear();

	}

	/**

	 * @return

	 */

	public List getAnimationTrackList() {

		return AnimationTrackList;

	}

	/**

	 * @param animationTrackList

	 */

	public void setAnimationTrackList(List animationTrackList) {

		AnimationTrackList = animationTrackList;

	}

	/*

	 * IPersistance methods.

	 */

	public String getClassName() {

		// TODO Auto-generated method stub

		return this.getClass().getName();

	}

	/**

	 * @return

	 */

	public XMLEntity getXMLEntity() {

		XMLEntity xml = new XMLEntity();

		xml.putProperty("class_name", this.getClassName());		

		for (int i = 0; i < this.AnimationTrackList.size(); i++) {			

			IAnimationTrack trackElement = (IAnimationTrack) this.AnimationTrackList.get(i);			

			trackElement.getXMLEntity();

		}

		return xml;

	}

	/**

	 * @param xml

	 */

	public void setXMLEntity(XMLEntity xml) {

		if (xml.contains("class_name"))

			className = xml.getStringProperty("class_name");	

		for (int i = 0; i < this.AnimationTrackList.size(); i++) {

			IAnimationTrack trackElement = (IAnimationTrack) this.AnimationTrackList

					.get(i);

			trackElement.setXMLEntity(xml);

		}

	}

	public String toString() {

		String result = "";

		List ATL = this.AnimationTrackList;

		result += "Mostrando lista de tracks:";

		if ((ATL == null) || ATL.isEmpty()) {

			result += "\nLista vacia";

		} else {

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

				Object element = ATL.get(i);

				result += "\n" + element;

			}

		}

		return result;

	}

	public void apply(double Tini, double Tend) {

		List ATL = this.AnimationTrackList;

		System.out.println("Tiempo de inicio: " + Tini + " tiempo final "

				+ Tend);

		if ((ATL != null) && !ATL.isEmpty()) {

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

				IAnimationTrack element = (IAnimationTrack) ATL.get(i);

				if (element.isEnable())

					element.apply(Tini, Tend);

			}

		}

	}

	public AnimationPlayer getAnimationPlayer() {

		return this.animationPlayer;

	}

}

package com.iver.cit.gvsig.animation.dateFilter;

import java.sql.Date;

import java.text.ParseException;

import java.text.SimpleDateFormat;

import java.util.Calendar;

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

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

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

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

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

import com.iver.utiles.IPersistance;

import com.iver.utiles.XMLEntity;

import com.sun.media.jai.opimage.AffineCRIF;

public class DateFilter implements ICustomVectorialFilter, IPersistance {

	public static int FIELDTYPE_DATE = 0;

	public static int FIELDTYPE_DATESTRING = 1;

	public static int BOTH = 2 | 4;

	public static int BEFORE_BEGIN = 2;

	public static int AFTER_END = 4;

	private int fieldType = -1;

	private int filterFieldIndex = -1;

	private Date minDate = null;

	private Date maxDate = null;

	// derived

	private SimpleDateFormat localeDF = null;

	private SimpleDateFormat javaDF = null;

	private Calendar cl = null;

	private int filterMode = BEFORE_BEGIN;

	public void setFieldIndex(int index) {

		filterFieldIndex = index;

	}

	public void setFieldType(int type) {

		fieldType = type;

	}

	public void setMinDate(Date miniDate) {

		minDate = miniDate;

	}

	public void setMaxDate(Date maxiDate) {

		maxDate = maxiDate;

	}

	public int getFieldType() {

		return fieldType;

	}

	public Date getMinDate() {

		return minDate;

	}

	public Date getMaxDate() {

		return maxDate;

	}

	public boolean accepts(IFeature feature) {

		if (filterFieldIndex == -1 || minDate == null || maxDate == null)

			return false;

		Value val = feature.getAttribute(filterFieldIndex);

		if (val instanceof NullValue)

			return false;

		Date dateVal = null;

		if (fieldType == FIELDTYPE_DATE) {

			try {

				dateVal = ((DateValue) val).getValue();

			} catch (RuntimeException e) {

				return false;

			}

		} else if (fieldType == FIELDTYPE_DATESTRING) {

			if (localeDF == null)

				localeDF = new SimpleDateFormat("dd/MM/yyyy");

			if (javaDF == null)

				javaDF = new SimpleDateFormat("yyyy-MM-dd");

			String valStr = val.toString();

			try {

				java.util.Date utDate = localeDF.parse(valStr); // reads locale

				// dd/MM/yyyy

				// strings

				String utDateStr = javaDF.format(utDate); // outputs

				// yyyy-MM-dd

				dateVal = Date.valueOf(utDateStr); // creates Date for

				// comparison

			} catch (ParseException e) {

				return false;

			}

		}

		try {

			String dateValStr = dateVal.toString();

			String minDateStr = minDate.toString();

			String maxDateStr = maxDate.toString();

			if (((this.filterMode & BEFORE_BEGIN) != BEFORE_BEGIN))

				if (dateVal.compareTo(minDate) < 0)

					return false;

			if (((this.filterMode & AFTER_END) != AFTER_END))

				if (dateVal.compareTo(maxDate) > 0)

					return false;

		} catch (Exception e) {

			return false;

		}

		return true;

	}

	public String getClassName() {

		return this.getClass().getName();

	}

	public XMLEntity getXMLEntity() {

		XMLEntity xml = new XMLEntity();

		xml.putProperty("fieldType", fieldType);

		xml.putProperty("fieldIndex", filterFieldIndex);

		xml.putProperty("minDate", minDate.toString());

		xml.putProperty("maxDate", maxDate.toString());

		return xml;

	}

	public void setXMLEntity(XMLEntity xml) {

		if (xml.contains("fieldType"))

			fieldType = xml.getIntProperty("fieldType");

		if (xml.contains("fieldIndex"))

			filterFieldIndex = xml.getIntProperty("fieldIndex");

		if (xml.contains("minDate"))

			minDate = Date.valueOf(xml.getStringProperty("minDate"));

		if (xml.contains("maxDate"))

			maxDate = Date.valueOf(xml.getStringProperty("maxDate"));

	}

	public String toString() {

		String result = "";

		result += minDate.toString() + "\n" + maxDate.toString();

		return result;

	}

	public boolean compareTo(ICustomVectorialFilter filter) {

		DateFilter filterAux = (DateFilter) filter;

		boolean type = this.getFieldType() == filterAux.getFieldType();

		boolean min = this.getMinDate().toString().equals(

				filterAux.getMinDate().toString());

		boolean max = this.getMaxDate().toString().equals(

				filterAux.getMaxDate().toString());

		return (type && min && max);

	}

	public int getFilterMode() {

		return filterMode;

	}

	public void setFilterMode(int filterMode) {

		this.filterMode = filterMode;

	}

}

package com.iver.cit.gvsig.animation.dateFilter;

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

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

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

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

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

import com.iver.utiles.IPersistance;

import com.iver.utiles.XMLEntity;

public class IndexFilter implements ICustomVectorialFilter, IPersistance {

	private int filterFieldIndex=-1;

	private int minIndex = -1;

	private int maxIndex = -1;

	public void setFieldIndex(int index) {

		filterFieldIndex = index;

	}

	// if type is INTEGER, use these instead of setMinDate/setMaxDate

	// internally, the int value is used as year

	public void setMinIndex(int miniIndex) {

		minIndex = miniIndex;

	}

	public void setMaxIndex(int maxiIndex) {

		maxIndex = maxiIndex;

	}

	public boolean accepts(IFeature feature) {

		Value val = feature.getAttribute(filterFieldIndex);

		if (val instanceof NullValue)

			return false;

		if (!(val instanceof NumericValue))

			return false;

		int intVal = ((NumericValue)val).intValue();

		if (intVal < minIndex)

		    return false;

		if (intVal > maxIndex)

		    return false;

		return true;

	}

	public String getClassName() {

		return this.getClass().getName();

	}

	public XMLEntity getXMLEntity() {

		XMLEntity xml = new XMLEntity();

		xml.putProperty("fieldIndex", filterFieldIndex);

		xml.putProperty("minIndex", minIndex);

		xml.putProperty("maxIndex", maxIndex);

		return xml;

	}

	public void setXMLEntity(XMLEntity xml) {

		if (xml.contains("fieldIndex"))

			filterFieldIndex = xml.getIntProperty("fieldIndex");

		if (xml.contains("minIndex"))

			minIndex = xml.getIntProperty("minIndex");

		if (xml.contains("maxIndex"))

			maxIndex = xml.getIntProperty("maxIndex");

	}

	public boolean compareTo(ICustomVectorialFilter filter) {

		IndexFilter filterAux = (IndexFilter) filter;

		return ((this.minIndex == filterAux.minIndex) && (this.maxIndex == filterAux.maxIndex));

	}

}

package com.iver.cit.gvsig.animation.keyframe;

import com.iver.cit.gvsig.animation.IAnimationType;

import com.iver.cit.gvsig.animation.keyframe.interpolator.IInterpolator;

public interface IAnimationTypeKeyFrame extends IAnimationType{

	public IInterpolator getInterpolator();

	public void setInterpolator(IInterpolator interpolator);

}

package com.iver.cit.gvsig.animation.keyframe.interpolator;

import java.util.HashMap;

import java.util.Map;

/*

 * factoria para el registro y la creacion de funciones de animacion de tiempo

 * 

 * 

 */

public class FuntionFactory {

//	private static Map<String, IInterpolatorFuntion> objectsList;

	private static Map objectsList;

	static {

//		objectsList = new HashMap<String, IInterpolatorFuntion>();

		objectsList = new HashMap();

		LinearFuntion lf = new LinearFuntion();

		lf.setName("LinearFuntion");

		lf.setDescription("Funcion para el tiempo lineal");

		FuntionFactory.register(lf);

	}

	public static void register(IInterpolatorFuntion funtion) {

		objectsList.put(funtion.getClassName(), funtion);

	}

	public static IInterpolatorFuntion createObject(String type) {

		IInterpolatorFuntion funtion = null;

		try {

			System.out.println("existe el tipo " + type + "  "

					+ objectsList.containsKey(type));

			if ((objectsList.containsKey(type)) == false)

				return null;

//			funtion = objectsList.get(type).getClass().newInstance();

			funtion = (IInterpolatorFuntion) objectsList.get(type).getClass().newInstance();

		} catch (InstantiationException e) {

			e.printStackTrace();

		} catch (IllegalAccessException e) {

			e.printStackTrace();

		}

		return funtion;

	}

}

package com.iver.cit.gvsig.animation.keyframe.interpolator;

import java.util.List;

import com.iver.cit.gvsig.animation.keyframe.IKeyFrame;

public interface IInterpolator {

	public IKeyFrame interpolate(List kfList, int index, double time);

	public void setAnimatedObject(Object ani);

	public Object getAnimatedObject();

	public void setFuntion(IInterpolatorFuntion funtion);

	public IInterpolatorFuntion getFuntion();

}

package com.iver.cit.gvsig.animation.keyframe.interpolator;

public class LinearFuntion implements IInterpolatorFuntion {

	private String name;

	private String description;

	public String getName() {

		return name;

	}

	public void setName(String name) {

		this.name = name;

	}

	public String getClassName() {

		return this.getClass().getName();

	}

	public String getDescription() {

		return this.description;

	}

	public void setDescription(String name) {

		this.description = name;

	}

	public double interpolate(double T) {

		return T*T;

	}

	public double[] interpolate(double[] T) {

		return T;

	}

	public IInterpolatorFuntion create() {

		return this;

	}

}

package com.iver.cit.gvsig.animation.keyframe.interpolator;

import java.util.List;

public interface IInterpolatorFuntion {

	// Identification of the class

	public void setName(String name);

	public void setDescription(String name);

	public String getName();

	public String getDescription();

	public String getClassName();

	// Interpolation funcion

	public double interpolate(double T);

	public double[] interpolate(double T[]);

	public IInterpolatorFuntion create();

}

package com.iver.cit.gvsig.animation.keyframe;

import java.util.List;

import com.iver.utiles.IPersistence;

import com.iver.utiles.XMLEntity;

public class AnimationFunction implements IPersistence{

	private List AnimationFunctionList;

	private String className;

	//private AnimationFunction animationFunctionItem;

	public List getAnimationFuntionList() {

		return AnimationFunctionList;

	}

	public void setAnimationFuntionList(List animationFuntionList) {

		AnimationFunctionList = animationFuntionList;

	}

	public String toString() {

		String result = "";

		return result;

	}

	public String getClassName() {

		// TODO Auto-generated method stub

		return this.getClass().getName();

	}

	public XMLEntity getXMLEntity() {

		// TODO Auto-generated method stub

		XMLEntity xml = new XMLEntity();

		xml.putProperty("class_name", this.getClassName());		

		for (int i = 0; i < this.AnimationFunctionList.size(); i++) {

			AnimationFunction animationFunctionItem = (AnimationFunction) this.AnimationFunctionList.get(i);			

			return null;//provisional	

		}	

		return null;

	}

	public void setXMLEntity(XMLEntity xml) {

		// TODO Auto-generated method stub

		if (xml.contains("class_name"))

			className = xml.getStringProperty("class_name");	

		for (int i = 0; i < this.AnimationFunctionList.size(); i++) {

			AnimationFunction animationFunctionItem = (AnimationFunction) this.AnimationFunctionList.get(i);			

			return;	 //provisional

		}	

	}

}

package com.iver.cit.gvsig.animation.keyframe;

import java.util.List;

import com.iver.utiles.IPersistence;

public interface IKeyFrame extends IPersistence {

	public void setName(String name);

	public String getName();

	public void setTime(double time);

	public double getTime();

	public void setPropertiesList(List list);

	public List getPropertiesList();

	public void CapturesProperties();

	public void Interpolate(Object p1,Object p2, double time);

	public void Apply(double Tini);

}

package com.iver.cit.gvsig.animation.interval;

import java.util.ArrayList;

import java.util.Iterator;

import java.util.List;

import com.iver.cit.gvsig.animation.IAnimationType;

import com.iver.cit.gvsig.animation.keyframe.IAnimationTypeKeyFrame;

import com.iver.cit.gvsig.animation.keyframe.IKeyFrame;

import com.iver.cit.gvsig.animation.keyframe.interpolator.IInterpolator;

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

import com.iver.cit.gvsig.project.documents.view.gui.View;

import com.iver.utiles.XMLEntity;

public class AnimationKeyFrameInterval implements IAnimationTimeInterval {

	private List KeyFrameList;

	private double initialTime = 0;

	private double endTime = 1;

	private double intervalTime = endTime - initialTime;

	private String className;

	public List getKeyFrameList() {

		return KeyFrameList;

	}

	public void setKeyFrameList(List keyFrameList) {

		KeyFrameList = keyFrameList;

	}

	public double getEndTime() {

		return endTime;

	}

	public double getInitialTime() {

		return initialTime;

	}

	public double getIntervalTime() {

		return (endTime - initialTime);

	}

	public void setEndTime(double time) {

		this.endTime = time;

	}

	public void setInitialTime(double time) {

		this.initialTime = time;

	}

	public void setIntervalTime(double time) {

		this.intervalTime = time;

	}

	public String toString() {

		String result;

		List KFL = this.KeyFrameList;

		if (KFL != null) {

			result = "Mostrando lista de KeyFrames del intervalo Tini:"

					+ this.getInitialTime() + " Tend" + this.getEndTime();

			for (Iterator iter = KFL.iterator(); iter.hasNext();) {

				Object element = (Object) iter.next();

				result += "\n" + element;

			}

		} else {

			result = "Lista de key frame vacia";

		}

		return result;

	}

	public void apply(double tini, double tend, IAnimationType animationType,

			Object animated) {

		IAnimationTypeKeyFrame animationTypeFrame = (IAnimationTypeKeyFrame) animationType;

		IInterpolator interpolator = animationTypeFrame.getInterpolator();

		IKeyFrame previus = null;

		IKeyFrame next = null;

		List KFLInterpolate = new ArrayList();

		List KFL = this.KeyFrameList;

		if (KFL != null) {

			for (Iterator iter = KFL.iterator(); iter.hasNext();) {

				IKeyFrame element = (IKeyFrame) iter.next();

				double KFtime = element.getTime();

				boolean asigned = false;

				if (KFtime <= tini) {

					if (previus != null) {

						if (KFtime > previus.getTime())

							previus = element;

					} else {

						previus = element;

					}

					asigned = true;

				}

				if ((KFtime > tini) && (!asigned)) {

					if (next != null) {

						if (KFtime < previus.getTime())

							next = element;

					} else {

						next = element;

					}

				}

			}

			KFLInterpolate.add(previus);

			KFLInterpolate.add(next);

		}

		IKeyFrame frame = null;

		if (KFLInterpolate != null) {

			// IInterpolator in = (IInterpolator) interpolator;

			frame = interpolator.interpolate(KFLInterpolate, 0, tini);

		}

		if (frame != null)

			animationType.AppliesToObject(frame);

	}

	public XMLEntity getXMLEntity() {

		// TODO Auto-generated method stub

		XMLEntity xml = new XMLEntity();

		xml.putProperty("class_name", this.getClassName());

		xml.putProperty("begin_time", initialTime);

		xml.putProperty("end_time", endTime);

		xml.putProperty("interval_time", intervalTime);

	/*	for (int i = 0; i < this.KeyFrameList.size(); i++) {

			IKeyFrame keyFrameItem = (IKeyFrame) this.KeyFrameList.get(i);			

			keyFrameItem.getXMLEntity();	

		}		*/

		return xml;		

	}

	public void setXMLEntity(XMLEntity xml) {

		// TODO Auto-generated method stub

		if (xml.contains("class_name"))

			className=	xml.getStringProperty("class_name");

		if (xml.contains("begin_time"))

			initialTime = xml.getDoubleProperty("begin_time");

		if (xml.contains("end_time"))

			endTime = xml.getDoubleProperty("end_time");

		if (xml.contains("interval_time"))

			intervalTime = xml.getDoubleProperty("interval_time");

		/*	for (int i = 0; i < this.KeyFrameList.size(); i++) {

			IKeyFrame keyFrameItem = (IKeyFrame) this.KeyFrameList.get(i);

			keyFrameItem.setXMLEntity(xml);

		}*/

	}

	public String getClassName() {

		// TODO Auto-generated method stub

		return this.getClass().getName();

	}

}

package com.iver.cit.gvsig.animation.interval;

import com.iver.cit.gvsig.animation.IAnimationType;

import com.iver.cit.gvsig.animation.keyframe.AnimationFunction;

import com.iver.utiles.XMLEntity;

public class AnimationFunctionInterval implements IAnimationTimeInterval {

	//private List animationFuncionList;

	private AnimationFunction animationFunctionItem;

	private double initialTime = 0;

	private double endTime = 1;

	private double intervalTime = endTime - initialTime;

	private String className;

	public AnimationFunction getAnimationFuncionItem() {

		return animationFunctionItem;

	}

	public void setAnimationFuncionList(AnimationFunction animationFuncionItem) {

		this.animationFunctionItem = animationFuncionItem;

	}

	public double getEndTime() {

		return this.endTime;

	}

	public double getInitialTime() {

		return this.initialTime;

	}

	public double getIntervalTime() {

		return endTime - initialTime;

	}

	public void setEndTime(double time) {

		this.endTime = time;

	}

	public void setInitialTime(double time) {

		this.initialTime = time;

	}

	public void setIntervalTime(double time) {

		this.intervalTime = time;

	}

	public String toString() {

		String result;

		//List AFL = this.animationFuncionList;

		result = "Mostrando lista de funciones de animacion del intervalo Tini:"

				+ this.getInitialTime() + " Tend" + this.getEndTime();

		result+= this.animationFunctionItem;	// ESTO NO SE SI ES ASI

//		for (Iterator iter = AFL.iterator(); iter.hasNext();) {

//			Object element = (Object) iter.next();

//			result += "\n" + element;

//		}

		return result;

	}

	public void apply(double tini, double tend, IAnimationType animationType,

			Object animated) {

		// TODO Auto-generated method stub

	}

	public String getClassName() {

		// TODO Auto-generated method stub

		return this.getClass().getName();

	}

	public XMLEntity getXMLEntity() {

		// TODO Auto-generated method stub

		XMLEntity xml = new XMLEntity();

		xml.putProperty("class_name", this.getClassName());		

		xml.putProperty("begin_time", initialTime);

		xml.putProperty("end_time", endTime);

		xml.putProperty("interval_time", intervalTime);

		//this.animationFunctionItem.getXMLEntity();	

		return xml;

	}

	public void setXMLEntity(XMLEntity xml) {

		// TODO Auto-generated method stub

		if (xml.contains("class_name"))

			className=	xml.getStringProperty("class_name");

		if (xml.contains("begin_time"))

			initialTime = xml.getDoubleProperty("begin_time");

		if (xml.contains("end_time"))

			endTime = xml.getDoubleProperty("end_time");

		if (xml.contains("interval_time"))

			intervalTime = xml.getDoubleProperty("interval_time");

		//this.animationFunctionItem.setXMLEntity(xml);	

	}

}

package com.iver.cit.gvsig.animation.interval;

import com.iver.utiles.IPersistence;

public interface IAnimationTimeInterval extends IAnimationInterval, IPersistence {

}

package com.iver.cit.gvsig.animation.interval;

import com.iver.cit.gvsig.animation.IAnimationType;

public interface IAnimationInterval {

	public double getIntervalTime();

	public void setIntervalTime(double time);

	public double getInitialTime();

	public void setInitialTime(double time);

	public double getEndTime();

	public void setEndTime(double time);

	public void apply(double tini, double tend, IAnimationType animationType,

			Object animated);

}

package com.iver.cit.gvsig.animation.interval;

import java.sql.Date;

import java.text.SimpleDateFormat;

import java.util.Calendar;

import java.util.Locale;

import com.iver.cit.gvsig.animation.IAnimationType;

import com.iver.cit.gvsig.animation.dateFilter.DateFilter;

import com.iver.utiles.DateTime;

import com.iver.utiles.IPersistence;

import com.iver.utiles.XMLEntity;

public class AnimationDatedInterval implements IAnimationInterval, IPersistence {

	private Date beginDateInterval;

	private Date endDateInterval;

	private String beginDateString = new String();

	private String endDateString = new String();

	private String sFormat = new String("Y-m-d");

	private String className;

	static final SimpleDateFormat sdf = new SimpleDateFormat("dd/MM/yyyy");

	public Date getBeginDateInterval() {

		return beginDateInterval;

	}

	public void setBeginDateInterval(Date beginDateInterval) {

		this.beginDateInterval = beginDateInterval;

	}

	public Date getEndDateInterval() {

		return endDateInterval;

	}

	public void setEndDateInterval(Date endDateInterval) {

		this.endDateInterval = endDateInterval;

	}

	public String toString() {

		String result = "Intervalo de " + this.beginDateInterval + " a "

				+ this.endDateInterval;

		return result;

	}

	public double getEndTime() {

		return this.endDateInterval.getTime();

	}

	public double getInitialTime() {

		return this.beginDateInterval.getTime();

	}

	public double getIntervalTime() {

		return (this.endDateInterval.getTime() - this.beginDateInterval

				.getTime());

	}

	public void setEndTime(double time) {

		this.endDateInterval.setTime((long) time);

	}

	public void setInitialTime(double time) {

		this.beginDateInterval.setTime((long) time);

	}

	public void setIntervalTime(double time) {

		// TODO generate method to calculate interval time

	}

	public void apply(double tini, double tend, IAnimationType animationType,

			Object animated) {

		// falta completar la funcion

		// System.out.println("PINTANDO OBJETO");

		// System.out.println("milisegundos del inicio del intervalo "

		// + this.dateToSeconds(this.getBeginDateInterval()));

		int day1 = this.getBeginDateInterval().getDate();

		int day2 = this.getEndDateInterval().getDate();

		int result = linearInterpolate(day1, day2, 0.0, 1.0, tini);

		// System.out.println("fecha resultante " + result);

		int min = (int) (result - 1);

		// System.out.println("fehca minima " + "2000-01-" + min );

		int max = (int) (result + 1);

		// System.out.println("fehca minima " + "2000-01-" + max );

		DateFilter filter = new DateFilter();

		filter.setFieldIndex(0); // Date field in com_aut data sample

		filter.setFieldType(DateFilter.FIELDTYPE_DATESTRING);

//		filter.setMinDate(Date.valueOf("2000-01-1"));

		filter.setMinDate(Date.valueOf("2000-01-" + min));

		filter.setMaxDate(Date.valueOf("2000-01-" + max));

		animationType.AppliesToObject(filter);

	}

	private int linearInterpolate(int minX, int minX2, double timePos,

			double timePos2, double time) {

		// P1 + (P2-P1)*((t-t1)/(t2-t1))

		double result = ((minX + (minX2 - minX)) * time);

		return (int) Math.ceil(result);

	}

	private double dateToSeconds(Date date) {

		Calendar ca = Calendar.getInstance(Locale.US);

		ca.setTime(date);

		return ca.getTimeInMillis();

	}

	/*

	 * IPersistance methods.

	 */

	public String getClassName() {

		// TODO Auto-generated method stub

		return null;

	}

	public XMLEntity getXMLEntity() {

		XMLEntity xml = new XMLEntity();

		xml.putProperty("className", this.getClassName());

		// xml.putProperty("beginDateInterval", beginDateString);

		// xml.putProperty("endDateInterval", endDateString);

		beginDateString = DateTime.dateToString(beginDateInterval, sFormat);

		endDateString = DateTime.dateToString(endDateInterval, sFormat);

		xml.putProperty("begin_date", beginDateString);

		xml.putProperty("end_date", endDateString);

		return xml;

	}

	public void setXMLEntity(XMLEntity xml) {

		if (xml.contains("class_name"))

			className = xml.getStringProperty("class_name");

		if (xml.contains("begin_date"))

			beginDateString = xml.getStringProperty("begin_date");

		if (xml.contains("end_date"))

			endDateString = xml.getStringProperty("end_date");

	}

}

package com.iver.cit.gvsig.animation.traks;

import java.util.List;

import com.iver.cit.gvsig.animation.IAnimationType;

import com.iver.cit.gvsig.animation.interval.IAnimationInterval;

import com.iver.utiles.IPersistence;

public interface IAnimationTrack extends IPersistence{

	// class information

	public String getName();

	public String getDescription();

	public boolean isEnable();

	public void setEnabale(boolean enable);

	public IAnimationType getAnimationType();

	// Interval methods

	public List getIntervalList();

	public void setIntervalList(List intervalList);