public DrawingPanel() {
   this(DEFAULT_WIDTH, DEFAULT_HEIGHT);
}

/**
* Constructs a drawing panel of given width and height enclosed in a window.
* @param width panel's width in pixels
* @param height panel's height in pixels
*/
public DrawingPanel(int width, int height) {
   ensureInRange("width", width, 0, MAX_SIZE);
   ensureInRange("height", height, 0, MAX_SIZE);

   checkAnimationSettings();

   if (DEBUG) System.out.println("DrawingPanel(): going to grab lock");
   synchronized (LOCK) {
         instances++;
         instanceNumber = instances; // each DrawingPanel stores its own int number
         INSTANCES.add(this);

         if (shutdownThread == null && !usingDrJava()) {
            if (DEBUG) System.out.println("DrawingPanel(): starting idle thread");
            shutdownThread = new Thread(new Runnable() {
               // Runnable implementation; used for shutdown thread.
               public void run() {
                     boolean save = shouldSave();
                     try {
                        while (true) {
                           // maybe shut down the program, if no more DrawingPanels are onscreen
                           // and main has finished executing
                           save |= shouldSave();
                           if (DEBUG) System.out.println("DrawingPanel idle thread: instances=" + instances + ", save=" + save + ", main active=" + mainIsActive());
                           if ((instances == 0 || save) && !mainIsActive()) {
                                 try {
                                    System.exit(0);
                                 } catch (SecurityException sex) {
                                    if (DEBUG) System.out.println("DrawingPanel idle thread: unable to exit program: " + sex);
                                 }
                           }

                           Thread.sleep(250);
                        }
                     } catch (Exception e) {
                        if (DEBUG) System.out.println("DrawingPanel idle thread: exception caught: " + e);
                     }
               }
            });
            // shutdownThread.setPriority(Thread.MIN_PRIORITY);
            shutdownThread.setName("DrawingPanel-shutdown");
            shutdownThread.start();
         }
   }

   this.width = width;
   this.height = height;

   if (DEBUG) System.out.println("DrawingPanel(w=" + width + ",h=" + height + ",anim=" + isAnimated() + ",graph=" + isGraphical() + ",save=" + shouldSave());

   if (isAnimated() && shouldSave()) {
         // image must be no more than 256 colors
         image = new BufferedImage(width, height, BufferedImage.TYPE_BYTE_INDEXED);
         // image = new BufferedImage(width, height, BufferedImage.TYPE_INT_ARGB);
         antialias = false; // turn off anti-aliasing to save palette colors

         // initially fill the entire frame with the background color,
         // because it won't show through via transparency like with a full ARGB image
         Graphics g = image.getGraphics();
         g.setColor(backgroundColor);
         g.fillRect(0, 0, width + 1, height + 1);
   } else {
         image = new BufferedImage(width, height, BufferedImage.TYPE_INT_ARGB);
   }
   initialPixel = image.getRGB(0, 0);

   g2 = (Graphics2D) image.getGraphics();
   // new field assignments for DebuggingGraphics
   g3 = new DebuggingGraphics();
   counts = new TreeMap<String, Integer>();
   g2.setColor(Color.BLACK);
   if (antialias) {
         g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
   }

   if (isAnimated()) {
         initializeAnimation();
   }

   if (isGraphical()) {
         try {
            UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
         } catch (Exception e) {
            // empty
         }

         statusBar = new JLabel(" ");
         statusBar.setBorder(BorderFactory.createLineBorder(Color.BLACK));

         panel = new JPanel(new FlowLayout(FlowLayout.LEFT, 0, 0));
         panel.setBackground(backgroundColor);
         panel.setPreferredSize(new Dimension(width, height));
         imagePanel = new ImagePanel(image);
         imagePanel.setBackground(backgroundColor);
         panel.add(imagePanel);

         // listen to mouse movement
         mouseListener = new DPMouseListener();
         panel.addMouseMotionListener(mouseListener);

         // main window frame
         frame = new JFrame(TITLE);
         // frame.setResizable(false);
         windowListener = new DPWindowListener();
         frame.addWindowListener(windowListener);
         // JPanel center = new JPanel(new FlowLayout(FlowLayout.CENTER, 0, 0));
         JScrollPane center = new JScrollPane(panel);
         // center.add(panel);
         frame.getContentPane().add(center);
         frame.getContentPane().add(statusBar, "South");
         frame.setBackground(Color.DARK_GRAY);

         // menu bar
         actionListener = new DPActionListener();
         setupMenuBar();

         frame.pack();
         center(frame);
         frame.setVisible(true);
         if (!shouldSave()) {
            toFront(frame);
         }

         // repaint timer so that the screen will update
         createTime = System.currentTimeMillis();
         timer = new Timer(DELAY, actionListener);
         timer.start();
   } else if (shouldSave()) {
         // headless mode; just set a hook on shutdown to save the image
         callingClassName = getCallingClassName();
         try {
            Runtime.getRuntime().addShutdownHook(new Thread(new Runnable() {
               // run on shutdown to save the image
               public void run() {
                     if (DEBUG) System.out.println("DrawingPanel.run(): Running shutdown hook");
                     if (DEBUG) System.out.println("DrawingPanel shutdown hook: instances=" + instances);
                     try {
                        String filename = System.getProperty(SAVE_PROPERTY);
                        if (filename == null) {
                           filename = callingClassName + ".png";
                        }

                        if (isAnimated()) {
                           saveAnimated(filename);
                        } else {
                           save(filename);
                        }
                     } catch (SecurityException e) {
                        System.err.println("Security error while saving image: " + e);
                     } catch (IOException e) {
                        System.err.println("Error saving image: " + e);
                     }
               }
            }));
         } catch (Exception e) {
            if (DEBUG) System.out.println("DrawingPanel(): unable to add shutdown hook: " + e);
         }
   }
}

