source: ether_megapoli/trunk/applets/src/AppletTimeSerie.java @ 175

import com.ether.AxeTypeForFixedPlateform;
import com.ether.Data;
import com.ether.EtherPlotService;
import com.ether.EtherService;
import com.ether.MegapoliPlot;
import com.medias.Context;
import com.medias.database.objects.Parametre;
import com.medias.database.objects.Unite;
import gov.noaa.pmel.sgt.Axis;
import gov.noaa.pmel.sgt.CartesianGraph;
import gov.noaa.pmel.sgt.Graph;
import gov.noaa.pmel.sgt.JPane;
import gov.noaa.pmel.sgt.Layer;
import gov.noaa.pmel.sgt.LineAttribute;
import gov.noaa.pmel.sgt.LineCartesianRenderer;
import gov.noaa.pmel.sgt.LineKey;
import gov.noaa.pmel.sgt.LinearTransform;
import gov.noaa.pmel.sgt.PlainAxis;
import gov.noaa.pmel.sgt.SGLabel;
import gov.noaa.pmel.sgt.StackedLayout;
import gov.noaa.pmel.sgt.TimeAxis;
import gov.noaa.pmel.sgt.demo.TestData;
import gov.noaa.pmel.sgt.dm.SimpleLine;
import gov.noaa.pmel.sgt.swing.JClassTree;
import gov.noaa.pmel.util.Dimension2D;
import gov.noaa.pmel.util.GeoDate;
import gov.noaa.pmel.util.IllegalTimeValue;
import gov.noaa.pmel.util.Point2D;
import gov.noaa.pmel.util.Range2D;
import gov.noaa.pmel.util.SoTPoint;
import gov.noaa.pmel.util.SoTRange;
import gov.noaa.pmel.util.TimeRange;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import javax.swing.*;
import javax.swing.border.EtchedBorder;
import java.applet.Applet;
import java.awt.*;
import java.awt.im.InputContext;
import java.util.Calendar;
import java.util.Date;
import java.util.Enumeration;
import java.util.Locale;

