Lab 9  Comp 170-201 -- Dordal/Nabicht -- Wed, October 30, 2002
Final version due Mon Nov 4


In this lab you will convert the Scribble program from using
ArrayLists to using arrays. All changes will take place to the
ScribblePanel class.

There are three issues with using arrays:

   * they are fixed size; you will have to decide what to do when
     the array runs out of space. Having the program just stop drawing
     would be acceptable. In the sample file, I have defined
        private final int SCRIBSIZE = 300;   // # points per scribble
        private final int NUMSCRIBS = 20;    // number of scribbles
     Any one scribble can thus have at most 300 points, and the entire
     diagram can have at most 20 scribbles.

   * You need to keep track of the part of the array that 
     is actually used. While working on one scribble, 
     you need to keep track of the fact, for example,
     that you're at point 54, and array slots 55-299 are unused.
     You can either do this by keeping a "size" value somewhere 
     in a numeric variable, or by making sure that the unused parts
     of each array contain the value "null", and checking for that.
     
   * Each scribble is an array of Points, and the whole works will be
     an array of scribbles, that is, an array of arrays of Point.

Start by copying the files Scribble.java and ScribblePanel.java from
my web page. These files include the necessary array declarations,
but the arrays aren't used. 

Note that, when using arrays, no type casting is needed to get the
correct type when you take data out of the array.

As with the ArrayList implementation, we will have a single array
representing the current scribble, 
        Point [] currentScribbleA;
and also an array of such arrays representing the set of all scribbles:
        Point[] [] ScribblesA;
The number of entries in ScribblesA can be represented by 
        int scribcount;
that is, ScribblesA[0]..ScribblesA[scount-1] are valid, and that last
one is currentScribbleA. You don't actually have to use scribcount;
you can just note that entries at or beyond scribcount in ScribblesA
will be null.