/**
* Constructs a drawing panel that displays the image from the given file enclosed in a window.
* The panel will be sized exactly to fit the image inside it.
* @param imageFile the image file to load
* @throws RuntimeException if the image file is not found
*/
public DrawingPanel(File imageFile) {
   this(imageFile.toString());
}

/**
* Constructs a drawing panel that displays the image from the given file name enclosed in a window.
* The panel will be sized exactly to fit the image inside it.
* @param imageFileName the file name/path of the image file to load
* @throws RuntimeException if the image file is not found
*/
public DrawingPanel(String imageFileName) {
   this();
   Image image = loadImage(imageFileName);
   setSize(image.getWidth(this), image.getHeight(this));
   getGraphics().drawImage(image, 0, 0, this);
}

/**
* Adds the given event listener to respond to key events on this panel.
* @param listener the key event listener to attach
*/
public void addKeyListener(KeyListener listener) {
   ensureNotNull("listener", listener);
frame.addKeyListener(listener);
   panel.setFocusable(false);
   frame.requestFocusInWindow();
   frame.requestFocus();
}

/**
* Adds the given event listener to respond to mouse events on this panel.
* @param listener the mouse event listener to attach
*/
public void addMouseListener(MouseListener listener) {
   ensureNotNull("listener", listener);
   panel.addMouseListener(listener);
   if (listener instanceof MouseMotionListener) {
         panel.addMouseMotionListener((MouseMotionListener) listener);
   }
}

/**
* Adds the given event listener to respond to mouse events on this panel.
*/
// public void addMouseListener(MouseMotionListener listener) {
//    panel.addMouseMotionListener(listener);
//    if (listener instanceof MouseListener) {
//          panel.addMouseListener((MouseListener) listener);
//    }
// }

// /**
// * Adds the given event listener to respond to mouse events on this panel.
// */
// public void addMouseListener(MouseInputListener listener) {
//    addMouseListener((MouseListener) listener);
// }

/*
* Whether the panel should automatically switch to animated mode
* if it calls the sleep method.
*/
private boolean autoEnableAnimationOnSleep() {
   return propertyIsTrue(AUTO_ENABLE_ANIMATION_ON_SLEEP_PROPERTY);
}

