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

/**
  * Demonstrate effect of the alpha transparency factor in pixel
  * values. The user selects via the BgControlPanel a color for a
  * large rectangle. Similarly, the user selects via the FgControlPanel
  * both the color and transparency factor of a small rectangle painted
  * over the larger one. The rectangles are displayed on the OutputPanel.
  * The resulting pixel value in the overlay area is displayed on
  * the output
 **/
public class TransparencyApplet extends JApplet
{
  /** Create the user interface with OutputPanel and two control panels.**/
  public void init () {

    setLayout (new GridLayout (2,1));

    // Create an instance of OutputPanel
    OutputPanel output_panel = new OutputPanel ();

    // Create an instance of the background color control panel
    BgControlPanel bg_control_panel = new BgControlPanel (output_panel);

    // Create an instance of the foreground color control panel
    FgControlPanel fg_control_panel = new FgControlPanel (output_panel);

    JPanel controls_panel = new JPanel (new GridLayout (1,2));

    controls_panel.add(bg_control_panel);
    controls_panel.add(fg_control_panel);

    // Add the panels to applet's pane.
    add (output_panel);
    add (controls_panel);
  } // init

} // class TransparencyApplet
 

import javax.swing.*;
import java.awt.*;
import java.awt.image.*;

/**
  * This JPanel subclass displays one large rectangle
  * with a background color plus a smaller rectangle
  * drawn over the first one with a foreground color. The
  * background and foreground colors can be set with the
  * setBgColor and setFgColor methods respectively.
  *
  * The drawing is first done on an offscreen image so that
  * we can obtain the pixel that results from the combination
  * of the two colors. The alpha factor selected for the
  * foreground will affect the combination color.
 **/
public class OutputPanel extends JPanel {
  Color fBgColor = Color.RED;
  Color fFgColor = Color.BLUE;

  /**
    * Set the background color by passing the 3 RGB component
    * values  (with ranges 0-255).
   **/
  void setBgColor (int cr, int cg, int cb) {
    fBgColor = new Color (cr,cg,cb);
    repaint ();
  }

  /**
    * Set the color of the foreground overlpay
    * by passing the 3 RGB component values
    * plus the alpha value (with ranges 0-255).
   **/
  void setFgColor (int cr, int cg, int cb, int ca) {
    fFgColor = new Color (cr,cg,cb,ca);
    repaint ();
  }

  /**
    * Use an offscreen image to draw a rectangle with the
    * background color and then overlay a smaller rectangle
    * with the foreground color amd  alpha factor selected
    * by the user. This image is then drawn on the panel.
    *
    * To find out the pixel value that results from this
    * combination of the background color plus the overlay color,
    * we use a PixelGrabber object to get the pixel array.
    * The resulting pixel value is drawn on the center of the panel.
   **/
  public void paintComponent (Graphics g) {
    super.paintComponent (g);

    int panelWd = getWidth ();
    int panelHt = getHeight ();

    Image img = createImage (panelWd,panelHt);
    Graphics img_gc = img.getGraphics ();

    // Now we fill a rectangle the size of the
    // panel with the chosen color.
    img_gc.setColor (fBgColor);
    img_gc.fillRect (0, 0, panelWd, panelHt);

    // Now overlay a rectanagular patch over the panel
    // and fill it with the foreground color.
    int x = (int)(0.20 * panelWd);
    int y = (int)(0.20 * panelHt);

    int patchWd = (int)(0.60 * panelWd);
    int patchHt = (int)(0.60 * panelHt);

    img_gc.setColor (fFgColor);
    img_gc.fillRect (x, y, patchWd, patchHt);

    g.drawImage (img, 0, 0, this);

    // To determine the color of the combination of background
    // and foreground overlay, we grab the pixels from the overlay
    // region of the offscreen image.
    int [] pixels = new int[patchWd * patchHt];
    PixelGrabber pg =
      new PixelGrabber (img, x, y, patchWd, patchHt, pixels, 0, patchWd);

    // The grabPixels method will cause the filling of the
    // pixels array.
    try {
      pg.grabPixels ();
    }
    catch (InterruptedException e) {
        System.err.println ("Interrupted while waiting for pixels!");
        return;
    }
    // Pixel filling isn't instantaneous so check here to
    // see that it finished.
    if ((pg.getStatus () & ImageObserver.ABORT) != 0) {
        System.err.println ("Image fetch abort or error occurred");
        return;
    }

    // Look at one of the pixels (they should all have the identical
    // value except perhaps at the edge.
    int color_value = pixels[pixels.length / 2];

    // Get the value in hex format and draw it at the center
    // of the panel.
    String color_value_str = Integer.toHexString (color_value);
    g.setColor(Color.BLACK);
    drawStringInCenter(g, color_value_str);

  } // paintComponent

  /** Use FontMetrics classes to draw a string at
    * the center of a panel.
   **/
  void drawStringInCenter(Graphics g, String msg) {

    // Create the font and pass it to the  Graphics context
    g.setFont (new Font ("Monospaced",Font.BOLD,18));

    // Get measures needed to center the message
    FontMetrics fm = g.getFontMetrics ();

    // How many pixels wide is the string
    int msg_width = fm.stringWidth (msg);

    // How far above the baseline can the font go?
    int ascent = fm.getMaxAscent ();

    // How far below the baseline?
    int descent= fm.getMaxDescent ();

    // Use the string width to find the starting point
    int msg_x = getSize ().width/2 - msg_width/2;

    // Use the vertical height of this font to find
    // the vertical starting coordinate
    int msg_y = getSize ().height/2 - descent/2 + ascent/2;

    g.drawString (msg, msg_x, msg_y);

   } // drawStringInCenter

} // class OutputPanel

1  2  3  4  5  6  7  8  9  10  11  12