Application: gvSIG desktop

package com.iver.ai2.animationgui.gui;

//import com.iver.ai2.gvsig3d.gui.AnimationContol3D;

import java.util.ArrayList;

import java.util.List;

import com.iver.ai2.gvsig3d.camera.ProjectCamera;

import com.iver.ai2.gvsig3d.gui.View3D;

import com.iver.andami.PluginServices;

import com.iver.andami.plugins.Extension;

import com.iver.andami.plugins.IExtension;

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

import com.iver.cit.gvsig.ProjectExtension;

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

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

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

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

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

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

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

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

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

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

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

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

import com.iver.cit.gvsig.fmap.MapControl;

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

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

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

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

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

import com.iver.utiles.extensionPoints.ExtensionPoint;

import com.iver.utiles.extensionPoints.ExtensionPoints;

import com.iver.utiles.extensionPoints.ExtensionPointsSingleton;

import es.upv.ai2.libjosg.viewer.Camera;

/**

 * @author

 * @since 1.1

 * 

 * Menu of animation toolbar's options.

 */

public class MenuAnimation3D extends Extension {

        private Project project;

        private int cont = 0;

        private AnimationContainer ac;

        private AnimationTimeTrack animationTimeTrack = null;

        private AnimationKeyFrameInterval AKFinterval;

        public void execute(String actionCommand) {

                // TODO Auto-generated method stub

                // if the button pressed is animation control the animation panel is

                // created.

                if (actionCommand.equals("CONTROLES")) {

                        System.out.println("pulsado boton controles !!!");

                        // ProjectExtent[] ex = project.getExtents();

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

                        // ProjectExtent projectExtent = ex[i];

                        // System.out.println(projectExtent);

                        // }

                        AnimationContainer ac = project.getAnimationContainer();

                        AnimationPlayer ap = ac.getAnimationPlayer();

                        ap.setAnimationContainer(ac);

                        AnimationContol3D fp = new AnimationContol3D(ap);

                        PluginServices.getMDIManager().addWindow((IWindow) fp);

                } else if (actionCommand.equals("ENCUADRECAP")) {// button capture

                        // snapshot pressed.

                        System.out.println("pulsado boton de capturar encuadres!!!");

                        String name = "Animation-" + cont++;

                        List keyFrameList = null;

                        // Getting the active windows

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

                        // crear track sino existe

                        ac = this.getAnimationContainer();

                        animationTimeTrack = this.getAnimationTimeTrack(

                                        "encuadrator_track", ac);

                        // generar el intervalo

                        if (AKFinterval == null) {

                                AKFinterval = (AnimationKeyFrameInterval) animationTimeTrack

                                                .createKeyFrameInterval();

                                AKFinterval.setInitialTime(0.0);

                                AKFinterval.setEndTime(1.0);

                        }

                        // If the w is instance of View

                        if (w instanceof View) {

                                BaseView view = (BaseView) w;

                                MapControl mapa = view.getMapControl();

                                ProjectExtent extent = ProjectFactory.createExtent();

                                extent.setDescription(name);

                                extent.setExtent(mapa.getViewPort().getExtent());

                                project.addExtent(extent);

                                // generar lista de keyframes

                                ProjectExtent[] extentsList = project.getExtents();

                                keyFrameList = new ArrayList();

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

                                        ProjectExtent projectExtent = extentsList[i];

                                        KeyFrame2D kf2D = new KeyFrame2D();

                                        double fin = AKFinterval.getEndTime();

                                        double ini = AKFinterval.getInitialTime();

                                        double size = extentsList.length;

                                        // Calcular el tiempo de insercion

                                        double tiempo = 0.0;

                                        if (i != 0)

                                                tiempo = i * ((fin - ini) / (size - 1.0));

                                        // (AKFinterval.getEndTime() - AKFinterval

                                        // .getInitialTime()) / extentsList.length);

                                        kf2D.setTime(tiempo);

                                        // hacer funcion de insercion o adapter

                                        // kf2D.CapturesProperties(projectExtent);

                                        kf2D.setAnimatedObject(projectExtent);

                                        keyFrameList.add(kf2D);

                                }

                        }

                        if (w instanceof View3D) {

                                View3D view = (View3D) w;

                                Camera ca = view.getCamera();

                                ProjectCamera camera = new ProjectCamera();

                                camera.setDescription(name);

                                camera.setCamera(ca);

                                Object[] l = project.getCameras();

                                project.addCamera(camera);

                                // generar lista de keyframes

                                Object[] extentsList = project.getCameras();

                                keyFrameList = new ArrayList();

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

                                        ProjectCamera projectCamera = (ProjectCamera) extentsList[i];

                                        KeyFrame3DFlat kf2D = new KeyFrame3DFlat();

                                        double fin = AKFinterval.getEndTime();

                                        double ini = AKFinterval.getInitialTime();

                                        double size = extentsList.length;

                                        // Calcular el tiempo de insercion

                                        double tiempo = 0.0;

                                        if (i != 0)

                                                tiempo = i * ((fin - ini) / (size - 1.0));

                                        // (AKFinterval.getEndTime() - AKFinterval

                                        // .getInitialTime()) / extentsList.length);

                                        kf2D.setTime(tiempo);

                                        // hacer funcion de insercion o adapter

                                        // kf2D.CapturesProperties(projectExtent);

                                        kf2D.setAnimatedObject(projectCamera);

                                        keyFrameList.add(kf2D);

                                }

                        }