/*
* Moves the given JFrame to the center of the screen.
*/
private void center(Window frame) {
   Toolkit tk = Toolkit.getDefaultToolkit();
   Dimension screen = tk.getScreenSize();
   int x = Math.max(0, (screen.width - frame.getWidth()) / 2);
   int y = Math.max(0, (screen.height - frame.getHeight()) / 2);
   frame.setLocation(x, y);
}

/*
* Constructs and initializes our JFileChooser field if necessary.
*/
private void checkChooser() {
   if (chooser == null) {
         chooser = new JFileChooser();
         try {
            chooser.setCurrentDirectory(new File(System.getProperty("user.dir")));
         } catch (Exception e) {
            // empty
         }
         chooser.setMultiSelectionEnabled(false);
         chooser.setFileFilter(new DPFileFilter());
   }
}

/**
* Erases all drawn shapes/lines/colors from the panel.
*/
public void clear() {
   int[] pixels = new int[width * height];
   for (int i = 0; i < pixels.length; i++) {
         pixels[i] = initialPixel;
   }
   image.setRGB(0, 0, width, height, pixels, 0, 1);
}

/*
* Compares the current DrawingPanel image to an image file on disk.
*/
private void compareToFile() {
   // save current image to a temp file
   try {
         String tempFile = saveToTempFile();

         // use file chooser dialog to find image to compare against
         checkChooser();
         if (chooser.showOpenDialog(frame) != JFileChooser.APPROVE_OPTION) {
            return;
         }

         // user chose a file; let's diff it
         new DiffImage(chooser.getSelectedFile().toString(), tempFile);
   } catch (IOException ioe) {
         JOptionPane.showMessageDialog(frame,
                                       "Unable to compare images: \n" + ioe);
   }
}

/*
* Compares the current DrawingPanel image to an image file on the web.
*/
private void compareToURL() {
   // save current image to a temp file
   try {
         String tempFile = saveToTempFile();

         // get list of images to compare against from web site
         URL url = new URL(COURSE_WEB_SITE);
         Scanner input = new Scanner(url.openStream());
         List<String> lines = new ArrayList<String>();
         List<String> filenames = new ArrayList<String>();
         while (input.hasNextLine()) {
            String line = input.nextLine().trim();
            if (line.length() == 0) { continue; }

            if (line.startsWith("#")) {
               // a comment
               if (line.endsWith(":")) {
                     // category label
                     lines.add(line);
                     line = line.replaceAll("#\\s*", "");
                     filenames.add(line);
               }
            } else {
               lines.add(line);

               // get filename
               int lastSlash = line.lastIndexOf('/');
               if (lastSlash >= 0) {
                     line = line.substring(lastSlash + 1);
               }

               // remove extension
               int dot = line.lastIndexOf('.');
               if (dot >= 0) {
                     line = line.substring(0, dot);
               }

               filenames.add(line);
            }
         }
         input.close();

         if (filenames.isEmpty()) {
            JOptionPane.showMessageDialog(frame,
               "No valid web files found to compare against.",
               "Error: no web files found",
               JOptionPane.ERROR_MESSAGE);
            return;
         } else {
            String fileURL = null;
            if (filenames.size() == 1) {
               // only one choice; take it
               fileURL = lines.get(0);
            } else {
               // user chooses file to compare against
               int choice = showOptionDialog(frame, "File to compare against?",
                        "Choose File", filenames.toArray(new String[0]));
               if (choice < 0) {
                     return;
               }

               // user chose a file; let's diff it
               fileURL = lines.get(choice);
            }
            new DiffImage(fileURL, tempFile);
         }
   } catch (NoRouteToHostException nrthe) {
         JOptionPane.showMessageDialog(frame, "You do not appear to have a working internet connection.\nPlease check your internet settings and try again.\n\n" + nrthe);
   } catch (UnknownHostException uhe) {
         JOptionPane.showMessageDialog(frame, "Internet connection error: \n" + uhe);
   } catch (SocketException se) {
         JOptionPane.showMessageDialog(frame, "Internet connection error: \n" + se);
   } catch (IOException ioe) {
         JOptionPane.showMessageDialog(frame, "Unable to compare images: \n" + ioe);
   }
}

