5
Building Interactive and Dynamic Charts

5.1.2.1 Building Interactive Axis Charts

Chart Builder provides the AxisChartInteractive class for building interactive axis charts. The AxisChartInteractive class contains the following event methods for determining when the mouse enters or exits series elements:

• The getSeriesElementEntered( ) method detects when the pointer enters a series element.

• The getSeriesElementExited( ) method detects when the pointer exits the series element.

• The getSeriesIndex( ) method determines the element in the series in which the event occurred.

• The getSeriesIndexDesc( ) method determines the series and the element in the series in which the event occurred. This method is for use with charts that contain more than one series.

When the series element events occur, your application can take the following actions:

• Take any valid Java action for a component.

• Display an annotation for an element, such as a bar in a bar chart, using the setSeriesAnnotation( ) method.

• Remove an annotation from an element, using the setSeriesAnnotationRemove( ) method.

• Highlight an element, using the setSeriesHighlight( ) method. You highlight an element by specifying a color.

• Remove the highlighting of an element, using the setSeriesUnHighlight( ) method.

To build an interactive chart, you take the following basic steps:

1. Implement the java.awt.event.MouseMotionListener or the java.awt.event.MouseListener interface, or both.

2. Use the AxisChartInteractive class to create the chart object.

3. Register the chart object using the addMouseListener( ) or addMouseMotionListener( ) methods, or both.