For each individual scribble, we also have to keep track of how many 
points are in it; for the scribble ScribbleA[i]. I've declared 
scribsizes[] to be an array of ints of size NUMSCRIBS; you can either
put the number of Points of ScribbleA[i] into scribsizes[i], or note 
that entries beyond the end of the scribble will be filled by null.
(In the latter case you wouldn't use scribsizes at all.)

Here's what you'll have to do:
1. Replace drawScribble(ArrayList s, Graphics g) with
        void drawScribbleA(Point[] s, int size, Graphics g);
You'll call this from paintComponent as
        drawScribbleA(ScribblesA[i], scribsizes[i], page);
or else, if you're using nulls to keep track of the end of the 
scribble, leave out the size. In that case, the body of 
drawScribbleA might look like:
        if (s[0] == null) return;
        Point prev = s[0];
        while (i<s.length && s[i]!= null) {
           Point next = s[i];
           g.drawLine(prev.x, prev.y, next.x, next.y);
           prev = next;
        }

2. Make paintComponent draw the first 0..scribcount-1 
scribbles, or else use null to determine which to draw: 
        while (i<NUMSCRIBS && ScribblesA[i] != null)

3. Have mousePressed() create a new currentScribbleA, add it to 
the array ScribblesA at position scribcount, increment scribcount,
and put the current point into currentScribbleA[0]. If you're using
nulls, search for the first null entry in ScribbleA to tell you where
to put the new currentScribbleA.

4. Have mouseDragged() add the new point to the right position of
currentScribbleA, and then update the scribsizes[] entry for that
scribble. If you're using nulls, search again for the first non-null
place to put the new point. If you're using numeric sizes, you will
have something like
         int n = scribsizes[scribcount-1];
          scribsizes[scribcount-1]++;
          currentScribbleA[n] = newpoint;
That is, the currentScribbleA is at position scribcount-1 in the
array ScribblesA of all scribbles, and so its size is at
scribsizes[scribcount-1]. The value n above is the first empty
position in the scribble.

One last thing: you should check for *array overflow* when applicable;
that is, you don't want to put more points (or scribbles) into an 
array than there's room for. An easy way to deal with overflow is to
do nothing, so the last code line of the block immediately above would be
        if (n<currentScribbleA.length) currentScribbleA[n] = newpoint;
        
===================================================================

//********************************************************************
//  ScribblePanel.java       Author: Lewis/Loftus
//
//  Represents the primary panel for the Scribble program on which the
//  scribbles are drawn.
//  This implementation *uses* ArrayLists, but contains
//  *declarations* for an array-only implementation as well - pld
//********************************************************************

import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import java.util.*;

public class ScribblePanel2 extends JPanel
{
   private final int WIDTH = 600, HEIGHT = 400;
   private final int SCRIBSIZE = 300;   // number of points in one scribble
   private final int NUMSCRIBS = 20;    // number of scribbles

   private ArrayList currentScribble;
   private ArrayList Scribbles;         // pld
   Point [] currentScribbleA;
   int scribcount = 0;                  // total number of scribbles in use
   Point[] [] ScribblesA;
   int [] scribsizes;                   // scribsizes[i] = size of currentScribbleA[i]

   //-----------------------------------------------------------------
   //  Sets up this panel to listen for mouse events.
   //-----------------------------------------------------------------
   public ScribblePanel2()
   {
      currentScribble = null;
      Scribbles = new ArrayList();          // pld
      scribcount = 0;
      // note following construction of an array where the components will be arrays,
      // but the components aren't being constructed yet:
      ScribblesA = new Point[NUMSCRIBS][];  // to replace Scribbles above
      scribsizes = new int[NUMSCRIBS];

      ScribbleListener sl = new ScribbleListener();
      addMouseListener (sl);
      addMouseMotionListener (sl);

      setBackground (Color.black);
      setPreferredSize (new Dimension(WIDTH, HEIGHT));
   }

   //-----------------------------------------------------------------
   //  Redraws all the scribbles
   //-----------------------------------------------------------------
   public void paintComponent (Graphics page)
   {
      super.paintComponent(page);       // clear screen; paint it black
      page.setColor (Color.green);

      // draw the scribbles in Scribbles
      int i = 0; 
      for (i=0; i<Scribbles.size(); i++) {
           drawScribble((ArrayList)Scribbles.get(i), page); // pld
      }
   }

//*************************
//   drawScribble: draws one ArrayList scribble on the page
//***************************
    private void drawScribble(ArrayList s, Graphics g) {
        if (s==null || s.size() == 0) return;  // pld; nothing to draw;
        Point prev = (Point)s.get(0);
        for (int i = 1; i<s.size(); i++) {
            Point next = (Point)s.get(i);
            g.drawLine(prev.x, prev.y, next.x, next.y);
            prev = next;
        }
    }
    
    // draws one array scribble on the page
       private void drawScribbleA(Point[] s, int size, Graphics g) {
          if (s==null || size == 0) return;  // pld; nothing to draw;
          Point prev = s[0];
          // ...
       }
 
   //*****************************************************************
   //  Represents the listener for mouse events.
   //*****************************************************************
   private class ScribbleListener implements MouseListener,
                                            MouseMotionListener // new
   {
      //--------------------------------------------------------------
      //  starts a new scribble
      //--------------------------------------------------------------
      public void mousePressed (MouseEvent event)
      {
         Point clickPoint = event.getPoint();
         currentScribble = new ArrayList();            // pld
         Scribbles.add(currentScribble);
         currentScribble.add (clickPoint);
         // array stuff
         scribcount++;
         int index = scribcount-1;
         scribsizes[index]=1;
         currentScribbleA = new Point[SCRIBSIZE];       // new array of Point
         // now put into ScrbblesA, and put clickPoint into currentScribbleA
        repaint();
      }

    // continues the scribble
      public void mouseDragged(MouseEvent event) {  
          Point newpoint = event.getPoint();
          currentScribble.add(newpoint);
          //int n = scribsizes[scribcount-1]; // for arrays
          // currentScribbleA[n] = newpoint;
          // what else?
          repaint();
      }
      
      //-----------------------------------------------------------------
      //  Provide empty definitions for unused event methods.
      //-----------------------------------------------------------------
      public void mouseClicked (MouseEvent event) {}
     // public void mousePressed (MouseEvent event) {}
      public void mouseReleased (MouseEvent event) {}
      public void mouseEntered (MouseEvent event) {}
      public void mouseExited (MouseEvent event) {}
      public void mouseMoved  (MouseEvent event) {}
     // public void mouseDragged(MouseEvent e) {}
   }
}