/*
* Closes the DrawingPanel and exits the program.
*/
private void exit() {
   if (isGraphical()) {
         frame.setVisible(false);
         frame.dispose();
   }
   try {
         System.exit(0);
   } catch (SecurityException e) {
         // if we're running in an applet or something, can't do System.exit
   }
}

/*
* Returns a best guess about the name of the class that constructed this panel.
*/
private String getCallingClassName() {
   StackTraceElement[] stack = new RuntimeException().getStackTrace();
   String className = this.getClass().getName();
   for (StackTraceElement element : stack) {
         String cl = element.getClassName();
         if (!className.equals(cl)) {
            className = cl;
            break;
         }
   }

   return className;
}

/**
* Returns a map of counts of occurrences of calls of various drawing methods.
* You can print this map to see how many times your graphics methods have
* been called to aid in debugging.
* @return map of {method name, count} pairs
*/
public Map<String, Integer> getCounts() {
   return Collections.unmodifiableMap(counts);
}

/**
* A variation of getGraphics that returns an object that records
* a count for various drawing methods.
* See also: getCounts
* @return debug Graphics object
*/
public Graphics getDebuggingGraphics() {
   if (g3 == null) {
         g3 = new DebuggingGraphics();
   }
   return g3;
}

/**
* Obtain the Graphics object to draw on the panel.
* @return panel's Graphics object
*/
public Graphics2D getGraphics() {
   return g2;
}

/*
* Creates the buffered image for drawing on this panel.
*/
private BufferedImage getImage() {
   // create second image so we get the background color
   BufferedImage image2;
   if (isAnimated()) {
         image2 = new BufferedImage(width, height, BufferedImage.TYPE_BYTE_INDEXED);
   } else {
         image2 = new BufferedImage(width, height, image.getType());
   }
   Graphics g = image2.getGraphics();
   // if (DEBUG) System.out.println("DrawingPanel getImage setting background to " + backgroundColor);
   g.setColor(backgroundColor);
   g.fillRect(0, 0, width, height);
   g.drawImage(image, 0, 0, panel);
   return image2;
}

/**
* Returns the drawing panel's height in pixels.
* @return drawing panel's height in pixels
*/
public int getHeight() {
   return height;
}

/**
* Returns the color of the pixel at the given x/y coordinate as a Color object.
* If nothing has been explicitly drawn on this particular pixel, the panel's
* background color is returned.
* @param x x-coordinate of pixel to retrieve
* @param y y-coordinate of pixel to retrieve
* @return pixel (x, y) color as a Color object
* @throws IllegalArgumentException if (x, y) is out of range
*/
public Color getPixel(int x, int y) {
int rgb = getPixelRGB(x, y);
   if (getAlpha(rgb) == 0) {
         return backgroundColor;
   } else {
         return new Color(rgb, /* hasAlpha */ true);
   }
}

/**
* Returns the color of the pixel at the given x/y coordinate as an RGB integer.
* The individual red, green, and blue components of the RGB integer can be
* extracted from this by calling DrawingPanel.getRed, getGreen, and getBlue.
* If nothing has been explicitly drawn on this particular pixel, the panel's
* background color is returned.
* See also: getPixel.
* @param x x-coordinate of pixel to retrieve
* @param y y-coordinate of pixel to retrieve
* @return pixel (x, y) color as an RGB integer
* @throws IllegalArgumentException if (x, y) is out of range
*/
public int getPixelRGB(int x, int y) {
   ensureInRange("x", x, 0, getWidth() - 1);
   ensureInRange("y", y, 0, getHeight() - 1);
int rgb = image.getRGB(x, y);
   if (getAlpha(rgb) == 0) {
         return backgroundColor.getRGB();
   } else {
         return rgb;
   }
}

/**
* Returns the colors of all pixels in this DrawingPanel as a 2-D array
* of Color objects.
* The first index of the array is the y-coordinate, and the second index
* is the x-coordinate. So, for example, index [r][c] represents the RGB
* pixel data for the pixel at position (x=c, y=r).
* @return 2D array of colors (row-major)
*/
public Color[][] getPixels() {
   Color[][] pixels = new Color[getHeight()][getWidth()];
   for (int row = 0; row < pixels.length; row++) {
         for (int col = 0; col < pixels[0].length; col++) {
            // note axis inversion; x/y => col/row
            pixels[row][col] = getPixel(col, row);
         }
   }
   return pixels;
}