                        AKFinterval.setKeyFrameList(keyFrameList);

                        System.out.println(ac);

                } else if (actionCommand.equals("CAPACAP")) {// button capture layer

                        // pressed.

                        System.out.println("pulsado boton de capturar capa!!!");

                }

        }

        private AnimationTimeTrack getAnimationTimeTrack(String name,

                        AnimationContainer ac) {

                AnimationTimeTrack at = this.animationTimeTrack;

                IAnimationTrack aa = ac.findTrack(name);

                if (aa == null) {

                        ExtensionPoints extensionPoints = ExtensionPointsSingleton

                                        .getInstance();

                        ExtensionPoint extPoint = ((ExtensionPoint) extensionPoints

                                        .get("Animation"));

                        com.iver.andami.ui.mdiManager.IWindow f = PluginServices

                        .getMDIManager().getActiveWindow();

                        if (f instanceof View) {

                        AnimationLayer2D animationLayer2D = null;

                        try {

                                animationLayer2D = (AnimationLayer2D) extPoint

                                                .create("AnimationLayer2D");

                        } catch (InstantiationException e) {

                                // TODO Auto-generated catch block

                                e.printStackTrace();

                        } catch (IllegalAccessException e) {

                                // TODO Auto-generated catch block

                                e.printStackTrace();

                        }

                        at = (AnimationTimeTrack) ac.CreateTimeTrack(animationLayer2D);

                        at.setName(name);

                                View view = (View) f;

                                at.setAnimatedObject(view);

                                Interpolator2D inter2D = new Interpolator2D();

                                inter2D.setAnimatedObject(view);

                                animationLayer2D.setInterpolator(inter2D);

                                at.setAnimationType(animationLayer2D);

                                animationLayer2D.setAnimatedObject(view);

                        }

                        if (f instanceof View3D) {

                                AnimationLayer3DFlat animationLayer3DFlat = null;

                                try {

                                        animationLayer3DFlat = (AnimationLayer3DFlat) extPoint

                                                        .create("AnimationLayer3DFlat");

                                } catch (InstantiationException e) {

                                        // TODO Auto-generated catch block

                                        e.printStackTrace();

                                } catch (IllegalAccessException e) {

                                        e.printStackTrace();

                                }

                                at = (AnimationTimeTrack) ac.CreateTimeTrack(animationLayer3DFlat);

                                at.setName(name);

                                BaseView view = (BaseView) f;

                                at.setAnimatedObject(view);

                                Interpolator3DFlat inter3DFlat = new Interpolator3DFlat();

                                inter3DFlat.setAnimatedObject(view);

                                animationLayer3DFlat.setInterpolator(inter3DFlat);

                                at.setAnimationType(animationLayer3DFlat);

                                animationLayer3DFlat.setAnimatedObject(view);

                        }

                }

                return at;

        }

        private AnimationContainer getAnimationContainer() {

                return project.getAnimationContainer();

        }

        public void initialize() {

                // Getting the project using pluggin services

                IExtension extension = PluginServices

                                .getExtension(com.iver.cit.gvsig.ProjectExtension.class);

                ProjectExtension pe = (ProjectExtension) extension;

                project = pe.getProject();

                // Register types

                AnimationTypeFactoryLayer2D.register();

//                AnimationTypeFactoryLayer3DFlat.register();

        }

        public boolean isEnabled() {

                // TODO Auto-generated method stub

                return true;

        }

        public boolean isVisible() {

                com.iver.andami.ui.mdiManager.IWindow f = PluginServices

                                .getMDIManager().getActiveWindow();

                if (f == null) {

                        return false;

                }

                // Only isVisible = true, where the view3D have layers

                if (f instanceof BaseView) {

                        return true;

                }

                return false;

        }

}