public class AppletTimeSerie
        extends JApplet
{
    public void init()
    {
        final String appletContext = "applet-context.xml";
        final String hibernateContext = "hibernate.cfg.xml";
        final String[] contextPaths = new String[]{appletContext, hibernateContext};

        final ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext( contextPaths );
        _etherService = (EtherService) context.getBean( "etherService", EtherService.class );
        _etherPlotService = (EtherPlotService) context.getBean( "etherPlotService", EtherPlotService.class );
        _locale = InputContext.getInstance().getLocale();
    }

    public void start()
    {
        // Init megapoliPlot with parameters
        final MegapoliPlot megapoliPlot = initMegapoliPlot();

        // Create graph
        setLayout( new BorderLayout( 0, 0 ) );
        setBackground( Color.WHITE );
        setSize( 800, 800 );

        // Top Pane
        final JPane jPaneTop = _etherPlotService.createTopPane( megapoliPlot );
        add( jPaneTop, BorderLayout.NORTH );

        // Bottom Pane
        final Integer valuesNumber = megapoliPlot.getValuesNumber();

        // Bottom Pane
        final JPane jPaneBottom = _etherPlotService.createBottomPane( valuesNumber, _locale );
        add( jPaneBottom, BorderLayout.PAGE_END );

        makeControlPanel();
        add( controlPanel, BorderLayout.SOUTH );

//        makeGraph( parametre.getParametreNom() );
        makeGraph();
        add( mainPane_, BorderLayout.CENTER );
    }

    void makeGraph()
    {
        /*
        * This example explicitly creates the JPane, Layers, Axes, and SGLabels.
        */
        /*
        * Create JPane, place in the center of the frame
        * and set the layout to use the StackedLayout.  StackedLayout is
        * a custom layout manager designed to place Components directly
        * over one another.
        */
        mainPane_ = new JPane( "Layout Demo", new Dimension( 426, 400 ) );
        mainPane_.setLayout( new StackedLayout() );
        /*
        * Create the two random time series using the TestData class and
        * the SimpleLine classes from sgt.dm
        */
        SimpleLine line;
        SimpleLine line2;
        GeoDate start = null;
        GeoDate stop = null;
        TimeRange tr;
        TestData td;
        try
        {
            start = new GeoDate( "1992-11-01", "yyyy-MM-dd" );
            stop = new GeoDate( "1993-02-20", "yyyy-MM-dd" );
        }
        catch( IllegalTimeValue e )
        {
        }
        tr = new TimeRange( start, stop );
        td = new TestData( TestData.TIME_SERIES, tr, 1.0f,
                TestData.RANDOM, 1.2f, 0.0f, 20.0f );
        line = (SimpleLine) td.getSGTData();
        //
        try
        {
            start = new GeoDate( "1992-11-01", "yyyy-MM-dd" );
            stop = new GeoDate( "1993-02-20", "yyyy-MM-dd" );
        }
        catch( IllegalTimeValue e )
        {
        }
        tr = new TimeRange( start, stop );
        td = new TestData( TestData.TIME_SERIES, tr, 1.0f,
                TestData.RANDOM, 1.2f, 0.5f, 30.0f );
        line2 = (SimpleLine) td.getSGTData();
        /*
        * Get the axis ranges from SGTLine
        */
        SoTRange ynRange, yRange;
        SoTRange tnRange;
        String yLabel;
        yRange = line.getYRange();
        yRange.add( line2.getYRange() );
        tnRange = line.getXRange();
        /*
        * compute the range for the y and time axes
        * and get the y axis label from line's metadata
        */
        ynRange = Graph.computeRange( yRange, 6 );
        yLabel = line.getYMetaData().getName();
        /*
        * LayoutDemo will have two layers.
        * One layer for each line to be drawn.
        * The first layer will contain the axes and labels
        * and the first set of data. The second layer will
        * contain the second set of data.
        */
        /*
        * xsize, ysize are the width and height in physical units
        * of the Layer graphics region.
        *
        * xstart, xend are the start and end points for the TimeAxis
        * ystart, yend are the start and end points for the Y axis
        */
        double xsize = 4.0;
        double xstart = 0.6;
        double xend = 3.25;
        double ysize = 3.0;
        double ystart = 0.6;
        double yend = 2.50;

        Layer layer, layer2;
        SGLabel label, title, ytitle;
        CartesianGraph graph, graph2;
        LinearTransform xt, yt;
        PlainAxis yleft;
        TimeAxis xbot;
        LineKey lkey;
        GeoDate stime;
        /*
        * create the first layer
        */
        layer = new Layer( "First Layer", new Dimension2D( xsize, ysize ) );
        /*
        * create a time stamp label for the plot
        * position the label at the lower left corner
        * and add to the first layer
        * (NOTE: the time will be displayed for the GMT time zone)
        */
        stime = new GeoDate();
        label = new SGLabel( "Date Stamp", stime.toString(),
                new Point2D.Double( 0.05, 0.05 ) );
        label.setAlign( SGLabel.BOTTOM, SGLabel.LEFT );
        label.setColor( Color.magenta );
        label.setHeightP( 0.15 );
        label.setFont( new Font( "Dialog", Font.PLAIN, 10 ) );
        layer.addChild( label );
        /*
        * create a title for the plot
        * position the label centered on the graph
        * and add to the first layer
        */
        title = new SGLabel( "Title", "Layout Demo zzzzqsdqdqs",
                new Point2D.Double( xsize / 2.0, ysize ) );
        title.setAlign( SGLabel.TOP, SGLabel.CENTER );
        title.setHeightP( 0.20 );
        title.setFont( new Font( "Helvetica", Font.BOLD, 14 ) );
        layer.addChild( title );
        /*
        * create a LineKey
        * the LineKey will be a legend for the two lines created
        * position the key in the upper right corner
        * and add to the first layer
        */
        lkey = new LineKey();
        lkey.setId( "Legend" );
        lkey.setLocationP( new Point2D.Double( xsize - 0.01, ysize ) );
        lkey.setVAlign( LineKey.TOP );
        lkey.setHAlign( LineKey.RIGHT );
        layer.addChild( lkey );
        /*
        * add the first layer to the Pane
        */
        mainPane_.add( layer );
        /*
        * create first CartesianGraph and transforms
        */
        graph = new CartesianGraph( "First Graph" );
        xt = new LinearTransform( new Range2D( xstart, xend ), tnRange );
        graph.setXTransform( xt );
        yt = new LinearTransform( new Range2D( ystart, yend ), ynRange );
        graph.setYTransform( yt );
        /*
        * Create the time axis, set its range in user units
        * and its origin. Add the axis to the first graph.
        */
        SoTPoint point = new SoTPoint( ynRange.getStart(), tnRange.getStart() );
        xbot = new TimeAxis( "Bottom Axis", TimeAxis.MONTH_YEAR );
        xbot.setRangeU( tnRange );
        xbot.setLocationU( point );
        Font xbfont = new Font( "Helvetica", Font.ITALIC, 14 );
        xbot.setLabelFont( xbfont );
        xbot.setMinorLabelInterval( 1 );
        graph.addXAxis( xbot );
        /*
        * Create the vertical axis, set its range in user units
        * and its origin.  Create the axis title and add the
        * axis to the first graph.
        */
        yleft = new PlainAxis( "Left Axis" );
        yleft.setRangeU( ynRange );
        yleft.setLocationU( point );
        yleft.setLabelFont( xbfont );
        ytitle = new SGLabel( "Y-Axis Title", yLabel,
                new Point2D.Double( 0.0, 0.0 ) );
        Font ytfont = new Font( "Helvetica", Font.PLAIN, 14 );
        ytitle.setFont( ytfont );
        ytitle.setHeightP( 0.2 );
        yleft.setTitle( ytitle );
        graph.addYAxis( yleft );
        /*
        * Add the first graph to the first layer.
        */
        layer.setGraph( graph );
        /*
        * Create a LineAttribute for the display of the first
        * line. Associate the attribute and the line with the
        * first graph.  Add the line to the LineKey.
        */
        LineAttribute attr;

        attr = new LineAttribute( LineAttribute.MARK, 20, Color.red );
        attr.setMarkHeightP( 0.1 );
        graph.setData( line, attr );
        lkey.addLineGraph( (LineCartesianRenderer) graph.getRenderer(),
                new SGLabel( "1st line", "Red Data",
                        new Point2D.Double( 0.0, 0.0 ) ) );
        /*
        * Create the second layer and add it the the Pane.
        * Create the second graph and associate it with the
        * second layer.
        */
        layer2 = new Layer( "Second Layer", new Dimension2D( xsize, ysize ) );
        mainPane_.add( layer2 );
        graph2 = new CartesianGraph( "Second Graph", xt, yt );
        layer2.setGraph( graph2 );
        /*
        * Create a LineAttribute for the display of the second
        * line. Associate the attribute and the line with the
        * second graph.  Add the line to the LineKey.
        */
        LineAttribute attr2;
        attr2 = new LineAttribute( LineAttribute.MARK, 2, Color.blue );
        attr2.setMarkHeightP( 0.1 );
        graph2.setData( line2, attr2 );
        lkey.addLineGraph( (LineCartesianRenderer) graph2.getRenderer(),
                new SGLabel( "2nd line", "Blue Data",
                        new Point2D.Double( 0.0, 0.0 ) ) );
    }

    /**
     * Change the Pane layout to StackedLayout.
     *
     * @param event
     */

    void stacked_itemStateChanged( java.awt.event.ItemEvent event )
    {
        /*
        * Get the component list for mainPane_ and change
        * the layout to StackedLayout.
        */
        Component[] comps = mainPane_.getComponents();
        mainPane_.setBatch( true );
        mainPane_.setLayout( new StackedLayout() );
        /*
        * Remove any axes that have been associated with
        * the second graph.  With the layers overlayed it
        * is not necessary to have duplicate axes.
        */
        Graph gr2 = ( (Layer) comps[1] ).getGraph();
        ( (CartesianGraph) gr2 ).removeAllXAxes();
        ( (CartesianGraph) gr2 ).removeAllYAxes();
        /*
        * Tell the Applet that the mainPane_ needs to
        * be layed out and re-draw the mainPane_.
        */
        if( isApplet_ )
        {
            validate();
        }
        else
        {
            frame.validate();
        }
        mainPane_.setBatch( false );
        if( tree_ != null )
        {
            if( tree_.isVisible() )
            {
                tree_.setJPane( mainPane_ );
                tree_.expandTree();
            }
        }
    }

    /**
     * Change the Pane layout to GridLayout.
     *
     * @param event
     */

    void grid_itemStateChanged( java.awt.event.ItemEvent event )
    {
        /*
        * Get the component list for mainPane_ and change
        * the layout to GridLayout.
        */
        Component[] comps = mainPane_.getComponents();
        mainPane_.setBatch( true );
        mainPane_.setLayout( new GridLayout( 2, 0 ) );
        /*
        * Get the first and second graphs from the first
        * and second layers, respectively.
        */
        Graph gr = ( (Layer) comps[0] ).getGraph();
        Graph gr2 = ( (Layer) comps[1] ).getGraph();
        /*
        * Create copies of all X-Axes associated with the first
        * graph for the second graph. If the axes are not copied then
        * the second graph will have the second line plotted, but without
        * any axes.
        */
        for( Enumeration xa = ( (CartesianGraph) gr ).xAxisElements(); xa.hasMoreElements(); )
        {
            ( (CartesianGraph) gr2 ).addXAxis( ( (Axis) xa.nextElement() ).copy() );
        }
        /*
        * Create copies of all Y-Axes associated with the first
        * graph for the second graph.
        */
        for( Enumeration ya = ( (CartesianGraph) gr ).yAxisElements(); ya.hasMoreElements(); )
        {
            ( (CartesianGraph) gr2 ).addYAxis( ( (Axis) ya.nextElement() ).copy() );
        }
        /*
        * Tell the Applet that the mainPane_ needs to
        * be layed out and re-draw the mainPane_.
        */
        if( isApplet_ )
        {
            validate();
        }
        else
        {
            frame.validate();
        }
        //    mainPane_.draw();
        mainPane_.setBatch( false );
        if( tree_ != null )
        {
            if( tree_.isVisible() )
            {
                tree_.setJPane( mainPane_ );
                tree_.expandTree();
            }
        }
    }

    void showTree_ActionPerformed( java.awt.event.ActionEvent event )
    {
        /*
        * Create the ClassTree dialog to display the classes used
        * in the mainPane_ and allow editing.
        */
        if( tree_ == null )
        {
            tree_ = new JClassTree( "Classes for LayoutDemo" );
        }
        tree_.setJPane( mainPane_ );
        tree_.show();
    }

    private MegapoliPlot initMegapoliPlot()
    {
        final Integer plateformId = 14;
        final Integer parameterId = 90;
        final String title = "Applet de merd....";
        final String axeType = AxeTypeForFixedPlateform.TIME_LINE.toString();

//        final Integer plateformId = Integer.valueOf( getParameter( "plateformId" ) );
//        final Integer parameterId = Integer.valueOf( getParameter( "parameterId" ) );
//        final String title = getParameter( "title" );
//        final String axeType = getParameter( "axeType" );
//
//        final String dateBegin = getParameter( "dateBegin" );
//        final String dateEnd = getParameter( "dateEnd" );
        final String dateBegin = null;
        final String dateEnd = null;
        final Calendar calendar = Calendar.getInstance();
        Date formatedDateBegin = null;
        Date formatedDateEnd = null;
        if( null != dateBegin && null != dateEnd && !"false".equals( dateBegin ) && !"false".equals( dateEnd ) )
            try
            {
                calendar.setTimeInMillis( Long.valueOf( dateBegin ) );
                formatedDateBegin = calendar.getTime();
                calendar.setTimeInMillis( Long.valueOf( dateEnd ) );
                formatedDateEnd = calendar.getTime();
            }
            catch( Exception e )
            {
                // TODO : gérer fenêtre d'erreur
//                createErrorPane( response, request, WebException.WebCode.INVALID_DATE.toString(), e );
//                flagException = true;
//                throw new ServletException( WebException.WebCode.INVALID_DATE.toString(), e );
            }

        // Parameter
//            final Parametre parametre = _etherService.getParameterById( parameterId );
        final Parametre parametre = new Parametre();
        parametre.setParametreNom( "Ozone" );
        final Unite unit = new Unite();
        unit.setUniteCode( "ppb" );
        parametre.setUnite( unit );
        if( null == parametre )
        {
            // TODO : gérer fenêtre d'erreur
//            createErrorPane( response, request, WebException.WebCode.PARAMETER_IS_NULL.toString(), null );
//            flagException = true;
//            throw new ServletException( WebException.WebCode.PARAMETER_IS_NULL.toString(), null );
        }

        // Create plot
        final MegapoliPlot megapoliPlot = new MegapoliPlot();
        megapoliPlot.setTitle( title );
        megapoliPlot.setAxeType( axeType );
        megapoliPlot.setParameterName( parametre.getParametreNom() );
        if( null != parametre.getUnite() && null != parametre.getUnite().getUniteCode() )
            megapoliPlot.setParameterUnitCode( parametre.getUnite().getUniteCode() );


        if( AxeTypeForFixedPlateform.TIME_LINE.name().equals( axeType ) || AxeTypeForFixedPlateform.TIME_POINTS.name().equals( axeType ) )
        {
//            final Data valuesLists = _etherService.getListsByPlateformByParameterByPeriodForTimeSerie( plateformId, parameterId, formatedDateBegin, formatedDateEnd );
            final double[] values = new double[50];
            final Date[] dates = new Date[50];

            for( int i = 0; i < 50; i++ )
            {
                values[i] = (double) i;
                dates[i] = new Date();
            }
            final Data valuesLists = new Data( values, dates );

            megapoliPlot.setData( valuesLists );

            megapoliPlot.setTimeSerie( true );
            megapoliPlot.setLegendToHide( true );
            megapoliPlot.setValuesNumber( ( (double[]) valuesLists.getFirstArray() ).length );
        }
        else
        {
//            final Data valuesLists = _etherService.getListsByPlateformByParameterByPeriodFor2D( plateformId, parameterId, formatedDateBegin, formatedDateEnd );
            final double[] latitudeValues = new double[50];
            final double[] longitudeValues = new double[50];
            final double[] parameterValues = new double[50];

            for( int i = 0; i < 50; i++ )
            {
                parameterValues[i] = Math.random() * i;
                latitudeValues[i] = Math.random() * i;
                longitudeValues[i] = Math.random() * i;
            }
            final Data valuesLists = new Data( parameterValues, latitudeValues, longitudeValues );

            megapoliPlot.setData( valuesLists );
//                final double[] latitudeArray = {2.1, 2.2, 2.3};
//                final double[] longitudeValues = {112.1, 12.2, 22.3};

            megapoliPlot.setTimeSerie( false );
            megapoliPlot.setLegendToHide( false );
            megapoliPlot.setValuesNumber( ( (double[]) valuesLists.getFirstArray() ).length );
        }
        return megapoliPlot;
    }
    public void makeControlPanel()
    {
        final JPanel controlPanel = new JPanel();
        final ButtonGroup gridtype = new ButtonGroup();
        final JCheckBox stacked = new JCheckBox();
        final JCheckBox grid = new JCheckBox();

        controlPanel.setLayout( new GridBagLayout() );
//    controlPanel.setBackground(new java.awt.Color(200,200,200));
        controlPanel.setBounds( 0, 679, 426, 33 );
        controlPanel.setBorder( new EtchedBorder() );
        gridtype.add( stacked );
        stacked.setSelected( true );
        stacked.setText( "Overlayed" );

        GridBagConstraints gbc = new GridBagConstraints();
        gbc.gridx = 0;
        gbc.gridy = 0;
        gbc.gridwidth = 1;
        gbc.gridheight = 1;
        gbc.weightx = 0.0;
        gbc.weighty = 1.0;
        gbc.anchor = GridBagConstraints.EAST;
        gbc.fill = GridBagConstraints.BOTH;
        gbc.insets = new Insets( 5, 15, 5, 5 );
        gbc.ipadx = 0;
        gbc.ipady = 0;
        controlPanel.add( stacked, gbc );
        stacked.setBounds( 15, 5, 84, 23 );
        gridtype.add( grid );
        grid.setText( "Grid" );

        gbc.gridx = 1;
        gbc.gridy = 0;
        gbc.gridwidth = 1;
        gbc.gridheight = 1;
        gbc.weightx = 0.5;
        gbc.weighty = 1.0;
        gbc.anchor = GridBagConstraints.WEST;
        gbc.fill = GridBagConstraints.VERTICAL;
        gbc.insets = new Insets( 5, 5, 5, 0 );
        gbc.ipadx = 0;
        gbc.ipady = 0;
        controlPanel.add( grid, gbc );
        grid.setBounds( 109, 5, 53, 23 );
        showTree.setText( "Show Class Tree" );

        gbc.gridx = 2;
        gbc.gridy = 0;
        gbc.gridwidth = 1;
        gbc.gridheight = 1;
        gbc.weightx = 1.0;
        gbc.weighty = 1.0;
        gbc.anchor = GridBagConstraints.EAST;
        gbc.fill = GridBagConstraints.VERTICAL;
        gbc.insets = new Insets( 5, 5, 5, 15 );
        gbc.ipadx = 0;
        gbc.ipady = 0;
        controlPanel.add( showTree, gbc );
        showTree.setBackground( Color.yellow.brighter() );
        showTree.setBounds( 302, 5, 109, 23 );

        SymItem lSymItem = new SymItem();
        stacked.addItemListener( lSymItem );
        grid.addItemListener( lSymItem );
        SymAction lSymAction = new SymAction();
        showTree.addActionListener( lSymAction );
    }


    class SymItem
            implements java.awt.event.ItemListener
    {
        public void itemStateChanged( java.awt.event.ItemEvent event )
        {
            Object object = event.getSource();
            if( object == stacked )
                stacked_itemStateChanged( event );
            else if( object == grid )
                grid_itemStateChanged( event );
        }
    }

    class SymAction
            implements java.awt.event.ActionListener
    {
        public void actionPerformed( java.awt.event.ActionEvent event )
        {
            Object object = event.getSource();
            if( object == showTree )
                showTree_ActionPerformed( event );
        }
    }

    JPane mainPane_;
    JClassTree tree_ = null;
    boolean isApplet_ = true;
    JFrame frame = null;

    JPanel controlPanel = new JPanel();
    JCheckBox stacked = new JCheckBox();
    ButtonGroup gridtype = new ButtonGroup();
    JCheckBox grid = new JCheckBox();
    JButton showTree = new JButton();

    private EtherService _etherService;
    private EtherPlotService _etherPlotService;
    private Locale _locale;
}