/**
* Returns the colors of all pixels in this DrawingPanel as a 2-D array
* of RGB integers.
* The first index of the array is the y-coordinate, and the second index
* is the x-coordinate. So, for example, index [r][c] represents the RGB
* pixel data for the pixel at position (x=c, y=r).
* The individual red, green, and blue components of each RGB integer can be
* extracted from this by calling DrawingPanel.getRed, getGreen, and getBlue.
* @return 2D array of RGB integers (row-major)
*/
public int[][] getPixelsRGB() {
   int[][] pixels = new int[getHeight()][getWidth()];
   int backgroundRGB = backgroundColor.getRGB();
   for (int row = 0; row < pixels.length; row++) {
         for (int col = 0; col < pixels[0].length; col++) {
            // note axis inversion; x/y => col/row
            int px = image.getRGB(col, row);
            if (getAlpha(px) == 0) {
               pixels[row][col] = backgroundRGB;
            } else {
               pixels[row][col] = px;
            }
         }
   }
   return pixels;
}

/**
* Returns the drawing panel's pixel size (width, height) as a Dimension object.
* @return panel's size
*/
public Dimension getSize() {
   return new Dimension(width, height);
}

/**
* Returns the drawing panel's width in pixels.
* @return panel's width
*/
public int getWidth() {
   return width;
}

/**
* Returns the drawing panel's x-coordinate on the screen.
* @return panel's x-coordinate
*/
public int getX() {
   return frame.getX();
}

/**
* Returns the drawing panel's y-coordinate on the screen.
* @return panel's y-coordinate
*/
public int getY() {
   return frame.getY();
}

/**
* Returns the drawing panel's current zoom factor.
* Initially this is 1 to indicate 100% zoom, the original size.
* A factor of 2 would indicate 200% zoom, and so on.
* @return zoom factor (default 1)
*/
public int getZoom() {
   return currentZoom;
}

/**
* Internal method;
* notifies the panel when images are loaded and updated.
* This is a required method of ImageObserver interface.
* This is an internal method not meant to be called by clients.
* @param img internal method; do not call
* @param infoflags internal method; do not call
* @param x internal method; do not call
* @param y internal method; do not call
* @param width internal method; do not call
* @param height internal method; do not call
*/
@Override
public boolean imageUpdate(Image img, int infoflags, int x, int y, int width, int height) {
   imagePanel.imageUpdate(img, infoflags, x, y, width, height);
   return false;
}

/*
* Sets up state for drawing and saving frames of animation to a GIF image.
*/
private void initializeAnimation() {
   frames = new ArrayList<ImageFrame>();
   encoder = new Gif89Encoder();
   /*
   try {
         if (hasProperty(SAVE_PROPERTY)) {
            stream = new FileOutputStream(System.getProperty(SAVE_PROPERTY));
         }
         // encoder.startEncoding(stream);
   } catch (IOException e) {
         System.out.println(e);
   }
   */
}

/*
* Returns whether this drawing panel is in animation mode.
*/
private boolean isAnimated() {
   return animated || propertyIsTrue(ANIMATED_PROPERTY);
}

/*
* Returns whether this drawing panel is going to be displayed on screen.
* This is almost always true except in some server environments where
* the DrawingPanel is run 'headless' without a GUI, often for scripting
* and automation purposes.
*/
private boolean isGraphical() {
   return !hasProperty(SAVE_PROPERTY) && !hasProperty(HEADLESS_PROPERTY);
}

/*
* Returns true if the drawing panel class is in multiple mode.
* This would be true if the current program pops up several drawing panels
* and we want to save the state of each of them to a different file.
*/
private boolean isMultiple() {
   return propertyIsTrue(MULTIPLE_PROPERTY);
}

/**
* Loads an image from the given file on disk and returns it
* as an Image object.
* @param file the file to load

Part1: (1) Divide the content pane into two. (2) In the first pan...