4. When particular mouse events occur, take an action. To take an action when a mouse event occurs in a series element, take the following steps:

   1. Use the Chart Builder series element event methods, such as getSeriesElementEntered( ) or getSeriesElementExited( ), to detect when an event occurs in an element. The following example uses the getSeriesElementEntered( ) method in an if statement:

      if (MyAxisCh.getSeriesElementEntered(x,y)) { ...
      
      

   2. Determine the element in which the event occurred by getting the index of the x, y coordinate at the screen location using the getSeriesIndex( ) or getSeriesIndexDesc( ) method. If the coordinate is contained in a series element (for example, in one of the bars in a bar chart), Chart Builder returns the index. The following example returns the index to the variable ind:

      int index = MyAxisCh.getSeriesIndex(x,y);
      
      

      If the chart contains more than one series, use the getSeriesIndexDesc( ) method. This method returns both the index and the series name. The following example shows how to use this method:

      // Allocate a SeriesDesc descriptor object.
      
      SeriesDesc SD = MYAxisCh.getSeriesIndexDesc(x,y);
      
      int index = SD.getSeriesIndex();
      
      String seriesname = SD.getSeriesName();
      
      

   3. Use one of the Chart Builder series element action methods, such as the setSeriesHighlight( ) method, to take the action, passing the series name and index to the method. The following example calls the setSeriesHighlight( ) method to change the color of a bar:

      MyAxisCh.setSeriesHighlight("uspopulation", index, Color.orange);
      
      

The following example shows excerpts of a Java applet that creates an interactive chart. When the pointer enters a bar, the bar is highlighted; when the mouse is pressed over a bar, an annotation pops ups and the color of the bar changes. The applet also removes the highlighting, annotation, and color change when the pointer exits the bar.

import java.applet.*;

import java.lang.*;

import javax.swing.*;


import java.awt.*;

import java.awt.event.*;


import oracle.charts.*;

import oracle.charts.axischart.*;

import oracle.charts.types.*;

import oracle.charts.io.*;


import java.awt.event.MouseMotionListener;

import java.awt.event.MouseListener;

import java.awt.event.MouseEvent;


public class applet1_inter extends JApplet implements MouseListener,     [1]

                                   MouseMotionListener {

 .

 .

 .

// Initialize the applet.                                         


    // Create an interactive chart.

    AxisChartInteractive MyAxisCh = new AxisChartInteractive();          [2]


public void init() {                                                     [3]


    this.enableEvents(AWTEvent.COMPONENT_EVENT_MASK); 


    addMouseListener(this);

    addMouseMotionListener(this);

 .

 .

 .

    bufferSize = this.getSize();


    Display_height = bufferSize.height;

    Display_width = bufferSize.width;


    MyAxisCh = createAxisChart(Display_width,  Display_height);


    if (MyAxisCh != null) {

          

        this.getContentPane().add(MyAxisCh);

        MyAxisCh.addMouseListener(this);                                 [4]

        MyAxisCh.addMouseMotionListener(this);


    }


    addMouseMotionListener(this);

      

}

 .

 .

 .

    

// Mouse Events. The first four are not used in this applet.             [5]


public void mouseDragged(MouseEvent e) {

    }

public void mouseReleased(MouseEvent e) {

    }

public void mouseClicked(MouseEvent e) {

    }

public void mouseEntered(MouseEvent e) {

    }


   

// Handle events associated with the mouse exiting the chart component. 

// On chart exit, if the previous mouse location was on a bar, 

// remove the highlighting and the annotation from the bar.

//

public void mouseExited(MouseEvent e) {                                  [6]

  int x = e.getX();

  int y = e.getY();


  try {

     if (MyAxisCh.getSeriesElementExited(x,y)) {                         [7]

                

         MyAxisCh.setSeriesUnHighlight();

         MyAxisCh.setSeriesAnnotationRemove();


         this.paint(this.getGraphics());

       }

            

      } catch (ChartException e2) {

            System.out.println(e2.getMessage()); }

 }


// Handle events associated with the mouse pressed within a chart component.

// If the mouse is pressed in a bar, change the color of the bar.


public void mousePressed(MouseEvent e) {                                 [8]

      

   int x = e.getX();

   int y = e.getY();


   SeriesDesc SD = MyAxisCh.getSeriesIndexDesc(x,y);                     [9]

   int index = SD.getSeriesIndex();

   String seriesName = SD.getSeriesName();

            

   try {


       // Set the highlight color; issue a repaint command.             [10]

       MyAxisCh.setSeriesHighlight(seriesName, index, Color.blue);

       this.paint(this.getGraphics());


      } catch (ChartException e2) {

             System.out.println(e2.getMessage());

         }

 }


// Handle events associated with the mouse moving within a chart component.

//    If mouse enters a bar, highlight the bar and display an annotation.

//    If mouse exits a bar, remove the highlighting and annotation.


public void mouseMoved(MouseEvent e) {                                  [11]

      

   int x = e.getX();

   int y = e.getY();


   try {


       if (MyAxisCh.getSeriesElementExited(x,y)) {                      [12]

                

           MyAxisCh.setSeriesUnHighlight();        

           MyAxisCh.setSeriesAnnotationRemove();


           this.paint(this.getGraphics());

       }

            

       if (MyAxisCh.getSeriesElementEntered(x,y)) {                     [13]

                

          SeriesDesc SD = MyAxisCh.getSeriesIndexDesc(x,y);             [14]

          int index = SD.getSeriesIndex();

          String seriesName = SD.getSeriesName();


          MyAxisCh.setSeriesHighlight(seriesName, index, Color.orange); [15]

          MyAxisCh.setSeriesAnnotation(seriesName, index);

          this.paint(this.getGraphics());

        }

 .

 .

 .

The numbers in the example correspond to the numbers in the following list, which describes the example in detail:

1. The applet implements the java.awt.event.MouseMotionListener and the java.awt.event.MouseListener interface.

2. The AxisChartInteractive( ) constructor creates a new interactive axis chart object.

3. In the init( ) method, the applet is initialized. The enableEvents( ) method enables Java events.

4. The chart object is registered with the addMouseListener( ) and addMouseMotionListener( ) methods.

5. All Java mouse events are handled, even though some of them are not used in this applet.

6. The mouseExited( ) method detects when the pointer exits the chart.

7. If the previous location of the pointer was in a series element, such as a bar, the getSeriesElementExited( ) method detects when the pointer exits the element. The setSeriesUnHighlight( ) method removes the highlighting; the setSeriesAnnotationRemove( ) method removes the annotation from the element.

8. The mousePressed( ) method detects if the mouse is pressed.

9. The getSeriesIndexDesc( ) method determines the element in which the pointer is located. The method returns the index and series name.

10. The setSeriesHighlight( ) method, using the index and series name returned from the getSeriesIndexDesc( ) method, changes the color of the element within the series.

11. The mouseMoved( ) method detects when a mouse moves.

12. If the previous location of the pointer was in a series element, such as a bar, the getSeriesElementExited( ) method detects when the pointer exits the element. The setSeriesUnHighlight( ) method removes the highlighting; the setSeriesAnnotationRemove( ) method removes the annotation from the element.

13. The getSeriesElementEntered( ) method detects if the pointer entered a series element.

14. The getSeriesIndexDesc( ) method determines the element in which the pointer is located. The method returns the index and series name.

15. The setSeriesHighlight( ) method, using the index and series name returned from the getSeriesIndexDesc( ) method, changes the color of the element within the series. The setSeriesAnnotation( ) method displays an annotation for the element.

The following figure shows the interactive chart when the mouse is pressed over a bar:

For more examples of interactive axis charts, see the following directory:

• On UNIX:

  drive/chartbuilder/demos/dynamic/interact/axischart
  
  

• On Windows NT:

  drive\chartbuilder\demos\dynamic\interact\axischart
  
  

5.1.2.2 Building Interactive Pie Charts

Chart Builder provides the PieChartInteractive class for building interactive pie charts. The PieChartInteractive class contains the following event methods for determining when the mouse pointer enters or exits a pie slice:

• The getSliceEntered( ) method detects when the pointer enters a pie slice.

• The getSliceExited( ) method detects when the pointer exits a pie slice.

• The getSliceIndex( ) method determines the slice in which the event occurred. This method returns the index of the pie slice.

When a pie slice event occurs, your application can take the following actions:

• Take any valid Java action for a component.

• Highlight an element (a pie slice or slice label) using the setSliceHighlight( ) or setSliceLabelHighlight( ) method. You highlight an element by specifying a color.

• Remove the highlighting of an element using the setSliceUnHighlight( ) or setSliceLabelUnHighlight( ) method. This method restores the slice or label to its original color.

To build an interactive pie chart, you take the following basic steps:

1. Implement the java.awt.event.MouseMotionListener or the java.awt.event.MouseListener interface, or both.

2. Use the PieChartInteractive class to create the chart object.

3. Register the chart object using the addMouseListener( ) or addMouseMotionListener( ) methods, or both.

4. When particular mouse events occur, take an action. To take an action when a mouse event occurs in a pie slice, take the following steps:

   1. Use the Chart Builder pie slice event methods, such as getSliceEntered( ), to detect when an event occurs in a pie slice. The following example uses the getSliceEntered( ) method in an if statement:

      if (MyPieCh.getSliceEntered(x,y)) { ...
      
      

   2. Determine the pie slice in which the event occurred by getting the index of the x, y coordinate at the screen location using the getSliceIndex( ) method. If the coordinate is contained in a pie slice, Chart Builder returns the index. The following example returns the index to the variable ind:

      int index = MyPieCh.getSliceIndex(x,y);
      
      

      Slice index values are integers starting at 0. For example, if a pie chart has three slices, the slice indexes are 0, 1, 2.

   3. Use one of the Chart Builder pie slice action methods, such as the setSliceHighlight( ) method, to take the action. You pass the index of the slice and a color to the method. The following example calls the setSliceHighlight( ) method to change the color of a pie slice:

      MyPieCh.setSliceHighlight(index, Color.orange);
      
      

The following example shows excerpts of a Java application that creates an interactive pie chart. When the cursor enters a pie slice, the slice is highlighted; when the cursor exits a pie slice, the slice returns to its original color; when the mouse is pressed in a pie slice, the color of the slice changes.

 . 

 .

 .

public class pie_inter extends Frame implements MouseListener,           [1]

                                      MouseMotionListener {

 .

 .

 .

    PieChartInteractive MyPieCh;


    pie_inter() {


      setSize(ChartWidth, ChartHeight + 30 );


      enableEvents(AWTEvent.COMPONENT_EVENT_MASK);                       [2]

      addMouseListener(this);                                            [3]

      addMouseMotionListener(this);


      MyPieCh = createPieChart(ChartWidth,  ChartHeight);

      this.add(MyPieCh);

      MyPieCh.addMouseListener(this);

      MyPieCh.addMouseMotionListener(this);


      show();

    }


    // Set the original colors for the slices.

    Color SliceColors[] = new Color[] {                                  [4]

      new Color(204, 204, 204),

      new Color(0, 204, 0),

      new Color(204, 0, 0),

      new Color(0, 0, 204),

    };


    // Set the highlight colors for the slices.

    Color HilightColors[] = new Color[] {

      new Color(255, 255, 255),

      new Color(0, 255, 0),

      new Color(255, 0, 0),

      new Color(0, 0, 255),

    };


    // Create the chart and define the data inline.

    public PieChartInteractive createPieChart(int chartWidth, int chartHeight)

    {

      // Define the color for each slice.

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

          USExports[i].setBackground(SliceColors[i]);


      // Create a new PieChart object.

      PieChartInteractive MyPieCh = new PieChartInteractive();           [5]

 .

 .

 .

      return(MyPieCh);

    }

    

   // Mouse Events.


    // No actions taken for the following events.                        [6]

    public void mouseClicked(MouseEvent e) {

    }

    public void mouseEntered(MouseEvent e) {

      }

    public void mouseDragged(MouseEvent e) {

    }

    public void mouseReleased(MouseEvent e) {

    }


    // Handle events associated with the mouse moving within a chart

    // component.

    //    Highlight slice on mouse entry.

    //    Remove the highlighting from the slice on mouse exit.

    public void mouseMoved(MouseEvent e) {                               [7]

         

      int x = e.getX();

      int y = e.getY();


      if (e.getSource().equals(MyPieCh)) {

          try {

            if (MyPieCh.getSliceExited(x,y)) {                           [8]

                

                MyPieCh.setSliceUnHighlight();                           

                this.paint(this.getGraphics());

            }

            

            if (MyPieCh.getSliceEntered(x,y)) {                          [9]

                

                int index = MyPieCh.getSliceIndex(x,y);                 [10]

                MyPieCh.setSliceHighlight(index, HilightColors[index]); [11]

                this.paint(this.getGraphics());

            }

            

          } catch (ChartException e2) { System.out.println(e2.getMessage()); }

            

      }

    }


    // Handle events associated with the mouse exiting the chart component.

    // Remove highlighting on the slice when the mouse exits from it.

    public void mouseExited(MouseEvent e) {                             [12]


      int x = e.getX();

      int y = e.getY();

      if (e.getSource().equals(MyPieCh)) {

          try {

            if (MyPieCh.getSliceExited(x,y)) {                          [13]

                

                MyPieCh.setSliceUnHighlight();

                this.paint(this.getGraphics());

            }

            

          } catch (ChartException e2) { System.out.println(e2.getMessage()); }

            

      }

    }

    

    // Handle events associated with the mouse pressed within a chart

    // component.

    public void mousePressed(MouseEvent e) {                            [14]

      

      int x = e.getX();

      int y = e.getY();

      if (e.getSource().equals(MyPieCh)) {

          try {

            // Get the index for the slice.

            int index = MyPieCh.getSliceIndex(x,y);                     [15]

            

            // Set the highlight color; issue a repaint command.

            MyPieCh.setSliceHighlight(index, Color.orange);             [16]

            this.paint(this.getGraphics());

 .

 .

 .

The numbers in the example correspond to the numbers in the following list:

1. The Frame implements the java.awt.event.MouseMotionListener and the java.awt.event.MouseListener interface.

2. The enableEvents( ) method enables Java events.

3. The chart object is registered with the addMouseListener( ) and addMouseMotionListener( ) methods.

4. The original colors and the colors to be used as a highlight are defined.

5. The PieChartInteractive( ) constructor creates a new interactive pie chart object.

6. All Java mouse events are handled, even though some of them are not used in this applet.

7. The mouseMoved( ) method detects when a mouse moves.

8. If the previous location of the cursor was in a slice, the getSliceExited( ) method detects when the cursor exits the slice. The setSliceUnHighlight( ) method removes the highlighting.

9. The getSliceEntered( ) method detects if the cursor entered a pie slice.

10. The getSliceIndex( ) method determines the pie slice in which the cursor is located. The method returns the index.

11. The setSliceHighlight( ) method, using the index returned from the getSliceIndex( ) method, changes the color of the pie slice.

12. The mouseExited( ) method detects when the cursor exits the chart.

13. If the previous location of the cursor was in a pie slice, the getSliceExited( ) method detects when the cursor exits the slice. The setSliceUnHighlight( ) method removes the highlighting.

14. The mousePressed( ) method detects if the mouse is pressed.

15. The getSliceIndex( ) method determines the pie slice in which the cursor is located. The method returns the index.

16. The setSliceHighlight( ) method, using the index returned from the getSliceIndex( ) method, changes the color of the slice to orange.

The following figure shows the chart when the mouse has been pressed on the pie slice labeled "Canada":

For more examples of interactive pie charts, see the following directory:

• On UNIX:

  drive/chartbuilder/demos/dynamic/interact/piechart
  
  

• On Windows NT:

  drive\chartbuilder\demos\dynamic\interact\piechart
  

5.2.1.1 Incrementally Adding Y-Axis Values

You can load all of the timestamps into the X-axis and some or none of the values into the Y-axis when the chart is created. Then, you can incrementally add the Y-axis values to the chart. To do so, take the following steps:

1. Load the timestamps into the X-axis using the setXSeries( ) method.

2. Invoke the setYSeries( ) method, using only the series name, only to initialize the chart. This does not load any data into the Y-axis. Alternatively, invoke the setYSeries( ) method, using both the series name and the array name to initialize the chart and load some data into the Y-axis data.

3. Display the initial chart.

4. When given a specific input, load the data into the Y-axis by using the setYSeriesAppend( ) method and display the updated chart.

The following example shows excerpts of an application that displays a chart that defines all timestamps and loads some Y-axis data when the chart is created. When a user requests additional data, the data is appended to the Y-axis.

.

.

.

public class dyn_incr_y extends Frame {


    JPanel p1 = new JPanel();

    AxisChartInteractive MyAxisCh;

 

    // Chart dimensions

    int ChartWidth = 300;

    int ChartHeight = 200;


    // Constructor

    dyn_incr_y() {

       setSize(ChartWidth, ChartHeight + 70 );

       this.enableEvents(AWTEvent.COMPONENT_EVENT_MASK); 


       p1.setLayout(new BorderLayout(0,0);

       p1.setBackground(new Color (150, 150, 240));

       p1.setLayout(new BorderLayout());


       // Add the command buttons to the panel.

       CommandButtons CButtons = new CommandButtons();

       p1.add(CButtons,"South");


       // Initial chart.

       MyAxisCh = createChart(ChartWidth, ChartHeight);

      

       // Add the axis chart to the panel.

       if (MyAxisCh != null) {

           p1.add(MyAxisCh, "North");

       }

      

       // Add the panel to the applet.

       this.add(p1,"Center");

      

       show();


   }


   // Create an axis chart containing standard X-axis and Y-axis series.

   public AxisChartInteractive createChart(int chartWidth, int chartHeight) {


     AxisChartInteractive MyAxisCh = null;


     // Chart data, defined inline.

     // Initial values for the Y-axis.

     double YSeries[] = {0, 2, 1, 3, 2, 4};

   

     try {

        // Create a new AxisChart object.

        MyAxisCh = new AxisChartInteractive();


        // Set the size of the chart.

        MyAxisCh.setSize(chartWidth, chartHeight);


        // Load the timestamps for the X-axis.

        MyAxisCh.setXSeries(Calendar.YEAR,                               [1]

                     java.sql.Date.valueOf("1990-01-01"),

                     java.sql.Date.valueOf("2010-01-01"),

                      1);

        // Load the data for the Y-axis.                                 [2]

        MyAxisCh.setYSeries("series0", YSeries);

        MyAxisCh.setSeriesColor("series0", myGreen);


        // Set the title.

        MyAxisCh.getTitle().setText("Dynamically Append Data");

         MyAxisCh.getSubtitle().setText("Timestamps are defined at chart creation.");


      } catch (ChartException e) 

          {

            System.out.println(e.getMessage());

          }


      return(MyAxisCh);                                                  [3]

    }

 .

 .

 .

      // Button Events. When the button is clicked, append data to chart.


      void button_actionPerformed(ActionEvent e) {                       [4]

          String cmd = e.getActionCommand();

          

            try {


                  // Define the additional Y-axis values.

                  double YSeriesAppend[] = {1, 3};


                  // Append the additional values to the chart.          [5]

                  MyAxisCh.setYSeriesAppend("series0", YSeriesAppend);


                  // Repaint the chart.

                  Graphics g = p1.getGraphics();

                  MyAxisCh.paint(g);

 .

 .

 .

The numbers in the example correspond to the numbers in the following list, which describes the parts of the example that are specific to dynamic charts:

1. The setXSeries( ) method loads the timestamps for the X-axis when the chart is created.

2. The setYSeries( ) method, using the series name and array name, loads some initial data for the Y-axis data. In this example, six values are loaded initially.

3. The initial chart is returned and subsequently displayed.

4. The button_actionPerformed( ) method handles the event when the button is clicked.

5. The setYSeriesAppend( ) method adds new data to the Y-axis of the chart.

The following figure shows the chart when it is created and after the user clicks the Append Data button a couple of times:

5.2.1.2 Incrementally Adding Timestamps and Y-Axis Values

To incrementally load the timestamps and incrementally add the Y-axis values to the chart, you take the following steps:

1. Invoke the setXSeriesReserve( ) method to reserve space for a specified number of timestamps. For example, setXSeriesReserve(30) reserves space for 30 timestamps in an empty chart. Note that this method does not label the X-axis with timestamps.

2. Invoke the setYSeries( ) method, using only the series name. This only initializes the chart; it does not load any data into the Y-axis. (For stock charts, you use the setCandlestickSeries( ), setHiLoCloseSeries( ), or the setOpenHiLoCloseSeries( ) method.)

3. Display the initial chart. It contains no data.

4. For each of the initial timestamps and values, take the following steps:

   1. Invoke the setXSeriesAppend( ) method to populate the X-axis with one timestamp.

   2. Invoke the setYSeriesAppend( ) method to populate the Y-axis with a corresponding data value. For stock charts, you use the setCandlestickSeriesAppend( ), setHiLoCloseSeriesAppend( ), or the setOpenHiLoCloseSeriesAppend( ) method.

5. When the initial incremental loading is complete, the chart will show data for each reserved space. You can continue to add data to the chart in the following ways:

   • Shifting the earliest data out of the chart and appending additional timestamps to the chart. Invoke the setXSeriesShift( ) method to shift in new timestamps and the setYSeriesAppend( ) method to add the corresponding data.

   • Extending the X-axis by appending additional timestamps to the chart. Invoke the setXSeriesAppend( ) method to add new timestamps and the setYSeriesAppend( ) method to add the corresponding data.

     Consider the number of timestamps you will be adding and the size of the chart. Adding a great number of timestamps to a small chart could make the chart unreadable.

The following example shows excerpts of a Java application that creates a chart and incrementally adds new data while it shifts the earliest data out of the chart:

.

.

.

    int InitialXAxisIntervals = 120;

    // Initial Y-axis series is empty.

    double YSeries2[] = {};

    // Create an axis chart. Initially, the chart has no data; 

    // new data points are added when the user clicks the button.

     

    public AxisChartInteractive createChart(int chartWidth, int chartHeight) {


    AxisChartInteractive AxisCh = null;


     try{


      // Define a circular line marker. Allocate a LineDesc descriptor.

      LineDesc markerDescCircle = new LineDesc();

      markerDescCircle.setMarkerType(LineDesc.MARKER_CIRCLE);


      // Indicate that seconds should be labeled at all times.

      // Otherwise, the chart heuristics may disable seconds labeling.

      TimeAxisDesc timeDesc = new TimeAxisDesc();

      timeDesc.setMinDimension(TimeAxisDesc.SECOND);


      // Use a minimum of 2 lines for labeling the time axis.

      timeDesc.setMinLabelingLines(2);


      // Define the minimum and maximum values of the Y-axis.

      NumAxisDesc yAxisD = new NumAxisDesc();

      yAxisD.setExtentMin(-1);

      yAxisD.setExtentMax(1);


      // Create a new AxisChart object.

      AxisCh = new AxisChartInteractive();


      // Set the size of the chart.

      AxisCh.setSize(chartWidth, chartHeight);


      // Reserve space for a specified number of points.                           [1]

      AxisCh.setXSeriesReserve(InitialXAxisIntervals);


      // Define the name of the Y-axis series.                                     [2]

      AxisCh.setYSeries("series0");


      // Set the Y-axis attributes.                                                [3]

      AxisCh.setChartAttributes(yAxisD);


      // Set the X-axis attributes.                                                [4]

      AxisCh.setChartAttributes(timeDesc);


      // Use a circular line marker for series0.

      AxisCh.setSeriesGraphic("series0", markerDescCircle);


      // Set the title.

      AxisCh.getTitle().setText("Dynamic Strip Chart");

          

     } catch (ChartException e) 

         {

           System.out.println(e.getMessage());

           System.exit(1);

         }


      return(AxisCh);                                                              [5]

    }

.

.

.

          public void actionPerformed(ActionEvent e) {

            adaptee.button_actionPerformed(e);

          }

      }


      int hours = 0;

      int minutes =0;

      int seconds = 29;

      String strHrs;

      String strMin;

      String strSec;

      

      boolean done = false;


      double Yvalue = 0;

      int Angle = 0;


      void incrementAngle() 

      {

          Angle += 10;

          Angle %= 360;

          Yvalue = Math.sin(Math.toRadians(Angle));

      }

            

      // Construct a timestamp in the form of:

      // java.sql.Timestamp.valueOf("2001-01-01 00:00:00.000000000")

      void incrementTime() 

      {

          seconds++;


          if (seconds == 60) {

            seconds = 0;

            minutes++;

            // Arbitrary number of minutes to stop chart loading.                

            if (minutes == 4) done = true;           


            if (minutes == 60) {

                minutes = 0;

                hours++;

                

            }

          }

           

          if (hours == 0) strHrs = "00";

          else if (hours < 10) 

            strHrs = "0" + Integer.toString(hours);

          else strHrs = Integer.toString(hours);

.

.

.          

      }

      

      int appendCount = 0;


      // Button events

      void button_actionPerformed(ActionEvent e) {

          

          String cmd = e.getActionCommand();

          

          if (cmd.equals(StartCmd)) {

            String date1;            

            while (!done) {


              try {

               // Increment the X-axis and the Y-axis data.

               incrementTime();

               incrementAngle();

               date1 ="2001-11-01 " + strHrs + ":" + strMin + ":" + strSec + ".000000000";

                

               // The Y-axis series that is appended on each simulation step.

               double YSeriesAppend[] = {Yvalue};


               // For the first 120 values, the X-axis has reserved intervals.

               // Fill these reserved intervals one point at a time.

               if ((YSeries2.length + appendCount) < InitialXAxisIntervals) {

                      

                  java.sql.Timestamp newdates[] = {java.sql.Timestamp.valueOf(date1)};


                  AxisCh.setXSeriesAppend(newdates);                                  [6]

                  AxisCh.setYSeriesAppend("series0", YSeriesAppend);                

                  appendCount++;

                      

                  }


                 else {


                  // When all series values along the X-axis are displayed,

                  // append new dates by shifting old ones out and adding new ones.

                  java.sql.Timestamp newdates[] = {java.sql.Timestamp.valueOf(date1)};

                  

                  AxisCh.setXSeriesShift(newdates);                                   [7]

                  

                  // Append one additional point to the Y-axis.

                  AxisCh.setYSeriesAppend("series0", YSeriesAppend);                  [8]

                  

                }

                  

                // Repaint the chart.

                Graphics g = p1.getGraphics();

                AxisCh.paint(g);

.

.

.

The numbers in the example correspond to the numbers in the following list:

1. The setXSeriesReserve( ) method reserves space for 120 timestamps in an empty chart, but it does not label the X-axis with timestamps.

2. The setYSeries( ) method, using only the series name, initializes the chart; it does not load any data into the Y-axis.

3. The setChartAttributes(yAxisD) method sets the attributes for the Y-axis. In this case, minimum and maximum values are set using the NumAxisDesc constructor, which is shown earlier in the example. See Section 3.6.1 for more information about setting minimum and maximum values.

4. The setChartAttributes(timeDesc) method sets the attributes for the X-axis. In this case, seconds are to be labeled at all times and a minimum of two lines are set using the TimeAxisDesc constructor, which is shown earlier in the example. See Section 3.5.4 for information about setting the minimum number of lines and see Section 3.6.1 for information about setting the increments.

5. The initial chart, containing no data, is displayed.

6. For each of the initial timestamps and values, the setXSeriesAppend( ) method populates the X-axis with one timestamp, and the setYSeriesAppend( ) method populates the Y-axis with a corresponding data value.

   When the initial incremental loading is complete, the chart will show data for each reserved space.

7. The setXSeriesShift( ) method adds new timestamps by shifting the earliest timestamps out of the chart and adding the new ones incrementally.

8. The setYSeriesAppend( ) method adds data to the Y-axis that corresponds to the added timestamps.

The following figure shows the resulting chart after the Start Simulation button is clicked:

For more examples of dynamic charts, see the following directory:

• On UNIX:

  drive/chartbuilder/demos/dynamic/dynupdate
  
  

• On Windows NT:

  drive\chartbuilder\demos\dynamic\dynupdate