Просмотр исходного текста страницы Java/SWT JFace Eclipse/2D

== Alpha Fade In ==






   
  <!-- start source code -->
   
    <source lang="java">
 
/******************************************************************************
 * All Right Reserved. 
 * Copyright (c) 1998, 2004 Jackwind Li Guojie
 * 
 * Created on 2004-4-21 22:36:43 by JACK
 * $Id$
 * 
 *****************************************************************************/

import org.eclipse.swt.SWT;
import org.eclipse.swt.events.PaintEvent;
import org.eclipse.swt.events.PaintListener;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.graphics.ImageData;
import org.eclipse.swt.layout.FillLayout;
import org.eclipse.swt.widgets.Canvas;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Shell;
public class AlphaFadeIn {
  Display display = new Display();
  Shell shell = new Shell(display);
  public AlphaFadeIn() {
    shell.setLayout(new FillLayout());
    final Canvas canvas = new Canvas(shell, SWT.NULL);
    
    ImageData imageData = new ImageData("jexp.gif");
    
    ImageData imageData2 = imageData.scaledTo(100, 100);
    Image image2 = new Image(display, imageData2);
    
    byte[] alphaValues = new byte[imageData.height * imageData.width];
    for(int j=0; j<imageData.height; j++) {
      for(int i=0; i<imageData.width; i++) {
        alphaValues[j*imageData.width + i] = (byte) (255 - 255 * i / imageData.width);
      }
    }
    
    
    
    imageData.alphaData = alphaValues;
    
    final Image image = new Image(display, imageData);
    
    canvas.addPaintListener(new PaintListener() {
      public void paintControl(PaintEvent e) {
        e.gc.drawImage(image, 10, 10);
      }
    });
    shell.setSize(200, 100);
    shell.open();
    //textUser.forceFocus();
    // Set up the event loop.
    while (!shell.isDisposed()) {
      if (!display.readAndDispatch()) {
        // If no more entries in event queue
        display.sleep();
      }
    }
    display.dispose();
  }
  private void init() {
  }
  public static void main(String[] args) {
    new AlphaFadeIn();
  }
}

           
         
  </source>
    
   
  <!-- end source code -->
   




== Animations Example ==






   
  <!-- start source code -->
   
    <source lang="java">
 

/*******************************************************************************
 * All Right Reserved. Copyright (c) 1998, 2004 Jackwind Li Guojie
 * 
 * Created on 2004-4-22 11:06:42 by JACK $Id$
 *  
 ******************************************************************************/

import org.eclipse.swt.SWT;
import org.eclipse.swt.events.PaintEvent;
import org.eclipse.swt.events.PaintListener;
import org.eclipse.swt.events.ShellAdapter;
import org.eclipse.swt.events.ShellEvent;
import org.eclipse.swt.events.ShellListener;
import org.eclipse.swt.graphics.GC;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.graphics.ImageData;
import org.eclipse.swt.graphics.ImageLoader;
import org.eclipse.swt.layout.FillLayout;
import org.eclipse.swt.widgets.Canvas;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Shell;
public class Animations {
  Display display = new Display();
  Shell shell = new Shell(display);
  public Animations() {
    shell.setLayout(new FillLayout());
    ImageLoader imageLoader = new ImageLoader();
    final ImageData[] imageDatas = imageLoader.load("jexp.gif");
    final Image image = new Image(display, imageDatas[0].width, imageDatas[0].height);
    final Canvas canvas = new Canvas(shell, SWT.NULL);
    canvas.addPaintListener(new PaintListener() {
      public void paintControl(PaintEvent e) {
        e.gc.drawImage(image, 0, 0);
      }
    });
    final GC gc = new GC(image);
    final Thread thread = new Thread() {
      int frameIndex = 0;
      public void run() {
        while (!isInterrupted()) {
          frameIndex %= imageDatas.length;
          final ImageData frameData = imageDatas[frameIndex];
          display.asyncExec(new Runnable() {
            public void run() {
              Image frame =
                new Image(display, frameData);
              gc.drawImage(frame, frameData.x, frameData.y);
              frame.dispose();
              canvas.redraw();
            }
          });
          
          try {
            // delay
            Thread.sleep(imageDatas[frameIndex].delayTime * 10);
          } catch (InterruptedException e) {
            return;
          }
          
          frameIndex += 1;
        }
        
      }
    };
    
    shell.addShellListener(new ShellAdapter() {
      public void shellClosed(ShellEvent e) {
        thread.interrupt();
      }
    });
    shell.setSize(400, 200);
    shell.open();
    
    thread.start();
    // Set up the event loop.
    while (!shell.isDisposed()) {
      if (!display.readAndDispatch()) {
        // If no more entries in event queue
        display.sleep();
      }
    }
    display.dispose();
  }
  private void init() {
  }
  public static void main(String[] args) {
    new Animations();
  }
}
           
         
  </source>
    
   
  <!-- end source code -->
   




== Class Analyzer ==






   
  <!-- start source code -->
   
    <source lang="java">
 
/*******************************************************************************
 * All Right Reserved. Copyright (c) 1998, 2004 Jackwind Li Guojie
 * 
 * Created on 2004-7-4 19:32:27 by JACK $Id$
 *  
 ******************************************************************************/
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import org.eclipse.draw2d.AbstractBorder;
import org.eclipse.draw2d.ChopboxAnchor;
import org.eclipse.draw2d.ColorConstants;
import org.eclipse.draw2d.Figure;
import org.eclipse.draw2d.Graphics;
import org.eclipse.draw2d.IFigure;
import org.eclipse.draw2d.Label;
import org.eclipse.draw2d.LightweightSystem;
import org.eclipse.draw2d.LineBorder;
import org.eclipse.draw2d.MouseListener;
import org.eclipse.draw2d.PolygonDecoration;
import org.eclipse.draw2d.PolylineConnection;
import org.eclipse.draw2d.ToolbarLayout;
import org.eclipse.draw2d.XYLayout;
import org.eclipse.draw2d.geometry.Insets;
import org.eclipse.draw2d.geometry.PointList;
import org.eclipse.draw2d.geometry.Rectangle;
import org.eclipse.jface.action.Action;
import org.eclipse.jface.dialogs.Dialog;
import org.eclipse.jface.dialogs.InputDialog;
import org.eclipse.jface.resource.ImageDescriptor;
import org.eclipse.jface.resource.ImageRegistry;
import org.eclipse.jface.window.ApplicationWindow;
import org.eclipse.swt.SWT;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.layout.FillLayout;
import org.eclipse.swt.widgets.Canvas;
import org.eclipse.swt.widgets.ruposite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.swt.widgets.Text;
class ClassFigure extends Figure {
  ImageRegistry registry = new ImageRegistry();
  // image keys.
  String KEY_CLASS = "class";
  String KEY_METHOD_PUBLIC = "method_public";
  String KEY_METHOD_DEFAULT = "method_default";
  String KEY_METHOD_PROTECTED = "method_protected";
  String KEY_METHOD_PRIVATE = "method_private";
  String KEY_FIELD_PUBLIC = "field_public";
  String KEY_FIELD_DEFAULT = "field_default";
  String KEY_FIELD_PROTECTED = "field_protected";
  String KEY_FIELD_PRIVATE = "field_private";
  String[] keys =
    {
      KEY_CLASS,
      KEY_METHOD_PUBLIC,
      KEY_METHOD_DEFAULT,
      KEY_METHOD_PROTECTED,
      KEY_METHOD_PRIVATE,
      KEY_FIELD_PUBLIC,
      KEY_FIELD_DEFAULT,
      KEY_FIELD_PROTECTED,
      KEY_FIELD_PRIVATE };
  public Box fieldBox = new Box();
  public Box methodBox = new Box();
  public ClassFigure(Class cls) {
    setLayoutManager(new ToolbarLayout());
    setBorder(new LineBorder(ColorConstants.black));
    setBackgroundColor(ColorConstants.yellow);
    setOpaque(true);
    for (int i = 0; i < keys.length; i++)
      registry.put(
        keys[i],
        ImageDescriptor.createFromFile(
          null,
          "icons/java/" + keys[i] + ".gif"));
    Label title = new Label(cls.getName(), registry.get(KEY_CLASS));
    add(title);
    add(fieldBox);
    add(methodBox);
    // fields.
    Field[] fields = cls.getDeclaredFields();
    for (int i = 0; i < fields.length; i++) {
      Field field = fields[i];
      Image image = null;
      if (Modifier.isPublic(field.getModifiers())) {
        image = registry.get(KEY_FIELD_PUBLIC);
      } else if (Modifier.isProtected(field.getModifiers())) {
        image = registry.get(KEY_FIELD_PROTECTED);
      } else if (Modifier.isPrivate(field.getModifiers())) {
        image = registry.get(KEY_FIELD_PRIVATE);
      } else {
        image = registry.get(KEY_FIELD_DEFAULT);
      }
      fieldBox.add(new Label(fields[i].getName(), image));
    }
    // fields.
    Method[] methods = cls.getDeclaredMethods();
    for (int i = 0; i < methods.length; i++) {
      Method method = methods[i];
      Image image = null;
      if (Modifier.isPublic(method.getModifiers())) {
        image = registry.get(KEY_METHOD_PUBLIC);
      } else if (Modifier.isProtected(method.getModifiers())) {
        image = registry.get(KEY_METHOD_PROTECTED);
      } else if (Modifier.isPrivate(method.getModifiers())) {
        image = registry.get(KEY_METHOD_PRIVATE);
      } else {
        image = registry.get(KEY_METHOD_DEFAULT);
      }
      methodBox.add(new Label(methods[i].getName(), image));
    }
  }
}
class Box extends Figure {
  public Box() {
    setBorder(new BoxBorder());
    ToolbarLayout toolbarLayout = new ToolbarLayout();
    toolbarLayout.setStretchMinorAxis(false);
    setLayoutManager(toolbarLayout);
  }
  private class BoxBorder extends AbstractBorder {
    /*
     * (non-Javadoc)
     * 
     * @see org.eclipse.draw2d.Border#getInsets(org.eclipse.draw2d.IFigure)
     */
    public Insets getInsets(IFigure figure) {
      return new Insets(1, 0, 0, 0);
    }
    /*
     * (non-Javadoc)
     * 
     * @see org.eclipse.draw2d.Border#paint(org.eclipse.draw2d.IFigure,
     *      org.eclipse.draw2d.Graphics,
     *      org.eclipse.draw2d.geometry.Insets)
     */
    public void paint(IFigure figure, Graphics graphics, Insets insets) {
      Rectangle rect = getPaintRectangle(figure, insets);
      graphics.drawLine(rect.getTopLeft(), rect.getTopRight());
    }
  }
}
/**
 *  
 */
public class ClassAnalyzer extends ApplicationWindow {
  Text className;
  Canvas canvas;
  Figure contents;
  XYLayout xyLayout;
  /**
   * @param parentShell
   */
  public ClassAnalyzer(Shell parentShell) {
    super(parentShell);
    addToolBar(SWT.NULL);
  }
  private void showClass(Class cls) {
    if (cls == null)
      return;
    // removes all existing items.
    contents.removeAll();
    // draws super class.
    Label sup = null;
    if (cls.getSuperclass() != null) {
      final Class superClass = cls.getSuperclass();
      sup = new Label(superClass.getName());
      sup.setBorder(new LineBorder());
      sup.setBackgroundColor(ColorConstants.lightGreen);
      sup.setOpaque(true);
      sup.addMouseListener(new MouseListener() {
        public void mousePressed(org.eclipse.draw2d.MouseEvent me) {
        }
        public void mouseReleased(org.eclipse.draw2d.MouseEvent me) {
        }
        public void mouseDoubleClicked(
          org.eclipse.draw2d.MouseEvent me) {
          showClass(superClass);
        }
      });
    }
    if (sup != null) {
      contents.add(sup);
      xyLayout.setConstraint(sup, new Rectangle(20, 20, -1, -1));
    }
    ClassFigure classFigure = new ClassFigure(cls);
    contents.add(classFigure);
    if (sup == null)
      xyLayout.setConstraint(classFigure, new Rectangle(20, 20, -1, -1));
    else
      xyLayout.setConstraint(
        classFigure,
        new Rectangle(20, sup.getBounds().height + 40, -1, -1));
    // adds connection.
    if (sup != null) {
      PolylineConnection connection = new PolylineConnection();
      ChopboxAnchor source = new ChopboxAnchor(classFigure);
      ChopboxAnchor target = new ChopboxAnchor(sup);
      connection.setSourceAnchor(source);
      connection.setTargetAnchor(target);
      PolygonDecoration decoration = new PolygonDecoration();
      PointList list = new PointList();
      list.addPoint(-2, -2);
      list.addPoint(0, 0);
      list.addPoint(-2, 2);
      decoration.setTemplate(list);
      connection.setTargetDecoration(decoration);
      contents.add(connection);
    }
    // resizes the shell.
    getShell().setSize(
      contents.getPreferredSize().width + 30,
      contents.getPreferredSize().height + 80);
  }
  /*
   * (non-Javadoc)
   * 
   * @see org.eclipse.jface.window.Window#createContents(org.eclipse.swt.widgets.ruposite)
   */
  protected Control createContents(Composite parent) {
    Composite composite = new Composite(parent, SWT.NULL);
    composite.setLayout(new FillLayout());
    canvas = new Canvas(composite, SWT.NULL);
    canvas.setBackground(getShell().getDisplay().getSystemColor(SWT.COLOR_WHITE));
    LightweightSystem lws = new LightweightSystem(canvas);
    contents = new Figure();
    xyLayout = new XYLayout();
    contents.setLayoutManager(xyLayout);
    lws.setContents(contents);
    showClass(this.getClass());
    // Creates tool bar items.
    getToolBarManager().add(new Action("Set class ...") {
      public void run() {
        InputDialog dialog =
          new InputDialog(
            getShell(),
            "",
            "Please enter the class name",
            "",
            null);
        if (dialog.open() != Dialog.OK)
          return;
        contents.removeAll();
        Class cls = null;
        try {
          cls = Class.forName(dialog.getValue());
        } catch (ClassNotFoundException e) {
          e.printStackTrace();
        }
        if (cls != null) {
          showClass(cls);
        }
      }
    });
    getToolBarManager().update(true);
    return composite;
  }
  public static void main(String[] args) {
    ClassAnalyzer window = new ClassAnalyzer(null);
    window.setBlockOnOpen(true);
    window.open();
    Display.getCurrent().dispose();
  }
}

           
         
  </source>
    
   
  <!-- end source code -->
   




== Demonstrates animation ==






   
  <!-- start source code -->
   
    <source lang="java">
 
//Send questions, comments, bug reports, etc. to the authors:
//Rob Warner (rwarner@interspatial.ru)
//Robert Harris (rbrt_harris@yahoo.ru)
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.*;
import org.eclipse.swt.graphics.*;
import org.eclipse.swt.layout.*;
import org.eclipse.swt.widgets.*;
/**
 * This class demonstrates animation.
 */
public class Animator {
  // The width (and height) of the image
  private static final int IMAGE_WIDTH = 100;
  // The timer interval in milliseconds
  private static final int TIMER_INTERVAL = 10;
  // The location of the "ball"
  private int x = 0;
  private int y = 0;
  // The direction the "ball" is moving
  private int directionX = 1;
  private int directionY = 1;
  // We draw everything on this canvas
  private Canvas canvas;
  /**
   * Runs the application
   */
  public void run() {
    final Display display = new Display();
    Shell shell = new Shell(display);
    shell.setText("Animator");
    createContents(shell);
    shell.open();
    // Set up the timer for the animation
    Runnable runnable = new Runnable() {
      public void run() {
        animate();
        display.timerExec(TIMER_INTERVAL, this);
      }
    };
    // Launch the timer
    display.timerExec(TIMER_INTERVAL, runnable);
    while (!shell.isDisposed()) {
      if (!display.readAndDispatch()) {
        display.sleep();
      }
    }
    // Kill the timer
    display.timerExec(-1, runnable);
    display.dispose();
  }
  /**
   * Creates the main window"s contents
   * 
   * @param shell the main window
   */
  private void createContents(final Shell shell) {
    shell.setLayout(new FillLayout());
    // Create the canvas for drawing
    canvas = new Canvas(shell, SWT.NO_BACKGROUND);
    canvas.addPaintListener(new PaintListener() {
      public void paintControl(PaintEvent event) {
        // Draw the background
        event.gc.fillRectangle(canvas.getBounds());
        // Set the color of the ball
        event.gc.setBackground(shell.getDisplay().getSystemColor(SWT.COLOR_RED));
        // Draw the ball
        event.gc.fillOval(x, y, IMAGE_WIDTH, IMAGE_WIDTH);
      }
    });
  }
  /**
   * Animates the next frame
   */
  public void animate() {
    // Determine the ball"s location
    x += directionX;
    y += directionY;
    // Determine out of bounds
    Rectangle rect = canvas.getClientArea();
    if (x < 0) {
      x = 0;
      directionX = 1;
    } else if (x > rect.width - IMAGE_WIDTH) {
      x = rect.width - IMAGE_WIDTH;
      directionX = -1;
    }
    if (y < 0) {
      y = 0;
      directionY = 1;
    } else if (y > rect.height - IMAGE_WIDTH) {
      y = rect.height - IMAGE_WIDTH;
      directionY = -1;
    }
    // Force a redraw
    canvas.redraw();
  }
  /**
   * The application entry point
   * 
   * @param args the command line arguments
   */
  public static void main(String[] args) {
    new Animator().run();
  }
}

           
         
  </source>
    
   
  <!-- end source code -->
   




== Demonstrates animation. It uses double buffering. ==






   
  <!-- start source code -->
   
    <source lang="java">
 
//Send questions, comments, bug reports, etc. to the authors:
//Rob Warner (rwarner@interspatial.ru)
//Robert Harris (rbrt_harris@yahoo.ru)
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.*;
import org.eclipse.swt.graphics.*;
import org.eclipse.swt.layout.*;
import org.eclipse.swt.widgets.*;
/**
 * This class demonstrates animation. It uses double buffering
 */
public class AnimatorDoubleBuffer {
  // The width (and height) of the image
  
  
  private static final int IMAGE_WIDTH = 100;
  // The timer interval in milliseconds
  private static final int TIMER_INTERVAL = 10;
  // The location of the "ball"
  private int x = 0;
  private int y = 0;
  // The direction the "ball" is moving
  private int directionX = 1;
  private int directionY = 1;
  // We draw everything on this canvas
  private Canvas canvas;
  /**
   * Runs the application
   */
  public void run() {
    final Display display = new Display();
    Shell shell = new Shell(display);
    shell.setText("Animator Double Buffer");
    createContents(shell);
    shell.open();
    // Set up the timer for the animation
    Runnable runnable = new Runnable() {
      public void run() {
        animate();
        display.timerExec(TIMER_INTERVAL, this);
      }
    };
    // Launch the timer
    display.timerExec(TIMER_INTERVAL, runnable);
    while (!shell.isDisposed()) {
      if (!display.readAndDispatch()) {
        display.sleep();
      }
    }
    // Kill the timer
    display.timerExec(-1, runnable);
    display.dispose();
  }
  /**
   * Creates the main window"s contents
   * 
   * @param shell the main window
   */
  private void createContents(final Shell shell) {
    shell.setLayout(new FillLayout());
    // Create the canvas for drawing
    canvas = new Canvas(shell, SWT.NO_BACKGROUND);
    canvas.addPaintListener(new PaintListener() {
      public void paintControl(PaintEvent event) {
        // Create the image to fill the canvas
        Image image = new Image(shell.getDisplay(), canvas.getBounds());
        // Set up the offscreen gc
        GC gcImage = new GC(image);
        // Draw the background
        gcImage.setBackground(event.gc.getBackground());
        gcImage.fillRectangle(image.getBounds());
        // Set the color of the ball
        gcImage.setBackground(shell.getDisplay().getSystemColor(SWT.COLOR_RED));
        // Draw the ball
        gcImage.fillOval(x, y, IMAGE_WIDTH, IMAGE_WIDTH);
        // Draw the offscreen buffer to the screen
        event.gc.drawImage(image, 0, 0);
        // Clean up
        image.dispose();
        gcImage.dispose();
      }
    });
  }
  /**
   * Animates the next frame
   */
  public void animate() {
    // Determine the ball"s location
    x += directionX;
    y += directionY;
    // Determine out of bounds
    Rectangle rect = canvas.getClientArea();
    if (x < 0) {
      x = 0;
      directionX = 1;
    } else if (x > rect.width - IMAGE_WIDTH) {
      x = rect.width - IMAGE_WIDTH;
      directionX = -1;
    }
    if (y < 0) {
      y = 0;
      directionY = 1;
    } else if (y > rect.height - IMAGE_WIDTH) {
      y = rect.height - IMAGE_WIDTH;
      directionY = -1;
    }
    // Force a redraw
    canvas.redraw();
  }
  /**
   * The application entry point
   * 
   * @param args the command line arguments
   */
  public static void main(String[] args) {
    new AnimatorDoubleBuffer().run();
  }
}

           
         
  </source>
    
   
  <!-- end source code -->
   




== Demonstrates drawing an Arc ==






   
  <!-- start source code -->
   
    <source lang="java">
 
//Send questions, comments, bug reports, etc. to the authors:
//Rob Warner (rwarner@interspatial.ru)
//Robert Harris (rbrt_harris@yahoo.ru)
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.*;
import org.eclipse.swt.layout.*;
import org.eclipse.swt.widgets.*;
/**
 * This class demonstrates drawing an Arc
 */
public class ArcExample {
  private Text txtWidth = null;
  private Text txtHeight = null;
  private Text txtBeginAngle = null;
  private Text txtAngle = null;
  /**
   * Runs the application
   */
  public void run() {
    Display display = new Display();
    Shell shell = new Shell(display);
    shell.setText("Arc Example");
    createContents(shell);
    shell.open();
    while (!shell.isDisposed()) {
      if (!display.readAndDispatch()) {
        display.sleep();
      }
    }
    display.dispose();
  }
  /**
   * Creates the main window"s contents
   * 
   * @param shell the main window
   */
  private void createContents(Shell shell) {
    shell.setLayout(new FillLayout(SWT.VERTICAL));
    // Create the composite that holds the input fields
    Composite widgetComposite = new Composite(shell, SWT.NONE);
    widgetComposite.setLayout(new GridLayout(2, false));
    // Create the input fields
    new Label(widgetComposite, SWT.NONE).setText("Width:");
    txtWidth = new Text(widgetComposite, SWT.BORDER);
    new Label(widgetComposite, SWT.NONE).setText("Height");
    txtHeight = new Text(widgetComposite, SWT.BORDER);
    new Label(widgetComposite, SWT.NONE).setText("Begin Angle:");
    txtBeginAngle = new Text(widgetComposite, SWT.BORDER);
    new Label(widgetComposite, SWT.NONE).setText("Angle:");
    txtAngle = new Text(widgetComposite, SWT.BORDER);
    // Create the button that launches the redraw
    Button button = new Button(widgetComposite, SWT.PUSH);
    button.setText("Redraw");
    shell.setDefaultButton(button);
    // Create the canvas to draw the arc on
    final Canvas drawingCanvas = new Canvas(shell, SWT.NONE);
    drawingCanvas.addPaintListener(new ArcExamplePaintListener());
    // Add a handler to redraw the arc when pressed
    button.addSelectionListener(new SelectionAdapter() {
      public void widgetSelected(SelectionEvent e) {
        drawingCanvas.redraw();
      }
    });
  }
  /**
   * This class gets the user input and draws the requested arc
   */
  private class ArcExamplePaintListener implements PaintListener {
    public void paintControl(PaintEvent e) {
      // Get the canvas for drawing and its dimensions
      Canvas canvas = (Canvas) e.widget;
      int x = canvas.getBounds().width;
      int y = canvas.getBounds().height;
      // Determine user input, defaulting everything to zero.
      // Any blank fields are converted to zero
      int width = 0;
      int height = 0;
      int begin = 0;
      int angle = 0;
      try {
        width = txtWidth.getText().length() == 0 ? 0 : Integer.parseInt(txtWidth
            .getText());
        height = txtHeight.getText().length() == 0 ? 0 : Integer
            .parseInt(txtHeight.getText());
        begin = txtBeginAngle.getText().length() == 0 ? 0 : Integer
            .parseInt(txtBeginAngle.getText());
        angle = txtAngle.getText().length() == 0 ? 0 : Integer.parseInt(txtAngle
            .getText());
      } catch (NumberFormatException ex) {
        // Any problems, reset them all to zero
        width = 0;
        height = 0;
        begin = 0;
        angle = 0;
      }
      // Set the drawing color to black
      e.gc.setBackground(e.display.getSystemColor(SWT.COLOR_BLACK));
      // Draw the arc, centered on the canvas
      e.gc
          .fillArc((x - width) / 2, (y - height) / 2, width, height, begin, angle);
    }
  }
  /**
   * The application entry point
   * 
   * @param args the command line arguments
   */
  public static void main(String[] args) {
    new ArcExample().run();
  }
}

           
         
  </source>
    
   
  <!-- end source code -->
   




== Demonstrates drawing lines ==






   
  <!-- start source code -->
   
    <source lang="java">
 
//Send questions, comments, bug reports, etc. to the authors:
//Rob Warner (rwarner@interspatial.ru)
//Robert Harris (rbrt_harris@yahoo.ru)
import org.eclipse.swt.*;
import org.eclipse.swt.events.*;
import org.eclipse.swt.widgets.*;
import org.eclipse.swt.layout.*;
/**
 * This class demonstrates drawing lines
 */
public class LineExample {
  /**
   * Runs the application
   */
  public void run() {
    Display display = new Display();
    Shell shell = new Shell(display);
    shell.setText("Line Example");
    createContents(shell);
    shell.open();
    while (!shell.isDisposed()) {
      if (!display.readAndDispatch()) {
        display.sleep();
      }
    }
    display.dispose();
  }
  /**
   * Creates the main window"s contents
   * 
   * @param shell the main window
   */
  private void createContents(Shell shell) {
    shell.setLayout(new FillLayout());
    // Create a canvas to draw on
    Canvas canvas = new Canvas(shell, SWT.NONE);
    // Add a handler to do the drawing
    canvas.addPaintListener(new PaintListener() {
      public void paintControl(PaintEvent e) {
        // Get the canvas and its size
        Canvas canvas = (Canvas) e.widget;
        int maxX = canvas.getSize().x;
        int maxY = canvas.getSize().y;
        // Calculate the middle
        int halfX = (int) maxX / 2;
        int halfY = (int) maxY / 2;
        // Set the drawing color to blue
        e.gc.setForeground(e.display.getSystemColor(SWT.COLOR_BLUE));
        // Set the width of the lines to draw
        e.gc.setLineWidth(10);
        // Draw a vertical line halfway across the canvas
        e.gc.drawLine(halfX, 0, halfX, maxY);
        // Draw a horizontal line halfway down the canvas
        e.gc.drawLine(0, halfY, maxX, halfY);
      }
    });
  }
  /**
   * The application entry point
   * 
   * @param args the command line arguments
   */
  public static void main(String[] args) {
    new LineExample().run();
  }
}

           
         
  </source>
    
   
  <!-- end source code -->
   




== Demonstrates drawing ovals ==






   
  <!-- start source code -->
   
    <source lang="java">
 
//Send questions, comments, bug reports, etc. to the authors:
//Rob Warner (rwarner@interspatial.ru)
//Robert Harris (rbrt_harris@yahoo.ru)
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.*;
import org.eclipse.swt.layout.*;
import org.eclipse.swt.widgets.*;
/**
 * This class demonstrates drawing ovals
 */
public class OvalExample {
  private Text txtWidth = null;
  private Text txtHeight = null;
  /**
   * Runs the application
   */
  public void run() {
    Display display = new Display();
    Shell shell = new Shell(display);
    shell.setText("Oval Example");
    createContents(shell);
    shell.open();
    while (!shell.isDisposed()) {
      if (!display.readAndDispatch()) {
        display.sleep();
      }
    }
    display.dispose();
  }
  /**
   * Creates the main window"s contents
   * 
   * @param shell the main window
   */
  private void createContents(Shell shell) {
    shell.setLayout(new FillLayout(SWT.VERTICAL));
    // Create the composite that holds the input fields
    Composite widgetComposite = new Composite(shell, SWT.NONE);
    widgetComposite.setLayout(new GridLayout(2, false));
    // Create the input fields
    new Label(widgetComposite, SWT.NONE).setText("Width:");
    txtWidth = new Text(widgetComposite, SWT.BORDER);
    new Label(widgetComposite, SWT.NONE).setText("Height");
    txtHeight = new Text(widgetComposite, SWT.BORDER);
    // Create the button that launches the redraw
    Button button = new Button(widgetComposite, SWT.PUSH);
    button.setText("Redraw");
    shell.setDefaultButton(button);
    // Create the canvas to draw the oval on
    final Canvas drawingCanvas = new Canvas(shell, SWT.NONE);
    drawingCanvas.addPaintListener(new OvalExamplePaintListener());
    // Add a handler to redraw the oval when pressed
    button.addSelectionListener(new SelectionAdapter() {
      public void widgetSelected(SelectionEvent e) {
        drawingCanvas.redraw();
      }
    });
  }
  /**
   * This class gets the user input and draws the requested oval
   */
  private class OvalExamplePaintListener implements PaintListener {
    public void paintControl(PaintEvent e) {
      // Get the canvas for drawing and its width and height
      Canvas canvas = (Canvas) e.widget;
      int x = canvas.getBounds().width;
      int y = canvas.getBounds().height;
      // Determine user input, defaulting everything to zero.
      // Any blank fields are converted to zero
      int width = 0;
      int height = 0;
      try {
        width = txtWidth.getText().length() == 0 ? 0 : Integer.parseInt(txtWidth
            .getText());
        height = txtHeight.getText().length() == 0 ? 0 : Integer
            .parseInt(txtHeight.getText());
      } catch (NumberFormatException ex) {
        // Any problems, set them both to zero
        width = 0;
        height = 0;
      }
      // Set the drawing width for the oval
      e.gc.setLineWidth(4);
      // Draw the requested oval
      e.gc.drawOval((x - width) / 2, (y - height) / 2, width, height);
    }
  }
  /**
   * The application entry point
   * 
   * @param args the command line arguments
   */
  public static void main(String[] args) {
    new OvalExample().run();
  }
}
           
         
  </source>
    
   
  <!-- end source code -->
   




== Demonstrates drawing points. It draws a sine wave ==






   
  <!-- start source code -->
   
    <source lang="java">
 

//Send questions, comments, bug reports, etc. to the authors:
//Rob Warner (rwarner@interspatial.ru)
//Robert Harris (rbrt_harris@yahoo.ru)
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.*;
import org.eclipse.swt.layout.FillLayout;
import org.eclipse.swt.widgets.*;
/**
 * This class demonstrates drawing points. It draws a sine wave.
 */
public class PointExample {
  /**
   * Runs the application
   */
  public void run() {
    Display display = new Display();
    Shell shell = new Shell(display);
    shell.setText("Point Example");
    createContents(shell);
    shell.open();
    while (!shell.isDisposed()) {
      if (!display.readAndDispatch()) {
        display.sleep();
      }
    }
    display.dispose();
  }
  /**
   * Creates the main window"s contents
   * 
   * @param shell the main window
   */
  private void createContents(Shell shell) {
    shell.setLayout(new FillLayout());
    // Create the canvas for drawing on
    Canvas canvas = new Canvas(shell, SWT.NONE);
    // Add the paint handler to draw the sine wave
    canvas.addPaintListener(new PointExamplePaintListener());
    // Use a white background
    canvas.setBackground(shell.getDisplay().getSystemColor(SWT.COLOR_WHITE));
  }
  /**
   * This class draws a sine wave using points
   */
  private class PointExamplePaintListener implements PaintListener {
    public void paintControl(PaintEvent e) {
      // Get the canvas and its dimensions
      Canvas canvas = (Canvas) e.widget;
      int maxX = canvas.getSize().x;
      int maxY = canvas.getSize().y;
      // Calculate the middle
      int halfX = (int) maxX / 2;
      int halfY = (int) maxY / 2;
      // Set the line color and draw a horizontal axis
      e.gc.setForeground(e.display.getSystemColor(SWT.COLOR_BLACK));
      e.gc.drawLine(0, halfY, maxX, halfY);
      // Draw the sine wave
      for (int i = 0; i < maxX; i++) {
        e.gc.drawPoint(i, getNormalizedSine(i, halfY, maxX));
      }
    }
    /**
     * Calculates the sine value
     * 
     * @param x the value along the x-axis
     * @param halfY the value of the y-axis
     * @param maxX the width of the x-axis
     * @return int
     */
    int getNormalizedSine(int x, int halfY, int maxX) {
      double piDouble = 2 * Math.PI;
      double factor = piDouble / maxX;
      return (int) (Math.sin(x * factor) * halfY + halfY);
    }
  }
  /**
   * The application entry point
   * 
   * @param args the command line arguments
   */
  public static void main(String[] args) {
    new PointExample().run();
  }
}
           
         
  </source>
    
   
  <!-- end source code -->
   




== Demonstrates drawing polygons ==






   
  <!-- start source code -->
   
    <source lang="java">
 
//Send questions, comments, bug reports, etc. to the authors:
//Rob Warner (rwarner@interspatial.ru)
//Robert Harris (rbrt_harris@yahoo.ru)
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.*;
import org.eclipse.swt.layout.*;
import org.eclipse.swt.widgets.*;
/**
 * This class demonstrates drawing polygons
 */
public class PolygonExample {
  private Text txtWidth = null;
  private Text txtHeight = null;
  /**
   * Runs the application
   */
  public void run() {
    Display display = new Display();
    Shell shell = new Shell(display);
    shell.setText("Polygon Example");
    createContents(shell);
    shell.open();
    while (!shell.isDisposed()) {
      if (!display.readAndDispatch()) {
        display.sleep();
      }
    }
    display.dispose();
  }
  /**
   * Creates the main window"s contents
   * 
   * @param shell the main window
   */
  private void createContents(Shell shell) {
    shell.setLayout(new FillLayout(SWT.VERTICAL));
    // Create the canvas to draw the polygons on
    Canvas drawingCanvas = new Canvas(shell, SWT.NONE);
    drawingCanvas.addPaintListener(new PolygonExamplePaintListener());
  }
  /**
   * This class gets the user input and draws the requested oval
   */
  private class PolygonExamplePaintListener implements PaintListener {
    public void paintControl(PaintEvent e) {
      // Get the canvas for drawing and its dimensions
      Canvas canvas = (Canvas) e.widget;
      int x = canvas.getBounds().width;
      int y = canvas.getBounds().height;
      // Set the drawing color
      e.gc.setBackground(e.display.getSystemColor(SWT.COLOR_BLACK));
      // Create the points for drawing a triangle in the upper left
      int[] upper_left = { 0, 0, 200, 0, 0, 200};
      // Create the points for drawing a triangle in the lower right
      int[] lower_right = { x, y, x, y - 200, x - 200, y};
      // Draw the triangles
      e.gc.fillPolygon(upper_left);
      e.gc.fillPolygon(lower_right);
    }
  }
  /**
   * The application entry point
   * 
   * @param args the command line arguments
   */
  public static void main(String[] args) {
    new PolygonExample().run();
  }
}
           
         
  </source>
    
   
  <!-- end source code -->
   




== Demonstrates how to draw text ==






   
  <!-- start source code -->
   
    <source lang="java">
 
//Send questions, comments, bug reports, etc. to the authors:
//Rob Warner (rwarner@interspatial.ru)
//Robert Harris (rbrt_harris@yahoo.ru)
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.*;
import org.eclipse.swt.graphics.*;
import org.eclipse.swt.widgets.*;
/**
 * This class demonstrates how to draw text
 */
public class DrawText {
  // The string to draw
  private static final String HELLO = "Hello,\n&World!\tFrom SWT";
  /**
   * Runs the application
   */
  public void run() {
    Display display = new Display();
    final Shell shell = new Shell(display);
    // Load an image to use as the background
    final Image image = new Image(display, this.getClass().getResourceAsStream(
        "jexp.gif"));
    shell.addPaintListener(new PaintListener() {
      public void paintControl(PaintEvent event) {
        /* Stretch the image to fill the window*/
        
        Rectangle rect = shell.getClientArea();
        event.gc.drawImage(image, 0, 0, image.getImageData().width, image
            .getImageData().height, 0, 0, rect.width, rect.height);
        // This will draw the string on one line, with non-printing characters
        // for \n and \t, with an ampersand, and with an opaque background
        event.gc.drawString(HELLO, 5, 0);
        // This will draw the string on one line, with non-printing characters
        // for \n and \t, with an ampersand, and with a transparent background
        event.gc.drawString(HELLO, 5, 40, true);
        // This will draw the string on two lines, with a tab between World! and
        // From, with an ampersand, and with an opaque background
        event.gc.drawText(HELLO, 5, 80);
        // This will draw the string on two lines, with a tab between World! and
        // From, with an ampersand, and with a transparent background
        event.gc.drawText(HELLO, 5, 120, true);
        // This will draw the string on two lines, with a tab between World! and
        // From, with the W underlined, and with a transparent background
        event.gc.drawText(HELLO, 5, 160, SWT.DRAW_MNEMONIC | SWT.DRAW_DELIMITER
            | SWT.DRAW_TAB | SWT.DRAW_TRANSPARENT);
      }
    });
    shell.setText("Draw Text");
    shell.open();
    while (!shell.isDisposed()) {
      if (!display.readAndDispatch()) {
        display.sleep();
      }
    }
    image.dispose();
    display.dispose();
  }
  /**
   * The application entry point
   * 
   * @param args the command line arguments
   */
  public static void main(String[] args) {
    new DrawText().run();
  }
}

           
         
  </source>
    
   
  <!-- end source code -->
   




== Demonstrates how to draw text in colors ==






   
  <!-- start source code -->
   
    <source lang="java">
 
//Send questions, comments, bug reports, etc. to the authors:
//Rob Warner (rwarner@interspatial.ru)
//Robert Harris (rbrt_harris@yahoo.ru)
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.*;
import org.eclipse.swt.widgets.*;
/**
 * This class demonstrates how to draw text in colors
 */
public class ColorFont {
  // The color indices to use for the text
  private static final int[] COLOR_INDICES = { SWT.COLOR_BLUE, SWT.COLOR_GREEN,
      SWT.COLOR_RED, SWT.COLOR_GRAY};
  /**
   * Runs the application
   */
  public void run() {
    Display display = new Display();
    final Shell shell = new Shell(display);
    // Handler to do the drawing
    shell.addPaintListener(new PaintListener() {
      public void paintControl(PaintEvent event) {
        // Loop through the colors, moving down the screen each iteration
        for (int i = 0, n = COLOR_INDICES.length, y = 0, height = event.gc
            .getFontMetrics().getHeight(); i < n; i++, y += height) {
          event.gc.setForeground(shell.getDisplay().getSystemColor(
              COLOR_INDICES[i]));
          event.gc.drawText("Hooray for Color!", 0, y);
        }
      }
    });
    shell.setText("Color Font");
    shell.open();
    while (!shell.isDisposed()) {
      if (!display.readAndDispatch()) {
        display.sleep();
      }
    }
    display.dispose();
  }
  /**
   * The application entry point
   * 
   * @param args the command line arguments
   */
  public static void main(String[] args) {
    new ColorFont().run();
  }
}
          
         
  </source>
    
   
  <!-- end source code -->
   




== Demonstrates how to draw vertical text ==






   
  <!-- start source code -->
   
    <source lang="java">
 
//Send questions, comments, bug reports, etc. to the authors:
//Rob Warner (rwarner@interspatial.ru)
//Robert Harris (rbrt_harris@yahoo.ru)
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.*;
import org.eclipse.swt.graphics.*;
import org.eclipse.swt.widgets.*;
/**
 * This class demonstrates how to draw vertical text
 */
public class VerticalTextSpanish {
  /**
   * Runs the application
   */
  public void run() {
    Display display = new Display();
    final Shell shell = new Shell(display);
    final Font font = new Font(display, "Arial", 36, SWT.ITALIC);
    // Create "Hello" image
    final Image hello = GraphicsUtils.createRotatedText("Hola", font, shell
        .getForeground(), shell.getBackground(), SWT.UP);
    // Create "Good Bye" image
    final Image goodBye = GraphicsUtils.createRotatedText("Chao Pescado", font,
        shell.getForeground(), shell.getBackground(), SWT.DOWN);
    shell.addPaintListener(new PaintListener() {
      public void paintControl(PaintEvent event) {
        // Set the font
        event.gc.setFont(font);
        // Draw hello in the upper left
        event.gc.drawImage(hello, 0, 0);
        // Draw good bye in the lower right
        // Note how we calculate the origin
        Rectangle rcImage = goodBye.getBounds();
        Rectangle rect = shell.getClientArea();
        event.gc.drawImage(goodBye, rect.width - rcImage.width, rect.height
            - rcImage.height);
      }
    });
    shell.setText("Vertical Text Spanish");
    shell.open();
    while (!shell.isDisposed()) {
      if (!display.readAndDispatch()) {
        display.sleep();
      }
    }
    goodBye.dispose();
    hello.dispose();
    font.dispose();
    display.dispose();
  }
  /**
   * The application entry point
   * 
   * @param args the command line arguments
   */
  public static void main(String[] args) {
    new VerticalTextSpanish().run();
  }
}
           
         
  </source>
    
   
  <!-- end source code -->
   




== Demonstrates the effects of the flags on the constructor ==






   
  <!-- start source code -->
   
    <source lang="java">
 
//Send questions, comments, bug reports, etc. to the authors:
//Rob Warner (rwarner@interspatial.ru)
//Robert Harris (rbrt_harris@yahoo.ru)
import org.eclipse.swt.*;
import org.eclipse.swt.graphics.*;
import org.eclipse.swt.layout.*;
import org.eclipse.swt.widgets.*;
/**
 * This class demonstrates the effects of the flags on the constructor:
 * 
 * <code>Image(Device device, Image srcImage, int flag)</code>
 */
public class ShowImageFlags {
  // Members to hold the images
  private Image image;
  private Image copy;
  private Image disable;
  private Image gray;
  /**
   * Runs the program
   */
  public void run() {
    Display display = new Display();
    Shell shell = new Shell(display);
    shell.setText("Show Image Flags");
    // Load the image
    image = new Image(display, this.getClass().getResourceAsStream(
        "jexp.gif"));
    // Create the duplicate image
    copy = new Image(display, image, SWT.IMAGE_COPY);
    // Create the disabled image
    disable = new Image(display, image, SWT.IMAGE_DISABLE);
    // Create the gray image
    gray = new Image(display, image, SWT.IMAGE_GRAY);
    createContents(shell);
    shell.pack();
    shell.open();
    while (!shell.isDisposed()) {
      if (!display.readAndDispatch()) {
        display.sleep();
      }
    }
    // Dispose the images
    image.dispose();
    copy.dispose();
    disable.dispose();
    gray.dispose();
    display.dispose();
  }
  /**
   * Creates the main window"s contents
   * 
   * @param shell the main window
   */
  private void createContents(Shell shell) {
    shell.setLayout(new FillLayout());
    // Create labels to hold each image
    new Label(shell, SWT.NONE).setImage(image);
    new Label(shell, SWT.NONE).setImage(copy);
    new Label(shell, SWT.NONE).setImage(disable);
    new Label(shell, SWT.NONE).setImage(gray);
  }
  /**
   * The application entry point
   * 
   * @param args the command line arguments
   */
  public static void main(String[] args) {
    new ShowImageFlags().run();
  }
}
           
         
  </source>
    
   
  <!-- end source code -->
   




== Displays information about the display device ==






   
  <!-- start source code -->
   
    <source lang="java">
 
//Send questions, comments, bug reports, etc. to the authors:
//Rob Warner (rwarner@interspatial.ru)
//Robert Harris (rbrt_harris@yahoo.ru)
import org.eclipse.swt.SWT;
import org.eclipse.swt.graphics.*;
import org.eclipse.swt.layout.*;
import org.eclipse.swt.widgets.*;
/**
 * This class displays information about the display device.
 */
public class ShowDevice {
  /**
   * Runs the application
   */
  public void run() {
    Display display = new Display();
    Shell shell = new Shell(display);
    shell.setText("Display Device");
    createContents(shell);
    shell.pack();
    shell.open();
    while (!shell.isDisposed()) {
      if (!display.readAndDispatch()) {
        display.sleep();
      }
    }
    display.dispose();
  }
  /**
   * Creates the main window"s contents
   * 
   * @param shell the main window
   */
  private void createContents(Shell shell) {
    shell.setLayout(new FillLayout());
    // Create a text box to hold the data
    Text text = new Text(shell, SWT.MULTI | SWT.H_SCROLL | SWT.V_SCROLL);
    // Get the display device
    Device device = shell.getDisplay();
    // Put its data into a buffer
    StringBuffer buf = new StringBuffer();
    buf.append("getBounds(): ").append(device.getBounds()).append("\n");
    buf.append("getClientArea(): ").append(device.getClientArea()).append("\n");
    buf.append("getDepth(): ").append(device.getDepth()).append("\n");
    buf.append("getDPI(): ").append(device.getDPI()).append("\n");
    // By setting warnings to true and then getting warnings, we know if the
    // current platform supports it
    device.setWarnings(true);
    buf.append("Warnings supported: ").append(device.getWarnings()).append("\n");
    // Put the collected information into the text box
    text.setText(buf.toString());
  }
  /**
   * The application entry point
   * 
   * @param args the command line arguments
   */
  public static void main(String[] args) {
    new ShowDevice().run();
  }
}

           
         
  </source>
    
   
  <!-- end source code -->
   




== Draw2D Sample ==






   
  <!-- start source code -->
   
    <source lang="java">
 
/******************************************************************************
 * All Right Reserved. 
 * Copyright (c) 1998, 2004 Jackwind Li Guojie
 * 
 * Created on 2004-7-3 17:22:26 by JACK
 * $Id$
 * 
 *****************************************************************************/
import org.eclipse.draw2d.Button;
import org.eclipse.draw2d.LightweightSystem;
import org.eclipse.jface.window.ApplicationWindow;
import org.eclipse.swt.SWT;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.layout.FillLayout;
import org.eclipse.swt.widgets.Canvas;
import org.eclipse.swt.widgets.ruposite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Shell;
public class Draw2DSample extends ApplicationWindow {
  /* (non-Javadoc)
   * @see org.eclipse.jface.window.ApplicationWindow#addToolBar(int)
   */
  protected void addToolBar(int style) {
    super.addToolBar(style);
  }
  /* (non-Javadoc)
   * @see org.eclipse.jface.window.Window#createContents(org.eclipse.swt.widgets.ruposite)
   */
  protected Control createContents(Composite parent) {
    Composite composite = new Composite(parent, SWT.NULL);
    composite.setLayout(new FillLayout());
    
    Canvas canvas = new Canvas(composite, SWT.NULL);
    
    LightweightSystem lws = new LightweightSystem(canvas);
    Button button = new Button("Button", new Image(getShell().getDisplay(), "jexp.gif"));
    lws.setContents(button);
    
    return composite;
  }
  /**
   * @param parentShell
   */
  public Draw2DSample(Shell parentShell) {
    super(parentShell);
  }
  public static void main(String[] args) {
    Draw2DSample window = new Draw2DSample(null);
    window.setBlockOnOpen(true);
    window.open();
  }
}
           
         
  </source>
    
   
  <!-- end source code -->
   




== Drawings ==






   
  <!-- start source code -->
   
    <source lang="java">
 
/******************************************************************************
 * All Right Reserved. 
 * Copyright (c) 1998, 2004 Jackwind Li Guojie
 * 
 * Created on 2004-4-18 18:33:36 by JACK
 * $Id$
 * 
 *****************************************************************************/

import org.eclipse.swt.SWT;
import org.eclipse.swt.events.PaintEvent;
import org.eclipse.swt.events.PaintListener;
import org.eclipse.swt.layout.FillLayout;
import org.eclipse.swt.widgets.Canvas;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Shell;
public class Drawings {
  Display display = new Display();
  Shell shell = new Shell(display);
  public Drawings() {
    shell.setLayout(new FillLayout());
    
    Canvas canvas = new Canvas(shell, SWT.BORDER);
    canvas.setBackground(display.getSystemColor(SWT.COLOR_WHITE));
    
    canvas.addPaintListener(new PaintListener() {
      public void paintControl(PaintEvent e) {
        
//        e.gc.drawString("SWT.LINE_SOLID (default)", 10, 10);
//        e.gc.drawString("SWT.LINE_DASH", 10, 30);
//        e.gc.drawString("SWT.LINE_DOT", 10, 50);
//        e.gc.drawString("SWT.LINE_DASHDOT", 10, 70);
//        e.gc.drawString("SWT.LINE_DASHDOTDOT", 10, 90);
//        e.gc.drawString("Line width = 1 (default)", 10, 120);
//        e.gc.drawString("Line width = 3", 10, 140);
//        
//        int start = 150;
//        e.gc.setLineWidth(1);
//        e.gc.setLineStyle(SWT.LINE_SOLID);
//        e.gc.drawLine(start, 15, start + 200, 15);
//        e.gc.setLineStyle(SWT.LINE_DASH);
//        e.gc.drawLine(start, 35, start + 200, 35);
//        e.gc.setLineStyle(SWT.LINE_DOT);
//        e.gc.drawLine(start, 55, start + 200, 55);
//        e.gc.setLineStyle(SWT.LINE_DASHDOT);
//        e.gc.drawLine(start, 75, start + 200, 75);
//        e.gc.setLineStyle(SWT.LINE_DASHDOTDOT);
//        e.gc.drawLine(start, 95, start + 200, 95);
//        
//        e.gc.setLineStyle(SWT.LINE_SOLID);
//        e.gc.drawLine(start, 125, start + 200, 125);
//        e.gc.setLineWidth(3);
//        e.gc.drawLine(start, 145, start + 200, 145);
        
        
//        int[] points = new int[3 * 2];
//        points[0] = 10; // The point at the top. 
//        points[1] = 10;
//        
//        points[2] = 10; // The point at the left bottom.
//        points[3] = 100;
//        
//        points[4] = 100; // the point at the right bottom
//        points[5] = 100;
//        
//        //e.gc.drawPolyline(points);
        
        e.gc.setLineStyle(SWT.LINE_SOLID);
        e.gc.setBackground(display.getSystemColor(SWT.COLOR_DARK_GREEN));
        e.gc.fillArc(10, 10, 200, 100, 0, -90);
        e.gc.setLineStyle(SWT.LINE_DOT);
        e.gc.drawLine(0, 60, 220, 60);
        e.gc.drawLine(110, 0, 110, 120);
      }
    });
    
    shell.pack();
    shell.open();
    //textUser.forceFocus();
    // Set up the event loop.
    while (!shell.isDisposed()) {
      if (!display.readAndDispatch()) {
        // If no more entries in event queue
        display.sleep();
      }
    }
    display.dispose();
  }
  private void init() {
  }
  public static void main(String[] args) {
    new Drawings();
  }
}

           
         
  </source>
    
   
  <!-- end source code -->
   




== Drawing with transformations, paths and alpha blending ==






   
  <!-- start source code -->
   
    <source lang="java">
 

/* 
 * Drawing with transformations, paths and alpha blending
 *
 * For a list of all SWT example snippets see
 * http://dev.eclipse.org/viewcvs/index.cgi/%7Echeckout%7E/platform-swt-home/dev.html#snippets
 */
import org.eclipse.swt.SWT;
import org.eclipse.swt.graphics.Font;
import org.eclipse.swt.graphics.FontData;
import org.eclipse.swt.graphics.GC;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.graphics.Path;
import org.eclipse.swt.graphics.Rectangle;
import org.eclipse.swt.graphics.Transform;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Event;
import org.eclipse.swt.widgets.Listener;
import org.eclipse.swt.widgets.Shell;
public class Snippet10 {
  public static void main(String[] args) {
    final Display display = new Display();
    final Shell shell = new Shell(display);
    shell.setText("Advanced Graphics");
    FontData fd = shell.getFont().getFontData()[0];
    final Font font = new Font(display, fd.getName(), 60, SWT.BOLD
        | SWT.ITALIC);
    final Image image = new Image(display, 640, 480);
    final Rectangle rect = image.getBounds();
    GC gc = new GC(image);
    gc.setBackground(display.getSystemColor(SWT.COLOR_RED));
    gc.fillOval(rect.x, rect.y, rect.width, rect.height);
    gc.dispose();
    shell.addListener(SWT.Paint, new Listener() {
      public void handleEvent(Event event) {
        GC gc = event.gc;
        Transform tr = new Transform(display);
        tr.translate(50, 120);
        tr.rotate(-30);
        gc.drawImage(image, 0, 0, rect.width, rect.height, 0, 0,
            rect.width / 2, rect.height / 2);
        gc.setAlpha(100);
        gc.setTransform(tr);
        Path path = new Path(display);
        path.addString("SWT", 0, 0, font);
        gc.setBackground(display.getSystemColor(SWT.COLOR_GREEN));
        gc.setForeground(display.getSystemColor(SWT.COLOR_BLUE));
        gc.fillPath(path);
        gc.drawPath(path);
        tr.dispose();
        path.dispose();
      }
    });
    shell.setSize(shell.ruputeSize(rect.width / 2, rect.height / 2));
    shell.open();
    while (!shell.isDisposed()) {
      if (!display.readAndDispatch())
        display.sleep();
    }
    image.dispose();
    font.dispose();
    display.dispose();
  }
}
           
         
  </source>
    
   
  <!-- end source code -->
   




== Draw lines and polygons with different cap and join styles ==






   
  <!-- start source code -->
   
    <source lang="java">
 

/*
 * Draw lines and polygons with different cap and join styles
 *
 * For a list of all SWT example snippets see
 * http://dev.eclipse.org/viewcvs/index.cgi/%7Echeckout%7E/platform-swt-home/dev.html#snippets
 */
import org.eclipse.swt.SWT;
import org.eclipse.swt.graphics.GC;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Event;
import org.eclipse.swt.widgets.Listener;
import org.eclipse.swt.widgets.Shell;
public class Snippet168 {
  public static void main(String[] args) {
    final Display display = new Display();
    Shell shell = new Shell(display);
    shell.addListener(SWT.Paint, new Listener() {
      public void handleEvent(Event event) {
        int x = 20, y = 20, w = 120, h = 60;
        GC gc = event.gc;
        gc.setForeground(display.getSystemColor(SWT.COLOR_BLUE));
        gc.setLineWidth(10);
        int[] caps = { SWT.CAP_FLAT, SWT.CAP_ROUND, SWT.CAP_SQUARE };
        for (int i = 0; i < caps.length; i++) {
          gc.setLineCap(caps[i]);
          gc.drawLine(x, y, x + w, y);
          y += 20;
        }
        int[] joins = { SWT.JOIN_BEVEL, SWT.JOIN_MITER, SWT.JOIN_ROUND };
        for (int i = 0; i < joins.length; i++) {
          gc.setLineJoin(joins[i]);
          gc
              .drawPolygon(new int[] { x, y, x + w / 2, y + h,
                  x + w, y });
          y += h + 20;
        }
      }
    });
    shell.open();
    while (!shell.isDisposed()) {
      if (!display.readAndDispatch())
        display.sleep();
    }
  }
}
           
         
  </source>
    
   
  <!-- end source code -->
   




== Draw Round Rectangle ==






   
  <!-- start source code -->
   
    <source lang="java">
 
//Send questions, comments, bug reports, etc. to the authors:
//Rob Warner (rwarner@interspatial.ru)
//Robert Harris (rbrt_harris@yahoo.ru)
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.*;
import org.eclipse.swt.layout.*;
import org.eclipse.swt.widgets.*;
public class RoundRectangleExample {
  private Text txtArcWidth = null;
  private Text txtArcHeight = null;
  /**
   * Runs the application
   */
  public void run() {
    Display display = new Display();
    Shell shell = new Shell(display);
    shell.setText("RoundRectangle Example");
    createContents(shell);
    shell.open();
    while (!shell.isDisposed()) {
      if (!display.readAndDispatch()) {
        display.sleep();
      }
    }
    display.dispose();
  }
  /**
   * Creates the main window"s contents
   * 
   * @param shell the main window
   */
  private void createContents(Shell shell) {
    shell.setLayout(new FillLayout(SWT.VERTICAL));
    // Create the composite that holds the input fields
    Composite widgetComposite = new Composite(shell, SWT.NONE);
    widgetComposite.setLayout(new GridLayout(2, false));
    // Create the input fields
    new Label(widgetComposite, SWT.NONE).setText("Arc Width:");
    txtArcWidth = new Text(widgetComposite, SWT.BORDER);
    new Label(widgetComposite, SWT.NONE).setText("Arc Height");
    txtArcHeight = new Text(widgetComposite, SWT.BORDER);
    // Create the button that launches the redraw
    Button button = new Button(widgetComposite, SWT.PUSH);
    button.setText("Redraw");
    shell.setDefaultButton(button);
    // Create the canvas to draw the round rectangle on
    final Canvas drawingCanvas = new Canvas(shell, SWT.NONE);
    drawingCanvas.addPaintListener(new RoundRectangleExamplePaintListener());
    // Add a handler to redraw the round rectangle when pressed
    button.addSelectionListener(new SelectionAdapter() {
      public void widgetSelected(SelectionEvent e) {
        drawingCanvas.redraw();
      }
    });
  }
  /**
   * This class gets the user input and draws the requested round rectangle
   */
  private class RoundRectangleExamplePaintListener implements PaintListener {
    public void paintControl(PaintEvent e) {
      // Get the canvas for drawing and its width and height
      Canvas canvas = (Canvas) e.widget;
      int x = canvas.getBounds().width;
      int y = canvas.getBounds().height;
      // Determine user input, defaulting everything to zero.
      // Any blank fields are converted to zero
      int arcWidth = 0;
      int arcHeight = 0;
      try {
        arcWidth = txtArcWidth.getText().length() == 0 ? 0 : Integer
            .parseInt(txtArcWidth.getText());
        arcHeight = txtArcWidth.getText().length() == 0 ? 0 : Integer
            .parseInt(txtArcHeight.getText());
      } catch (NumberFormatException ex) {
        // Any problems, set them both to zero
        arcWidth = 0;
        arcHeight = 0;
      }
      // Set the line width
      e.gc.setLineWidth(4);
      // Draw the round rectangle
      e.gc.drawRoundRectangle(10, 10, x - 20, y - 20, arcWidth, arcHeight);
    }
  }
  /**
   * The application entry point
   * 
   * @param args the command line arguments
   */
  public static void main(String[] args) {
    new RoundRectangleExample().run();
  }
}
           
         
  </source>
    
   
  <!-- end source code -->
   




== Draw Text Demo ==






   
  <!-- start source code -->
   
    <source lang="java">
 
/******************************************************************************
 * All Right Reserved. 
 * Copyright (c) 1998, 2004 Jackwind Li Guojie
 * 
 * Created on 2004-4-19 13:48:04 by JACK
 * $Id$
 * 
 *****************************************************************************/
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.PaintEvent;
import org.eclipse.swt.events.PaintListener;
import org.eclipse.swt.graphics.Font;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.graphics.Point;
import org.eclipse.swt.graphics.Rectangle;
import org.eclipse.swt.layout.FillLayout;
import org.eclipse.swt.widgets.Canvas;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Shell;
public class DrawTextDemo {
  Display display = new Display();
  Shell shell = new Shell(display);
  public DrawTextDemo() {
    shell.setLayout(new FillLayout());
    
    final Canvas canvas = new Canvas(shell, SWT.NO_BACKGROUND);
    
    final Image image = new Image(display, "jexp.gif");
    canvas.addPaintListener(new PaintListener() {
      public void paintControl(PaintEvent e) {
        Rectangle size = image.getBounds();
        // Draws the background image.
        e.gc.drawImage(image, 0, 0, size.width, size.height, 0, 0, canvas.getSize().x, canvas.getSize().y);
        
        Font font = new Font(display, "Tahoma", 18, SWT.BOLD);
        e.gc.setFont(font);
        e.gc.setForeground(display.getSystemColor(SWT.COLOR_WHITE));
        e.gc.setBackground(display.getSystemColor(SWT.COLOR_BLUE));
        String english = "SWT rocks!";
        String chinese = "\u4e2d\u6587\u6c49\u5b57\u6d4b\u8bd5";
        
        e.gc.drawString(english, 10, 10);
        e.gc.drawString(chinese, 10, 80, true);
        
        String text = "Text to be drawn in the center";
        Point textSize = e.gc.textExtent(text);
        e.gc.drawText(text, (canvas.getSize().x - textSize.x)/2, (canvas.getSize().y - textSize.y)/2);
        
        font.dispose();
      }
    });
    
    shell.setSize(300, 150);
    shell.open();
    //textUser.forceFocus();
    // Set up the event loop.
    while (!shell.isDisposed()) {
      if (!display.readAndDispatch()) {
        // If no more entries in event queue
        display.sleep();
      }
    }
    display.dispose();
  }
  private void init() {
  }
  public static void main(String[] args) {
    new DrawTextDemo();
  }
}
           
         
  </source>
    
   
  <!-- end source code -->
   




== GC Creation ==






   
  <!-- start source code -->
   
    <source lang="java">
 
/******************************************************************************
 * All Right Reserved. 
 * Copyright (c) 1998, 2004 Jackwind Li Guojie
 * 
 * Created on 2004-4-18 15:03:44 by JACK
 * $Id$
 * 
 *****************************************************************************/
import org.eclipse.swt.SWT;
import org.eclipse.swt.custom.CLabel;
import org.eclipse.swt.graphics.GC;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Shell;
/**
 * 
 */
public class GCCreation {
  Display display = new Display();
  Shell shell = new Shell(display);
  public GCCreation() {
    Image image = new Image(display, "jexp.gif");
    
    // Clones the image. 
    Image image2 = new Image(display, image.getImageData());
    // Draws an oval
    GC gc = new GC(image2);
    gc.setForeground(display.getSystemColor(SWT.COLOR_WHITE));
    gc.drawOval(10, 10, 90, 40);
    gc.dispose();
    
    CLabel label = new CLabel(shell, SWT.NULL);
    label.setImage(image);
    label.setBounds(10, 10, 130, 130);
    
    CLabel label2 = new CLabel(shell, SWT.NULL);
    label2.setImage(image2);
    label2.setBounds(150, 10, 130, 130);
    shell.pack();
    shell.open();
    //textUser.forceFocus();
    // Set up the event loop.
    while (!shell.isDisposed()) {
      if (!display.readAndDispatch()) {
        // If no more entries in event queue
        display.sleep();
      }
    }
    display.dispose();
  }

  public static void main(String[] args) {
    new GCCreation();
  }
}

           
         
  </source>
    
   
  <!-- end source code -->
   




== GC example: draw a thick line ==






   
  <!-- start source code -->
   
    <source lang="java">
 

/*
 * GC example snippet: draw a thick line
 *
 * For a list of all SWT example snippets see
 * http://dev.eclipse.org/viewcvs/index.cgi/%7Echeckout%7E/platform-swt-home/dev.html#snippets
 */
import org.eclipse.swt.graphics.GC;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Shell;
public class Snippet13 {
  public static void main(String[] args) {
    Display display = new Display();
    Shell shell = new Shell(display);
    shell.open();
    GC gc = new GC(shell);
    gc.setLineWidth(4);
    gc.drawRectangle(20, 20, 100, 100);
    gc.dispose();
    while (!shell.isDisposed()) {
      if (!display.readAndDispatch())
        display.sleep();
    }
    display.dispose();
  }
}
           
         
  </source>
    
   
  <!-- end source code -->
   




== GC: implement a simple scribble program ==






   
  <!-- start source code -->
   
    <source lang="java">
 

/*
 * GC example snippet: implement a simple scribble program
 *
 * For a list of all SWT example snippets see
 * http://dev.eclipse.org/viewcvs/index.cgi/%7Echeckout%7E/platform-swt-home/dev.html#snippets
 */
import org.eclipse.swt.SWT;
import org.eclipse.swt.graphics.GC;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Event;
import org.eclipse.swt.widgets.Listener;
import org.eclipse.swt.widgets.Shell;
public class Snippet66 {
  public static void main(String[] args) {
    Display display = new Display();
    final Shell shell = new Shell(display);
    Listener listener = new Listener() {
      int lastX = 0, lastY = 0;
      public void handleEvent(Event event) {
        switch (event.type) {
        case SWT.MouseMove:
          if ((event.stateMask & SWT.BUTTON1) == 0)
            break;
          GC gc = new GC(shell);
          gc.drawLine(lastX, lastY, event.x, event.y);
          gc.dispose();
        // FALL THROUGH
        case SWT.MouseDown:
          lastX = event.x;
          lastY = event.y;
          break;
        }
      }
    };
    shell.addListener(SWT.MouseDown, listener);
    shell.addListener(SWT.MouseMove, listener);
    shell.open();
    while (!shell.isDisposed()) {
      if (!display.readAndDispatch())
        display.sleep();
    }
    display.dispose();
  }
}
           
         
  </source>
    
   
  <!-- end source code -->
   




== GC: measure a string ==






   
  <!-- start source code -->
   
    <source lang="java">
 

/*
 * GC example snippet: measure a string
 *
 * For a list of all SWT example snippets see
 * http://dev.eclipse.org/viewcvs/index.cgi/%7Echeckout%7E/platform-swt-home/dev.html#snippets
 */
import org.eclipse.swt.SWT;
import org.eclipse.swt.graphics.GC;
import org.eclipse.swt.graphics.Point;
import org.eclipse.swt.layout.RowLayout;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Label;
import org.eclipse.swt.widgets.Shell;
public class Snippet93 {
  public static void main(String[] args) {
    Display display = new Display();
    Shell shell = new Shell(display);
    shell.setLayout(new RowLayout());
    Label label = new Label(shell, SWT.NONE);
    GC gc = new GC(label);
    Point size = gc.textExtent("Hello");
    gc.dispose();
    label.setText("Hello -> " + size);
    shell.pack();
    shell.open();
    while (!shell.isDisposed()) {
      if (!display.readAndDispatch())
        display.sleep();
    }
    display.dispose();
  }
}
           
         
  </source>
    
   
  <!-- end source code -->
   




== How to draw directly on an SWT Control ==






   
  <!-- start source code -->
   
    <source lang="java">
 
import java.util.ResourceBundle;
import org.eclipse.swt.events.DisposeEvent;
import org.eclipse.swt.events.DisposeListener;
import org.eclipse.swt.events.PaintEvent;
import org.eclipse.swt.events.PaintListener;
import org.eclipse.swt.graphics.Color;
import org.eclipse.swt.graphics.GC;
import org.eclipse.swt.graphics.Rectangle;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Shell;
/*
 * This example builds on HelloWorld1 and demonstrates how to draw directly
 * on an SWT Control.
 */
public class HelloWorld5 {
  public static void main(String[] args) {
    Display display = new Display();
    Shell shell = new HelloWorld5().open(display);
    while (!shell.isDisposed()) {
      if (!display.readAndDispatch())
        display.sleep();
    }
    display.dispose();
  }
  public Shell open(Display display) {
    final Color red = new Color(display, 0xFF, 0, 0);
    final Shell shell = new Shell(display);
    shell.addPaintListener(new PaintListener() {
      public void paintControl(PaintEvent event) {
        GC gc = event.gc;
        gc.setForeground(red);
        Rectangle rect = shell.getClientArea();
        gc.drawRectangle(rect.x + 10, rect.y + 10, rect.width - 20,
            rect.height - 20);
        gc.drawString("Hello_world", rect.x + 20,
            rect.y + 20);
      }
    });
    shell.addDisposeListener(new DisposeListener() {
      public void widgetDisposed(DisposeEvent e) {
        red.dispose();
      }
    });
    shell.open();
    return shell;
  }
}

           
         
  </source>
    
   
  <!-- end source code -->
   




== Palettes ==






   
  <!-- start source code -->
   
    <source lang="java">
 
/*******************************************************************************
 * All Right Reserved. Copyright (c) 1998, 2004 Jackwind Li Guojie
 * 
 * Created on 2004-4-21 20:12:55 by JACK $Id$
 *  
 ******************************************************************************/
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.PaintEvent;
import org.eclipse.swt.events.PaintListener;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.graphics.ImageData;
import org.eclipse.swt.graphics.PaletteData;
import org.eclipse.swt.graphics.RGB;
import org.eclipse.swt.layout.FillLayout;
import org.eclipse.swt.widgets.Canvas;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Shell;
public class Palettes {
  Display display = new Display();
  Shell shell = new Shell(display);
  public Palettes() {
    shell.setLayout(new FillLayout());
    PaletteData paletteData = new PaletteData(0xFF0000, 0x00FF00, 0x0000FF);
    ImageData imageData = new ImageData(100, 100, 24, paletteData);
    for (int i = 0; i < 100; i++) { // each column.
      for (int j = 0; j < 100; j++) { // each row.
        if (j < 30 || (i > 35 && i < 65))
          imageData.setPixel(i, j, 0xFF);
        else
          imageData.setPixel(i, j, 0xFFFF00);
      }
    }
    //    int pixelValue = imageData.getPixel(50, 50);
    //    int redComponent = pixelValue & imageData.palette.redMask;
    //    int greenComponent = pixelValue & imageData.palette.greenMask;
    //    int blueComponent = pixelValue & imageData.palette.blueMask;
    PaletteData paletteData2 =
      new PaletteData(new RGB[] { new RGB(0, 0, 255), // blue
      new RGB(255, 255, 0) // yellow
    });
    
    ImageData imageData2 = new ImageData(100, 100, 1, paletteData2);
    for (int i = 0; i < 100; i++) { // each column.
      for (int j = 0; j < 100; j++) { // each row.
        if (j < 30 || (i > 35 && i < 65))
          imageData2.setPixel(i, j, 0);
        else
          imageData2.setPixel(i, j, 1);
      }
    }
    
    System.out.println(imageData.palette.getRGB(imageData.getPixel(50, 50)));
    
    final Image image2 = new Image(display, imageData2);
    final Image image = new Image(display, imageData);
    final Canvas canvas = new Canvas(shell, SWT.NULL);
    canvas.setBackground(display.getSystemColor(SWT.COLOR_WHITE));
    canvas.addPaintListener(new PaintListener() {
      public void paintControl(PaintEvent e) {
        e.gc.drawImage(image2, 0, 0);
      }
    });
    shell.pack();
    shell.open();
    //textUser.forceFocus();
    // Set up the event loop.
    while (!shell.isDisposed()) {
      if (!display.readAndDispatch()) {
        // If no more entries in event queue
        display.sleep();
      }
    }
    display.dispose();
  }
  private void init() {
  }
  public static void main(String[] args) {
    new Palettes();
  }
}

           
         
  </source>
    
   
  <!-- end source code -->
   




== SWT 2D Chart: Flowchart ==






   
  <!-- start source code -->
   
    <source lang="java">
 
/*
SWT/JFace in Action
GUI Design with Eclipse 3.0
Matthew Scarpino, Stephen Holder, Stanford Ng, and Laurent Mihalkovic
ISBN: 1932394273
Publisher: Manning
*/
import java.util.Enumeration;
import java.util.Hashtable;
import org.eclipse.draw2d.AbstractConnectionAnchor;
import org.eclipse.draw2d.ColorConstants;
import org.eclipse.draw2d.ConnectionAnchor;
import org.eclipse.draw2d.Figure;
import org.eclipse.draw2d.FreeformLayeredPane;
import org.eclipse.draw2d.FreeformLayout;
import org.eclipse.draw2d.Graphics;
import org.eclipse.draw2d.IFigure;
import org.eclipse.draw2d.LightweightSystem;
import org.eclipse.draw2d.ManhattanConnectionRouter;
import org.eclipse.draw2d.MarginBorder;
import org.eclipse.draw2d.MouseEvent;
import org.eclipse.draw2d.MouseListener;
import org.eclipse.draw2d.MouseMotionListener;
import org.eclipse.draw2d.PolylineConnection;
import org.eclipse.draw2d.PolylineDecoration;
import org.eclipse.draw2d.geometry.Dimension;
import org.eclipse.draw2d.geometry.Point;
import org.eclipse.draw2d.geometry.PointList;
import org.eclipse.draw2d.geometry.PrecisionPoint;
import org.eclipse.draw2d.geometry.Rectangle;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Shell;
public class Flowchart {
  public static void main(String args[]) {
    Shell shell = new Shell();
    shell.setSize(200, 300);
    shell.open();
    shell.setText("Flowchart");
    LightweightSystem lws = new LightweightSystem(shell);
    ChartFigure flowchart = new ChartFigure();
    lws.setContents(flowchart);
    TerminatorFigure start = new TerminatorFigure();
    start.setName("Start");
    start.setBounds(new Rectangle(40, 20, 80, 20));
    DecisionFigure dec = new DecisionFigure();
    dec.setName("Should I?");
    dec.setBounds(new Rectangle(30, 60, 100, 60));
    ProcessFigure proc = new ProcessFigure();
    proc.setName("Do it!");
    proc.setBounds(new Rectangle(40, 140, 80, 40));
    TerminatorFigure stop = new TerminatorFigure();
    stop.setName("End");
    stop.setBounds(new Rectangle(40, 200, 80, 20));
    PathFigure path1 = new PathFigure();
    path1.setSourceAnchor(start.outAnchor);
    path1.setTargetAnchor(dec.inAnchor);
    PathFigure path2 = new PathFigure();
    path2.setSourceAnchor(dec.yesAnchor);
    path2.setTargetAnchor(proc.inAnchor);
    PathFigure path3 = new PathFigure();
    path3.setSourceAnchor(dec.noAnchor);
    path3.setTargetAnchor(stop.inAnchor);
    PathFigure path4 = new PathFigure();
    path4.setSourceAnchor(proc.outAnchor);
    path4.setTargetAnchor(stop.inAnchor);
    flowchart.add(start);
    flowchart.add(dec);
    flowchart.add(proc);
    flowchart.add(stop);
    flowchart.add(path1);
    flowchart.add(path2);
    flowchart.add(path3);
    flowchart.add(path4);
    new Dnd(start);
    new Dnd(proc);
    new Dnd(dec);
    new Dnd(stop);
    Display display = Display.getDefault();
    while (!shell.isDisposed()) {
      if (!display.readAndDispatch())
        display.sleep();
    }
  }
}
class ChartFigure extends FreeformLayeredPane {
  public ChartFigure() {
    setLayoutManager(new FreeformLayout());
    setBorder(new MarginBorder(5));
    setBackgroundColor(ColorConstants.white);
    setOpaque(true);
  }
}
class Dnd extends MouseMotionListener.Stub implements MouseListener {
  public Dnd(IFigure figure) {
    figure.addMouseMotionListener(this);
    figure.addMouseListener(this);
  }
  Point start;
  public void mouseReleased(MouseEvent e) {
  }
  public void mouseClicked(MouseEvent e) {
  }
  public void mouseDoubleClicked(MouseEvent e) {
  }
  public void mousePressed(MouseEvent e) {
    start = e.getLocation();
  }
  public void mouseDragged(MouseEvent e) {
    Point p = e.getLocation();
    Dimension d = p.getDifference(start);
    start = p;
    Figure f = ((Figure) e.getSource());
    f.setBounds(f.getBounds().getTranslated(d.width, d.height));
  }
}
class TerminatorFigure extends ActivityFigure {
  FixedAnchor inAnchor, outAnchor;
  public TerminatorFigure() {
    inAnchor = new FixedAnchor(this);
    inAnchor.place = new Point(1, 0);
    targetAnchors.put("in_term", inAnchor);
    outAnchor = new FixedAnchor(this);
    outAnchor.place = new Point(1, 2);
    sourceAnchors.put("out_term", outAnchor);
  }
  public void paintFigure(Graphics g) {
    Rectangle r = bounds;
    g.drawArc(r.x + r.width / 8, r.y, r.width / 4, r.height - 1, 90, 180);
    g.drawLine(r.x + r.width / 4, r.y, r.x + 3 * r.width / 4, r.y);
    g.drawLine(r.x + r.width / 4, r.y + r.height - 1,
        r.x + 3 * r.width / 4, r.y + r.height - 1);
    g.drawArc(r.x + 5 * r.width / 8, r.y, r.width / 4, r.height - 1, 270,
        180);
    g.drawText(message, r.x + 3 * r.width / 8, r.y + r.height / 8);
  }
}
class FixedAnchor extends AbstractConnectionAnchor {
  Point place;
  public FixedAnchor(IFigure owner) {
    super(owner);
  }
  public Point getLocation(Point loc) {
    Rectangle r = getOwner().getBounds();
    int x = r.x + place.x * r.width / 2;
    int y = r.y + place.y * r.height / 2;
    Point p = new PrecisionPoint(x, y);
    getOwner().translateToAbsolute(p);
    return p;
  }
}
class DecisionFigure extends ActivityFigure {
  FixedAnchor inAnchor, yesAnchor, noAnchor;
  public DecisionFigure() {
    inAnchor = new FixedAnchor(this);
    inAnchor.place = new Point(1, 0);
    targetAnchors.put("in_dec", inAnchor);
    noAnchor = new FixedAnchor(this);
    noAnchor.place = new Point(2, 1);
    sourceAnchors.put("no", noAnchor);
    yesAnchor = new FixedAnchor(this);
    yesAnchor.place = new Point(1, 2);
    sourceAnchors.put("yes", yesAnchor);
  }
  public void paintFigure(Graphics g) {
    Rectangle r = bounds;
    PointList pl = new PointList(4);
    pl.addPoint(r.x + r.width / 2, r.y);
    pl.addPoint(r.x, r.y + r.height / 2);
    pl.addPoint(r.x + r.width / 2, r.y + r.height - 1);
    pl.addPoint(r.x + r.width, r.y + r.height / 2);
    g.drawPolygon(pl);
    g.drawText(message, r.x + r.width / 4 + 5, r.y + 3 * r.height / 8);
    g.drawText("N", r.x + 7 * r.width / 8, r.y + 3 * r.height / 8);
    g.drawText("Y", r.x + r.width / 2 - 2, r.y + 3 * r.height / 4);
  }
}
class PathFigure extends PolylineConnection {
  public PathFigure() {
    setTargetDecoration(new PolylineDecoration());
    setConnectionRouter(new ManhattanConnectionRouter());
  }
}
class ProcessFigure extends ActivityFigure {
  FixedAnchor inAnchor, outAnchor;
  public ProcessFigure() {
    inAnchor = new FixedAnchor(this);
    inAnchor.place = new Point(1, 0);
    targetAnchors.put("in_proc", inAnchor);
    outAnchor = new FixedAnchor(this);
    outAnchor.place = new Point(1, 2);
    sourceAnchors.put("out_proc", outAnchor);
  }
  public void paintFigure(Graphics g) {
    Rectangle r = bounds;
    g.drawText(message, r.x + r.width / 4, r.y + r.height / 4);
    g.drawRectangle(r.x, r.y, r.width - 1, r.height - 1);
  }
}
abstract class ActivityFigure extends Figure {
  Rectangle r = new Rectangle();
  Hashtable targetAnchors = new Hashtable();
  Hashtable sourceAnchors = new Hashtable();
  String message = new String();
  public void setName(String msg) {
    message = msg;
    repaint();
  }
  public ConnectionAnchor ConnectionAnchorAt(Point p) {
    ConnectionAnchor closest = null;
    long min = Long.MAX_VALUE;
    Hashtable conn = getSourceConnectionAnchors();
    conn.putAll(getTargetConnectionAnchors());
    Enumeration e = conn.elements();
    while (e.hasMoreElements()) {
      ConnectionAnchor c = (ConnectionAnchor) e.nextElement();
      Point p2 = c.getLocation(null);
      long d = p.getDistance2(p2);
      if (d < min) {
        min = d;
        closest = c;
      }
    }
    return closest;
  }
  public ConnectionAnchor getSourceConnectionAnchor(String name) {
    return (ConnectionAnchor) sourceAnchors.get(name);
  }
  public ConnectionAnchor getTargetConnectionAnchor(String name) {
    return (ConnectionAnchor) targetAnchors.get(name);
  }
  public String getSourceAnchorName(ConnectionAnchor c) {
    Enumeration e = sourceAnchors.keys();
    String name;
    while (e.hasMoreElements()) {
      name = (String) e.nextElement();
      if (sourceAnchors.get(name).equals(c))
        return name;
    }
    return null;
  }
  public String getTargetAnchorName(ConnectionAnchor c) {
    Enumeration e = targetAnchors.keys();
    String name;
    while (e.hasMoreElements()) {
      name = (String) e.nextElement();
      if (targetAnchors.get(name).equals(c))
        return name;
    }
    return null;
  }
  public ConnectionAnchor getSourceConnectionAnchorAt(Point p) {
    ConnectionAnchor closest = null;
    long min = Long.MAX_VALUE;
    Enumeration e = getSourceConnectionAnchors().elements();
    while (e.hasMoreElements()) {
      ConnectionAnchor c = (ConnectionAnchor) e.nextElement();
      Point p2 = c.getLocation(null);
      long d = p.getDistance2(p2);
      if (d < min) {
        min = d;
        closest = c;
      }
    }
    return closest;
  }
  public Hashtable getSourceConnectionAnchors() {
    return sourceAnchors;
  }
  public ConnectionAnchor getTargetConnectionAnchorAt(Point p) {
    ConnectionAnchor closest = null;
    long min = Long.MAX_VALUE;
    Enumeration e = getTargetConnectionAnchors().elements();
    while (e.hasMoreElements()) {
      ConnectionAnchor c = (ConnectionAnchor) e.nextElement();
      Point p2 = c.getLocation(null);
      long d = p.getDistance2(p2);
      if (d < min) {
        min = d;
        closest = c;
      }
    }
    return closest;
  }
  public Hashtable getTargetConnectionAnchors() {
    return targetAnchors;
  }
}
class FigureFactory {
  public static IFigure createTerminatorFigure() {
    return new TerminatorFigure();
  }
  public static IFigure createDecisionFigure() {
    return new DecisionFigure();
  }
  public static IFigure createProcessFigure() {
    return new ProcessFigure();
  }
  public static PathFigure createPathFigure() {
    return new PathFigure();
  }
  public static ChartFigure createChartFigure() {
    return new ChartFigure();
  }
}

           
         
  </source>
    
   
  <!-- end source code -->
   




== SWT 2D Simple Demo ==






   
  <!-- start source code -->
   
    <source lang="java">
 
/*******************************************************************************
 * Copyright (c) 2004 Berthold Daum. All rights reserved. This program and the
 * accompanying materials are made available under the terms of the Common
 * Public License v1.0 which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/cpl-v10.html
 * 
 * Contributors: Berthold Daum
 ******************************************************************************/
import java.awt.RenderingHints;
import java.util.ArrayList;
import java.util.Iterator;
import org.eclipse.swt.SWT;
import org.eclipse.swt.awt.SWT_AWT;
import org.eclipse.swt.events.PaintEvent;
import org.eclipse.swt.events.PaintListener;
import org.eclipse.swt.events.SelectionAdapter;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.graphics.Point;
import org.eclipse.swt.layout.FillLayout;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.ruposite;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.swt.widgets.Text;
public class SWT2D {
  // Shell fur Popup-Editor
  Shell eShell = null;
  // Text-Widget fur Editor
  Text eText = null;
  // Liste eingegebener Zeichenketten
  ArrayList wordList = new ArrayList(12);
  public static void main(String[] args) {
    SWT2D swtawt = new SWT2D();
    swtawt.run();
  }
  private void run() {
    // Create top level shell
    final Display display = new Display();
    final Shell shell = new Shell(display);
    shell.setText("Java 2D Example");
    // GridLayout for canvas and button
    shell.setLayout(new GridLayout());
    // Create container for AWT canvas
    final Composite canvasComp = new Composite(shell, SWT.EMBEDDED);
    // Set preferred size
    GridData data = new GridData();
    data.widthHint = 600;
    data.heightHint = 500;
    canvasComp.setLayoutData(data);
    // Create AWT Frame for Canvas
    java.awt.Frame canvasFrame = SWT_AWT.new_Frame(canvasComp);
    // Create Canvas and add it to the Frame
    final java.awt.Canvas canvas = new java.awt.Canvas();
    canvasFrame.add(canvas);
    // Get graphical context and cast to Java2D
    final java.awt.Graphics2D g2d = (java.awt.Graphics2D) canvas
        .getGraphics();
    // Enable antialiasing
    g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
        RenderingHints.VALUE_ANTIALIAS_ON);
    // Remember initial transform
    final java.awt.geom.AffineTransform origTransform = g2d.getTransform();
    // Create Clear button and position it
    Button clearButton = new Button(shell, SWT.PUSH);
    clearButton.setText("Clear");
    data = new GridData();
    data.horizontalAlignment = GridData.CENTER;
    clearButton.setLayoutData(data);
    // Event processing for Clear button
    clearButton.addSelectionListener(new SelectionAdapter() {
      public void widgetSelected(SelectionEvent e) {
        // Delete word list and redraw canvas
        wordList.clear();
        canvasComp.redraw();
      }
    });
    // Process canvas mouse clicks
    canvas.addMouseListener(new java.awt.event.MouseListener() {
      public void mouseClicked(java.awt.event.MouseEvent e) {
      }
      public void mouseEntered(java.awt.event.MouseEvent e) {
      }
      public void mouseExited(java.awt.event.MouseEvent e) {
      }
      public void mousePressed(java.awt.event.MouseEvent e) {
        // Manage pop-up editor
        display.syncExec(new Runnable() {
          public void run() {
            if (eShell == null) {
              // Create new Shell: non-modal!
              eShell = new Shell(shell, SWT.NO_TRIM
                  | SWT.MODELESS);
              eShell.setLayout(new FillLayout());
              // Text input field
              eText = new Text(eShell, SWT.BORDER);
              eText.setText("Text rotation in the SWT?");
              eShell.pack();
              // Set position (Display coordinates)
              java.awt.Rectangle bounds = canvas.getBounds();
              org.eclipse.swt.graphics.Point pos = canvasComp
                  .toDisplay(bounds.width / 2,
                      bounds.height / 2);
              Point size = eShell.getSize();
              eShell.setBounds(pos.x, pos.y, size.x, size.y);
              // Open Shell
              eShell.open();
            } else if (!eShell.isVisible()) {
              // Editor versteckt, sichtbar machen
              eShell.setVisible(true);
            } else {
              // Editor is visible - get text
              String t = eText.getText();
              // set editor invisible
              eShell.setVisible(false);
              // Add text to list and redraw canvas
              wordList.add(t);
              canvasComp.redraw();
            }
          }
        });
      }
      public void mouseReleased(java.awt.event.MouseEvent e) {
      }
    });
    // Redraw the canvas
    canvasComp.addPaintListener(new PaintListener() {
      public void paintControl(PaintEvent e) {
        // Pass the redraw task to AWT event queue
        java.awt.EventQueue.invokeLater(new Runnable() {
          public void run() {
            // Compute canvas center
            java.awt.Rectangle bounds = canvas.getBounds();
            int originX = bounds.width / 2;
            int originY = bounds.height / 2;
            // Reset canvas
            g2d.setTransform(origTransform);
            g2d.setColor(java.awt.Color.WHITE);
            g2d.fillRect(0, 0, bounds.width, bounds.height);
            // Set font
            g2d.setFont(new java.awt.Font("Myriad",
                java.awt.Font.PLAIN, 32));
            double angle = 0d;
            // Prepare star shape
            double increment = Math.toRadians(30);
            Iterator iter = wordList.iterator();
            while (iter.hasNext()) {
              // Determine text colors in RGB color cycle
              float red = (float) (0.5 + 0.5 * Math.sin(angle));
              float green = (float) (0.5 + 0.5 * Math.sin(angle
                  + Math.toRadians(120)));
              float blue = (float) (0.5 + 0.5 * Math.sin(angle
                  + Math.toRadians(240)));
              g2d.setColor(new java.awt.Color(red, green, blue));
              // Redraw text
              String text = (String) iter.next();
              g2d.drawString(text, originX + 50, originY);
              // Rotate for next text output
              g2d.rotate(increment, originX, originY);
              angle += increment;
            }
          }
        });
      }
    });
    // Finish shell and open it
    shell.pack();
    shell.open();
    // SWT event processing
    while (!shell.isDisposed()) {
      if (!display.readAndDispatch())
        display.sleep();
    }
    display.dispose();
  }
}

           
         
  </source>
    
   
  <!-- end source code -->
   




== SWT 2D Unicode ==






   
  <!-- start source code -->
   
    <source lang="java">
 
/*
 * -----------------------------------------------------------------------------
 * (c) Copyright IBM Corp. 2004 All rights reserved.
 * 
 * The sample program(s) is/are owned by International Business Machines
 * Corporation or one of its subsidiaries ("IBM") and is/are copyrighted and
 * licensed, not sold.
 * 
 * You may copy, modify, and distribute this/these sample program(s) in any form
 * without payment to IBM, for any purpose including developing, using,
 * marketing or distributing programs that include or are derivative works of
 * the sample program(s).
 * 
 * The sample program(s) is/are provided to you on an "AS IS" basis, without
 * warranty of any kind. IBM HEREBY EXPRESSLY DISCLAIMS ALL WARRANTIES, EITHER
 * EXPRESS OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. Some jurisdictions do
 * not allow for the exclusion or limitation of implied warranties, so the above
 * limitations or exclusions may not apply to you. IBM shall not be liable for
 * any damages you suffer as a result of using, modifying or distributing the
 * sample program(s) or its/their derivatives.
 * 
 * Each copy of any portion of this/these sample program(s) or any derivative
 * work, must include the above copyright notice and disclaimer of warranty.
 * 
 * -----------------------------------------------------------------------------
 */
import java.awt.GradientPaint;
import java.awt.Graphics2D;
import java.awt.RenderingHints;
import java.awt.image.BufferedImage;
import org.eclipse.draw2d.Figure;
import org.eclipse.draw2d.IFigure;
import org.eclipse.draw2d.LightweightSystem;
import org.eclipse.draw2d.geometry.Dimension;
import org.eclipse.swt.graphics.GC;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.graphics.ImageData;
import org.eclipse.swt.graphics.PaletteData;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Shell;
public class Draw2DTest {
  public static void main(String[] args) {
    final Graphics2DRenderer renderer = new Graphics2DRenderer();
    Shell shell = new Shell();
    shell.setSize(350, 350);
    shell.open();
    shell.setText("Draw2d Hello World");
    LightweightSystem lws = new LightweightSystem(shell);
    IFigure figure = new Figure() {
      protected void paintClientArea(org.eclipse.draw2d.Graphics graphics) {
        Dimension controlSize = getSize();
        renderer.prepareRendering(graphics);
        // prepares the Graphics2D renderer
        // gets the Graphics2D context and switch on the antialiasing
        Graphics2D g2d = renderer.getGraphics2D();
        g2d.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING,
            RenderingHints.VALUE_TEXT_ANTIALIAS_ON);
        // paints the background with a color gradient
        g2d.setPaint(new GradientPaint(0.0f, 0.0f,
            java.awt.Color.yellow, (float) controlSize.width,
            (float) controlSize.width, java.awt.Color.white));
        g2d.fillRect(0, 0, controlSize.width, controlSize.width);
        // draws rotated text
        g2d.setFont(new java.awt.Font("SansSerif", java.awt.Font.BOLD,
            16));
        g2d.setColor(java.awt.Color.blue);
        g2d.translate(controlSize.width / 2, controlSize.width / 2);
        int nbOfSlices = 18;
        for (int i = 0; i < nbOfSlices; i++) {
          g2d.drawString("Angle = " + (i * 360 / nbOfSlices)
              + "\u00B0", 30, 0);
          g2d.rotate(-2 * Math.PI / nbOfSlices);
        }
        // now that we are done with Java2D, renders Graphics2D
        // operation
        // on the SWT graphics context
        renderer.render(graphics);
        // now we can continue with pure SWT paint operations
        graphics.drawOval(0, 0, controlSize.width, controlSize.width);
      }
    };
    lws.setContents(figure);
    Display display = Display.getDefault();
    while (!shell.isDisposed()) {
      if (!display.readAndDispatch())
        display.sleep();
    }
    renderer.dispose();
  }
}
/*
 * -----------------------------------------------------------------------------
 * (c) Copyright IBM Corp. 2004 All rights reserved.
 * 
 * The sample program(s) is/are owned by International Business Machines
 * Corporation or one of its subsidiaries ("IBM") and is/are copyrighted and
 * licensed, not sold.
 * 
 * You may copy, modify, and distribute this/these sample program(s) in any form
 * without payment to IBM, for any purpose including developing, using,
 * marketing or distributing programs that include or are derivative works of
 * the sample program(s).
 * 
 * The sample program(s) is/are provided to you on an "AS IS" basis, without
 * warranty of any kind. IBM HEREBY EXPRESSLY DISCLAIMS ALL WARRANTIES, EITHER
 * EXPRESS OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. Some jurisdictions do
 * not allow for the exclusion or limitation of implied warranties, so the above
 * limitations or exclusions may not apply to you. IBM shall not be liable for
 * any damages you suffer as a result of using, modifying or distributing the
 * sample program(s) or its/their derivatives.
 * 
 * Each copy of any portion of this/these sample program(s) or any derivative
 * work, must include the above copyright notice and disclaimer of warranty.
 * 
 * -----------------------------------------------------------------------------
 */
/**
 * Helper class allowing the use of Java2D on SWT or Draw2D graphical context.
 * 
 * @author Yannick Saillet
 */
class Graphics2DRenderer {
  private static final PaletteData PALETTE_DATA = new PaletteData(0xFF0000,
      0xFF00, 0xFF);
  private BufferedImage awtImage;
  private Image swtImage;
  private ImageData swtImageData;
  private int[] awtPixels;
  /** RGB value to use as transparent color */
  private static final int TRANSPARENT_COLOR = 0x123456;
  /**
   * Prepare to render on a SWT graphics context.
   */
  public void prepareRendering(GC gc) {
    org.eclipse.swt.graphics.Rectangle clip = gc.getClipping();
    prepareRendering(clip.x, clip.y, clip.width, clip.height);
  }
  /**
   * Prepare to render on a Draw2D graphics context.
   */
  public void prepareRendering(org.eclipse.draw2d.Graphics graphics) {
    org.eclipse.draw2d.geometry.Rectangle clip = graphics
        .getClip(new org.eclipse.draw2d.geometry.Rectangle());
    prepareRendering(clip.x, clip.y, clip.width, clip.height);
  }
  /**
   * Prepare the AWT offscreen image for the rendering of the rectangular
   * region given as parameter.
   */
  private void prepareRendering(int clipX, int clipY, int clipW, int clipH) {
    // check that the offscreen images are initialized and large enough
    checkOffScreenImages(clipW, clipH);
    // fill the region in the AWT image with the transparent color
    java.awt.Graphics awtGraphics = awtImage.getGraphics();
    awtGraphics.setColor(new java.awt.Color(TRANSPARENT_COLOR));
    awtGraphics.fillRect(clipX, clipY, clipW, clipH);
  }
  /**
   * Returns the Graphics2D context to use.
   */
  public Graphics2D getGraphics2D() {
    if (awtImage == null)
      return null;
    return (Graphics2D) awtImage.getGraphics();
  }
  /**
   * Complete the rendering by flushing the 2D renderer on a SWT graphical
   * context.
   */
  public void render(GC gc) {
    if (awtImage == null)
      return;
    org.eclipse.swt.graphics.Rectangle clip = gc.getClipping();
    transferPixels(clip.x, clip.y, clip.width, clip.height);
    gc.drawImage(swtImage, clip.x, clip.y, clip.width, clip.height, clip.x,
        clip.y, clip.width, clip.height);
  }
  /**
   * Complete the rendering by flushing the 2D renderer on a Draw2D graphical
   * context.
   */
  public void render(org.eclipse.draw2d.Graphics graphics) {
    if (awtImage == null)
      return;
    org.eclipse.draw2d.geometry.Rectangle clip = graphics
        .getClip(new org.eclipse.draw2d.geometry.Rectangle());
    transferPixels(clip.x, clip.y, clip.width, clip.height);
    graphics.drawImage(swtImage, clip.x, clip.y, clip.width, clip.height,
        clip.x, clip.y, clip.width, clip.height);
  }
  /**
   * Transfer a rectangular region from the AWT image to the SWT image.
   */
  private void transferPixels(int clipX, int clipY, int clipW, int clipH) {
    int step = swtImageData.depth / 8;
    byte[] data = swtImageData.data;
    awtImage.getRGB(clipX, clipY, clipW, clipH, awtPixels, 0, clipW);
    for (int i = 0; i < clipH; i++) {
      int idx = (clipY + i) * swtImageData.bytesPerLine + clipX * step;
      for (int j = 0; j < clipW; j++) {
        int rgb = awtPixels[j + i * clipW];
        for (int k = swtImageData.depth - 8; k >= 0; k -= 8) {
          data[idx++] = (byte) ((rgb >> k) & 0xFF);
        }
      }
    }
    if (swtImage != null)
      swtImage.dispose();
    swtImage = new Image(Display.getDefault(), swtImageData);
  }
  /**
   * Dispose the resources attached to this 2D renderer.
   */
  public void dispose() {
    if (awtImage != null)
      awtImage.flush();
    if (swtImage != null)
      swtImage.dispose();
    awtImage = null;
    swtImageData = null;
    awtPixels = null;
  }
  /**
   * Ensure that the offscreen images are initialized and are at least as
   * large as the size given as parameter.
   */
  private void checkOffScreenImages(int width, int height) {
    int currentImageWidth = 0;
    int currentImageHeight = 0;
    if (swtImage != null) {
      currentImageWidth = swtImage.getImageData().width;
      currentImageHeight = swtImage.getImageData().height;
    }
    // if the offscreen images are too small, recreate them
    if (width > currentImageWidth || height > currentImageHeight) {
      dispose();
      width = Math.max(width, currentImageWidth);
      height = Math.max(height, currentImageHeight);
      awtImage = new BufferedImage(width, height,
          BufferedImage.TYPE_INT_ARGB);
      swtImageData = new ImageData(width, height, 24, PALETTE_DATA);
      swtImageData.transparentPixel = TRANSPARENT_COLOR;
      awtPixels = new int[width * height];
    }
  }
}

           
         
  </source>
    
   
  <!-- end source code -->
   




== SWT Draw 2D ==






   
  <!-- start source code -->
   
    <source lang="java">
 
/*
SWT/JFace in Action
GUI Design with Eclipse 3.0
Matthew Scarpino, Stephen Holder, Stanford Ng, and Laurent Mihalkovic
ISBN: 1932394273
Publisher: Manning
*/

import org.eclipse.swt.SWT;
import org.eclipse.swt.graphics.GC;
import org.eclipse.swt.widgets.Canvas;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Shell;
public class DrawExample {
  public static void main(String[] args) {
    Display display = new Display();
    Shell shell = new Shell(display);
    shell.setText("Drawing Example");
    Canvas canvas = new Canvas(shell, SWT.NONE);
    canvas.setSize(150, 150);
    canvas.setLocation(20, 20);
    shell.open();
    shell.setSize(200, 220);
    GC gc = new GC(canvas);
    gc.drawRectangle(10, 10, 40, 45);
    gc.drawOval(65, 10, 30, 35);
    gc.drawLine(130, 10, 90, 80);
    gc.drawPolygon(new int[] { 20, 70, 45, 90, 70, 70 });
    gc.drawPolyline(new int[] { 10, 120, 70, 100, 100, 130, 130, 75 });
    gc.dispose();
    while (!shell.isDisposed()) {
      if (!display.readAndDispatch())
        display.sleep();
    }
    display.dispose();
  }
}
           
         
  </source>
    
   
  <!-- end source code -->
   




== SWT Draw2D Example ==






   
  <!-- start source code -->
   
    <source lang="java">
 
/*
SWT/JFace in Action
GUI Design with Eclipse 3.0
Matthew Scarpino, Stephen Holder, Stanford Ng, and Laurent Mihalkovic
ISBN: 1932394273
Publisher: Manning
*/

import org.eclipse.draw2d.ButtonGroup;
import org.eclipse.draw2d.ButtonModel;
import org.eclipse.draw2d.ChangeEvent;
import org.eclipse.draw2d.ChangeListener;
import org.eclipse.draw2d.CheckBox;
import org.eclipse.draw2d.Clickable;
import org.eclipse.draw2d.Figure;
import org.eclipse.draw2d.Label;
import org.eclipse.draw2d.LightweightSystem;
import org.eclipse.draw2d.ToggleModel;
import org.eclipse.draw2d.XYLayout;
import org.eclipse.draw2d.geometry.Rectangle;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Shell;
public class Draw2D_Example {
  public static void main(String args[]) {
    final Label label = new Label("Press a button!");
    Shell shell = new Shell();
    LightweightSystem lws = new LightweightSystem(shell);
    Figure parent = new Figure();
    parent.setLayoutManager(new XYLayout());
    lws.setContents(parent);
    Clickable above = new CheckBox("I"m above!");
    parent.add(above, new Rectangle(10, 10, 80, 20));
    ButtonModel aModel = new ToggleModel();
    aModel.addChangeListener(new ChangeListener() {
      public void handleStateChanged(ChangeEvent e) {
        label.setText("Above");
      }
    });
    above.setModel(aModel);
    Clickable below = new CheckBox("I"m below!");
    parent.add(below, new Rectangle(10, 40, 80, 20));
    ButtonModel bModel = new ToggleModel();
    bModel.addChangeListener(new ChangeListener() {
      public void handleStateChanged(ChangeEvent e) {
        label.setText("Below");
      }
    });
    below.setModel(bModel);
    ButtonGroup bGroup = new ButtonGroup();
    bGroup.add(aModel);
    bGroup.add(bModel);
    bGroup.setDefault(bModel);
    parent.add(label, new Rectangle(10, 70, 80, 20));
    shell.setSize(130, 120);
    shell.open();
    shell.setText("Example");
    Display display = Display.getDefault();
    while (!shell.isDisposed()) {
      if (!display.readAndDispatch())
        display.sleep();
    }
  }
}
           
         
  </source>
    
   
  <!-- end source code -->
   




== SWT Graphics Example ==






   
  <!-- start source code -->
   
    <source lang="java">
 
import java.io.IOException;
import java.io.InputStream;
import java.util.HashSet;
import java.util.Iterator;
import java.util.MissingResourceException;
import java.util.Random;
import java.util.ResourceBundle;
import java.util.Vector;
import org.eclipse.swt.SWT;
import org.eclipse.swt.SWTException;
import org.eclipse.swt.graphics.Color;
import org.eclipse.swt.graphics.Font;
import org.eclipse.swt.graphics.FontData;
import org.eclipse.swt.graphics.GC;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.graphics.Path;
import org.eclipse.swt.graphics.Point;
import org.eclipse.swt.graphics.RGB;
import org.eclipse.swt.graphics.Rectangle;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.layout.RowLayout;
import org.eclipse.swt.widgets.Canvas;
import org.eclipse.swt.widgets.ColorDialog;
import org.eclipse.swt.widgets.rubo;
import org.eclipse.swt.widgets.ruposite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Event;
import org.eclipse.swt.widgets.Group;
import org.eclipse.swt.widgets.Label;
import org.eclipse.swt.widgets.Listener;
import org.eclipse.swt.widgets.Menu;
import org.eclipse.swt.widgets.MenuItem;
import org.eclipse.swt.widgets.MessageBox;
import org.eclipse.swt.widgets.Sash;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.swt.widgets.Spinner;
import org.eclipse.swt.widgets.ToolBar;
import org.eclipse.swt.widgets.ToolItem;
import org.eclipse.swt.widgets.Tree;
import org.eclipse.swt.widgets.TreeItem;
public class GraphicsExample {
  Composite parent;
  GraphicsTab[] tabs;
  GraphicsTab tab;
  Object[] tabBackground;
  boolean animate;
  Listener redrawListener;
  ToolBar toolBar;
  Tree tabList;
  Canvas canvas;
  Composite controlPanel, tabPanel;
  ToolItem playItem, pauseItem, backItem, dbItem;
  Spinner timerSpinner;
  Menu backMenu;
  MenuItem customMI;
  Image customImage;
  Color customColor;
  Vector images;
  static boolean advanceGraphics, advanceGraphicsInit;
  static final int TIMER = 30;
  public GraphicsExample(final Composite parent) {
    this.parent = parent;
    redrawListener = new Listener() {
      public void handleEvent(Event e) {
        redraw();
      }
    };
    GridData data;
    GridLayout layout = new GridLayout(3, false);
    layout.horizontalSpacing = 1;
    parent.setLayout(layout);
    tabs = createTabs();
    images = new Vector();
    createToolBar(parent);
    createTabList(parent);
    final Sash sash = new Sash(parent, SWT.VERTICAL);
    createTabPanel(parent);
    data = new GridData(SWT.FILL, SWT.CENTER, true, false);
    data.horizontalSpan = 3;
    toolBar.setLayoutData(data);
    data = new GridData(SWT.CENTER, SWT.FILL, false, true);
    data.widthHint = tabList.ruputeSize(SWT.DEFAULT, SWT.DEFAULT).x + 50;
    tabList.setLayoutData(data);
    data = new GridData(SWT.CENTER, SWT.FILL, false, true);
    sash.setLayoutData(data);
    data = new GridData(SWT.FILL, SWT.FILL, true, true);
    tabPanel.setLayoutData(data);
    sash.addListener(SWT.Selection, new Listener() {
      public void handleEvent(Event event) {
        if (event.detail != SWT.DRAG) {
          GridData data = (GridData) tabList.getLayoutData();
          data.widthHint = event.x
              - tabList.ruputeTrim(0, 0, 0, 0).width;
          parent.layout(true);
          animate = pauseItem.getEnabled();
        } else {
          animate = false;
        }
      }
    });
    setTab(tab);
    startAnimationTimer();
  }
  boolean checkAdvancedGraphics() {
    if (advanceGraphicsInit)
      return advanceGraphics;
    advanceGraphicsInit = true;
    Display display = Display.getCurrent();
    try {
      Path path = new Path(display);
      path.dispose();
    } catch (SWTException e) {
      Shell shell = display.getActiveShell(), newShell = null;
      if (shell == null)
        shell = newShell = new Shell(display);
      MessageBox dialog = new MessageBox(shell, SWT.ICON_WARNING | SWT.OK);
      dialog.setText("Warning"); //$NON-NLS-1$
      dialog.setMessage("LibNotFound"); //$NON-NLS-1$
      dialog.open();
      if (newShell != null)
        newShell.dispose();
      return false;
    }
    return advanceGraphics = true;
  }
  void createCanvas(Composite parent) {
    canvas = new Canvas(parent, SWT.NO_BACKGROUND);
    canvas.addListener(SWT.Paint, new Listener() {
      public void handleEvent(Event event) {
        GC gc;
        Rectangle rect = canvas.getClientArea();
        Image buffer = null;
        if (dbItem.getSelection()) {
          buffer = new Image(canvas.getDisplay(), rect);
          gc = new GC(buffer);
        } else {
          gc = event.gc;
        }
        paintBackground(gc, rect);
        GraphicsTab tab = getTab();
        if (tab != null)
          tab.paint(gc, rect.width, rect.height);
        if (gc != event.gc)
          gc.dispose();
        if (buffer != null) {
          event.gc.drawImage(buffer, 0, 0);
          buffer.dispose();
        }
      }
    });
  }
  void createControlPanel(Composite parent) {
    Group group;
    controlPanel = group = new Group(parent, SWT.NONE);
    group.setText(getResourceString("Settings")); //$NON-NLS-1$
    controlPanel.setLayout(new RowLayout());
  }
  void createTabPanel(Composite parent) {
    tabPanel = new Composite(parent, SWT.NONE);
    GridData data;
    GridLayout layout = new GridLayout(1, false);
    layout.marginHeight = layout.marginWidth = 0;
    tabPanel.setLayout(layout);
    createCanvas(tabPanel);
    createControlPanel(tabPanel);
    data = new GridData(SWT.FILL, SWT.FILL, true, true);
    canvas.setLayoutData(data);
    data = new GridData(SWT.FILL, SWT.CENTER, true, false);
    controlPanel.setLayoutData(data);
  }
  void createToolBar(final Composite parent) {
    final Display display = parent.getDisplay();
    toolBar = new ToolBar(parent, SWT.FLAT);
    Listener toolBarListener = new Listener() {
      public void handleEvent(Event event) {
        switch (event.type) {
        case SWT.Selection: {
          if (event.widget == playItem) {
            animate = true;
            playItem.setEnabled(!animate);
            pauseItem.setEnabled(animate);
          } else if (event.widget == pauseItem) {
            animate = false;
            playItem.setEnabled(!animate);
            pauseItem.setEnabled(animate);
          } else if (event.widget == backItem) {
            final ToolItem toolItem = (ToolItem) event.widget;
            final ToolBar toolBar = toolItem.getParent();
            Rectangle toolItemBounds = toolItem.getBounds();
            Point point = toolBar.toDisplay(new Point(
                toolItemBounds.x, toolItemBounds.y));
            backMenu.setLocation(point.x, point.y
                + toolItemBounds.height);
            backMenu.setVisible(true);
          }
        }
          break;
        }
      }
    };
    playItem = new ToolItem(toolBar, SWT.PUSH);
    playItem.setText(getResourceString("Play")); //$NON-NLS-1$
    playItem.setImage(loadImage(display, "play.gif")); //$NON-NLS-1$
    playItem.addListener(SWT.Selection, toolBarListener);
    pauseItem = new ToolItem(toolBar, SWT.PUSH);
    pauseItem.setText(getResourceString("Pause")); //$NON-NLS-1$
    pauseItem.setImage(loadImage(display, "pause.gif")); //$NON-NLS-1$
    pauseItem.addListener(SWT.Selection, toolBarListener);
    backItem = new ToolItem(toolBar, SWT.PUSH);
    backItem.setText(getResourceString("Background")); //$NON-NLS-1$
    backItem.addListener(SWT.Selection, toolBarListener);
    String[] names = new String[] { getResourceString("White"), //$NON-NLS-1$
        getResourceString("Black"), //$NON-NLS-1$
        getResourceString("Red"), //$NON-NLS-1$
        getResourceString("Green"), //$NON-NLS-1$
        getResourceString("Blue"), //$NON-NLS-1$
        getResourceString("CustomColor"), //$NON-NLS-1$
    };
    Color[] colors = new Color[] { display.getSystemColor(SWT.COLOR_WHITE),
        display.getSystemColor(SWT.COLOR_BLACK),
        display.getSystemColor(SWT.COLOR_RED),
        display.getSystemColor(SWT.COLOR_GREEN),
        display.getSystemColor(SWT.COLOR_BLUE), null, };
    backMenu = new Menu(parent);
    Listener listener = new Listener() {
      public void handleEvent(Event event) {
        MenuItem item = (MenuItem) event.widget;
        if (customMI == item) {
          ColorDialog dialog = new ColorDialog(parent.getShell());
          RGB rgb = dialog.open();
          if (rgb == null)
            return;
          if (customColor != null)
            customColor.dispose();
          customColor = new Color(display, rgb);
          if (customImage != null)
            customImage.dispose();
          customImage = createImage(display, customColor);
          item.setData(new Object[] { customColor, customImage });
          item.setImage(customImage);
        }
        tabBackground = (Object[]) item.getData();
        backItem.setImage((Image) tabBackground[1]);
        canvas.redraw();
      }
    };
    for (int i = 0; i < names.length; i++) {
      MenuItem item = new MenuItem(backMenu, SWT.NONE);
      item.setText(names[i]);
      item.addListener(SWT.Selection, listener);
      Image image = null;
      if (colors[i] != null) {
        image = createImage(display, colors[i]);
        images.addElement(image);
        item.setImage(image);
      } else {
        // custom menu item
        customMI = item;
      }
      item.setData(new Object[] { colors[i], image });
      if (tabBackground == null) {
        tabBackground = (Object[]) item.getData();
        backItem.setImage((Image) tabBackground[1]);
      }
    }
    dbItem = new ToolItem(toolBar, SWT.CHECK);
    dbItem.setText(getResourceString("DoubleBuffer")); //$NON-NLS-1$
    dbItem.setImage(loadImage(display, "db.gif")); //$NON-NLS-1$
    ToolItem separator = new ToolItem(toolBar, SWT.SEPARATOR);
    Composite comp = new Composite(toolBar, SWT.NONE);
    GridData data;
    GridLayout layout = new GridLayout(1, false);
    layout.verticalSpacing = 0;
    layout.marginWidth = layout.marginHeight = 3;
    comp.setLayout(layout);
    timerSpinner = new Spinner(comp, SWT.BORDER | SWT.WRAP);
    data = new GridData(SWT.CENTER, SWT.CENTER, false, false);
    timerSpinner.setLayoutData(data);
    Label label = new Label(comp, SWT.NONE);
    label.setText(getResourceString("Animation")); //$NON-NLS-1$
    data = new GridData(SWT.CENTER, SWT.CENTER, false, false);
    label.setLayoutData(data);
    timerSpinner.setMaximum(1000);
    timerSpinner.setSelection(TIMER);
    timerSpinner.setSelection(TIMER);
    separator.setControl(comp);
    separator.setWidth(comp.ruputeSize(SWT.DEFAULT, SWT.DEFAULT).x);
  }
  Image createImage(Display display, Color color) {
    Image image = new Image(display, 16, 16);
    GC gc = new GC(image);
    gc.setBackground(color);
    Rectangle rect = image.getBounds();
    gc.fillRectangle(rect);
    if (color.equals(display.getSystemColor(SWT.COLOR_BLACK))) {
      gc.setForeground(display.getSystemColor(SWT.COLOR_WHITE));
    }
    gc.drawRectangle(rect.x, rect.y, rect.width - 1, rect.height - 1);
    gc.dispose();
    return image;
  }
  void createTabList(Composite parent) {
    tabList = new Tree(parent, SWT.SINGLE | SWT.H_SCROLL | SWT.V_SCROLL
        | SWT.BORDER);
    HashSet set = new HashSet();
    for (int i = 0; i < tabs.length; i++) {
      GraphicsTab tab = tabs[i];
      set.add(tab.getCategory());
    }
    for (Iterator iter = set.iterator(); iter.hasNext();) {
      String text = (String) iter.next();
      TreeItem item = new TreeItem(tabList, SWT.NONE);
      item.setText(text);
    }
    TreeItem[] items = tabList.getItems();
    for (int i = 0; i < items.length; i++) {
      TreeItem item = items[i];
      for (int j = 0; j < tabs.length; j++) {
        GraphicsTab tab = tabs[j];
        if (item.getText().equals(tab.getCategory())) {
          TreeItem item1 = new TreeItem(item, SWT.NONE);
          item1.setText(tab.getText());
          item1.setData(tab);
        }
      }
    }
    tabList.addListener(SWT.Selection, new Listener() {
      public void handleEvent(Event event) {
        TreeItem item = (TreeItem) event.item;
        if (item != null) {
          setTab((GraphicsTab) item.getData());
        }
      }
    });
  }
  GraphicsTab[] createTabs() {
    return new GraphicsTab[] { new LineTab(this), new StarPolyTab(this),
        tab = new IntroTab(this), new BlackHoleTab(this), };
  }
  /**
   * Disposes all resources created by the receiver.
   */
  public void dispose() {
    if (tabs != null) {
      for (int i = 0; i < tabs.length; i++) {
        GraphicsTab tab = tabs[i];
        tab.dispose();
      }
    }
    tabs = null;
    if (images != null) {
      for (int i = 0; i < images.size(); i++) {
        ((Image) images.elementAt(i)).dispose();
      }
    }
    images = null;
    if (customColor != null)
      customColor.dispose();
    customColor = null;
    if (customImage != null)
      customImage.dispose();
    customImage = null;
  }
  TreeItem findItemByData(TreeItem[] items, Object data) {
    for (int i = 0; i < items.length; i++) {
      TreeItem item = items[i];
      if (item.getData() == data)
        return item;
      item = findItemByData(item.getItems(), data);
      if (item != null)
        return item;
    }
    return null;
  }
  /**
   * Gets the current tab.
   */
  public GraphicsTab getTab() {
    return tab;
  }
  Listener getRedrawListener() {
    return redrawListener;
  }
  /**
   * Gets a string from the resource bundle. We don"t want to crash because of
   * a missing String. Returns the key if not found.
   */
  static String getResourceString(String key) {
      return "key";
  }
  static Image loadImage(Display display, Class clazz, String string) {
    InputStream stream = clazz.getResourceAsStream(string);
    if (stream == null)
      return null;
    Image image = null;
    try {
      image = new Image(display, stream);
    } catch (SWTException ex) {
    } finally {
      try {
        stream.close();
      } catch (IOException ex) {
      }
    }
    return image;
  }
  Image loadImage(Display display, String name) {
    Image image = loadImage(display, GraphicsExample.class, name);
    if (image != null)
      images.addElement(image);
    return image;
  }
  void paintBackground(GC gc, Rectangle rect) {
    gc.setBackground((Color) tabBackground[0]);
    gc.fillRectangle(rect);
  }
  /**
   * Redraws the current tab.
   */
  public void redraw() {
    canvas.redraw();
  }
  /**
   * Grabs input focus.
   */
  public void setFocus() {
    tabList.setFocus();
  }
  /**
   * Sets the current tab.
   */
  public void setTab(GraphicsTab tab) {
    this.tab = tab;
    Control[] children = controlPanel.getChildren();
    for (int i = 0; i < children.length; i++) {
      Control control = children[i];
      control.dispose();
    }
    if (tab != null) {
      tab.createControlPanel(controlPanel);
      animate = tab.isAnimated();
    }
    playItem.setEnabled(!animate);
    pauseItem.setEnabled(animate);
    GridData data = (GridData) controlPanel.getLayoutData();
    children = controlPanel.getChildren();
    data.exclude = children.length == 0;
    controlPanel.setVisible(!data.exclude);
    if (data.exclude) {
      tabPanel.layout();
    } else {
      tabPanel.layout(children);
    }
    if (tab != null) {
      TreeItem[] selection = tabList.getSelection();
      if (selection.length == 0 || selection[0].getData() != tab) {
        TreeItem item = findItemByData(tabList.getItems(), tab);
        if (item != null)
          tabList.setSelection(new TreeItem[] { item });
      }
    }
    canvas.redraw();
  }
  void startAnimationTimer() {
    final Display display = Display.getCurrent();
    display.timerExec(timerSpinner.getSelection(), new Runnable() {
      public void run() {
        if (canvas.isDisposed())
          return;
        if (animate) {
          GraphicsTab tab = getTab();
          if (tab != null && tab.isAnimated()) {
            Rectangle rect = canvas.getClientArea();
            tab.next(rect.width, rect.height);
            canvas.redraw();
            canvas.update();
          }
        }
        display.timerExec(timerSpinner.getSelection(), this);
      }
    });
  }
  public static void main(String[] args) {
    Display display = new Display();
    Shell shell = new Shell(display);
    shell.setText(getResourceString("SWTGraphics")); //$NON-NLS-1$
    final GraphicsExample example = new GraphicsExample(shell);
    shell.addListener(SWT.Close, new Listener() {
      public void handleEvent(Event event) {
        example.dispose();
      }
    });
    shell.open();
    while (!shell.isDisposed()) {
      if (!display.readAndDispatch())
        display.sleep();
    }
  }
}
/*******************************************************************************
 * Copyright (c) 2000, 2005 IBM Corporation and others. All rights reserved.
 * This program and the accompanying materials are made available under the
 * terms of the Eclipse Public License v1.0 which accompanies this distribution,
 * and is available at http://www.eclipse.org/legal/epl-v10.html
 * 
 * Contributors: IBM Corporation - initial API and implementation
 ******************************************************************************/
abstract class GraphicsTab {
  GraphicsExample example;
  public GraphicsTab(GraphicsExample example) {
    this.example = example;
  }
  /**
   * Creates the widgets used to control the drawing.
   */
  public void createControlPanel(Composite parent) {
  }
  /**
   * Disposes resources created by the receiver.
   */
  public void dispose() {
  }
  /**
   * Answer the receiver"s name.
   */
  public abstract String getText();
  /**
   * Answer the receiver"s category.
   */
  public String getCategory() {
    return GraphicsExample.getResourceString("Misc"); //$NON-NLS-1$
  }
  /**
   * Answer whether the receiver is animated or not.
   */
  public boolean isAnimated() {
    return false;
  }
  /**
   * Advance the animation.
   */
  public void next(int width, int height) {
  }
  /**
   * Paint the receiver into the specified GC.
   */
  public void paint(GC gc, int width, int height) {
  }
}
/*******************************************************************************
 * Copyright (c) 2000, 2005 IBM Corporation and others. All rights reserved.
 * This program and the accompanying materials are made available under the
 * terms of the Eclipse Public License v1.0 which accompanies this distribution,
 * and is available at http://www.eclipse.org/legal/epl-v10.html
 * 
 * Contributors: IBM Corporation - initial API and implementation
 ******************************************************************************/
class LineTab extends GraphicsTab {
  public LineTab(GraphicsExample example) {
    super(example);
  }
  public String getText() {
    return GraphicsExample.getResourceString("Line"); //$NON-NLS-1$
  }
  public void paint(GC gc, int width, int height) {
    gc.drawLine(0, 0, width, height);
    gc.drawLine(width, 0, 0, height);
  }
}
/*******************************************************************************
 * Copyright (c) 2000, 2005 IBM Corporation and others. All rights reserved.
 * This program and the accompanying materials are made available under the
 * terms of the Eclipse Public License v1.0 which accompanies this distribution,
 * and is available at http://www.eclipse.org/legal/epl-v10.html
 * 
 * Contributors: IBM Corporation - initial API and implementation
 ******************************************************************************/
class StarPolyTab extends GraphicsTab {
  int[] radial;
  static final int POINTS = 11;
  Combo fillRuleCb;
  public StarPolyTab(GraphicsExample example) {
    super(example);
    radial = new int[POINTS * 2];
  }
  public void createControlPanel(Composite parent) {
    new Label(parent, SWT.NONE).setText(GraphicsExample
        .getResourceString("FillRule")); //$NON-NLS-1$
    fillRuleCb = new Combo(parent, SWT.DROP_DOWN);
    fillRuleCb.add("FILL_EVEN_ODD");
    fillRuleCb.add("FILL_WINDING");
    fillRuleCb.select(0);
    fillRuleCb.addListener(SWT.Selection, example.getRedrawListener());
  }
  public String getCategory() {
    return GraphicsExample.getResourceString("Polygons"); //$NON-NLS-1$
  }
  public String getText() {
    return GraphicsExample.getResourceString("StarPolygon"); //$NON-NLS-1$
  }
  public void paint(GC gc, int width, int height) {
    int centerX = width / 2;
    int centerY = height / 2;
    int pos = 0;
    for (int i = 0; i < POINTS; ++i) {
      double r = Math.PI * 2 * pos / POINTS;
      radial[i * 2] = (int) ((1 + Math.cos(r)) * centerX);
      radial[i * 2 + 1] = (int) ((1 + Math.sin(r)) * centerY);
      pos = (pos + POINTS / 2) % POINTS;
    }
    Display display = Display.getCurrent();
    gc.setFillRule(fillRuleCb.getSelectionIndex() != 0 ? SWT.FILL_WINDING
        : SWT.FILL_EVEN_ODD);
    gc.setBackground(display.getSystemColor(SWT.COLOR_WHITE));
    gc.fillPolygon(radial);
    gc.drawPolygon(radial);
  }
}
/*******************************************************************************
 * Copyright (c) 2000, 2005 IBM Corporation and others. All rights reserved.
 * This program and the accompanying materials are made available under the
 * terms of the Eclipse Public License v1.0 which accompanies this distribution,
 * and is available at http://www.eclipse.org/legal/epl-v10.html
 * 
 * Contributors: IBM Corporation - initial API and implementation
 ******************************************************************************/
class BlackHoleTab extends GraphicsTab {
  int size = 1;
  public BlackHoleTab(GraphicsExample example) {
    super(example);
  }
  public String getText() {
    return GraphicsExample.getResourceString("BlackHole"); //$NON-NLS-1$
  }
  public boolean isAnimated() {
    return true;
  }
  public void next(int width, int height) {
    if (size > width * 3 / 2)
      size = 0;
    else
      size += 10;
  }
  public void paint(GC gc, int width, int height) {
    Display display = Display.getCurrent();
    gc.setBackground(display.getSystemColor(SWT.COLOR_BLACK));
    gc.fillOval((width - size) / 2, (height - size) / 2, size, size);
  }
}
/*******************************************************************************
 * Copyright (c) 2000, 2005 IBM Corporation and others. All rights reserved.
 * This program and the accompanying materials are made available under the
 * terms of the Eclipse Public License v1.0 which accompanies this distribution,
 * and is available at http://www.eclipse.org/legal/epl-v10.html
 * 
 * Contributors: IBM Corporation - initial API and implementation
 ******************************************************************************/
class IntroTab extends GraphicsTab {
  Font font;
  Image image;
  Random random = new Random();
  float x, y;
  float incX = 10.0f;
  float incY = 5.0f;
  int textWidth, textHeight;
  String text = "SWT";
  public IntroTab(GraphicsExample example) {
    super(example);
  }
  public void dispose() {
    if (image != null)
      image.dispose();
    image = null;
    if (font != null)
      font.dispose();
    font = null;
  }
  public String getCategory() {
    return GraphicsExample.getResourceString("Introduction"); //$NON-NLS-1$
  }
  public String getText() {
    return GraphicsExample.getResourceString("SWT"); //$NON-NLS-1$
  }
  public boolean isAnimated() {
    return true;
  }
  public void next(int width, int height) {
    x += incX;
    y += incY;
    float random = (float) Math.random();
    if (x + textWidth > width) {
      x = width - textWidth;
      incX = random * -width / 16 - 1;
    }
    if (x < 0) {
      x = 0;
      incX = random * width / 16 + 1;
    }
    if (y + textHeight > height) {
      y = (height - textHeight) - 2;
      incY = random * -height / 16 - 1;
    }
    if (y < 0) {
      y = 0;
      incY = random * height / 16 + 1;
    }
  }
  public void paint(GC gc, int width, int height) {
    if (!example.checkAdvancedGraphics())
      return;
    Display display = Display.getCurrent();
    if (image == null) {
      image = example.loadImage(Display.getCurrent(), "irmaos.jpg");
      Rectangle rect = image.getBounds();
      FontData fd = display.getSystemFont().getFontData()[0];
      font = new Font(display, fd.getName(), rect.height / 4, SWT.BOLD);
      gc.setFont(font);
      Point size = gc.stringExtent(text);
      textWidth = size.x;
      textHeight = size.y;
    }
    Path path = new Path(display);
    path.addString(text, x, y, font);
    gc.setClipping(path);
    Rectangle rect = image.getBounds();
    gc.drawImage(image, 0, 0, rect.width, rect.height, 0, 0, width, height);
    gc.setClipping((Rectangle) null);
    gc.setForeground(display.getSystemColor(SWT.COLOR_BLUE));
    gc.drawPath(path);
  }
}

           
         
  </source>
    
   
  <!-- end source code -->
   




== SWT OpenGL snippet: draw a square ==






   
  <!-- start source code -->
   
    <source lang="java">
 
/*******************************************************************************
 * Copyright (c) 2000, 2005 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     Sebastian Davids - initial implementation
 *     IBM Corporation
 *******************************************************************************/
package org.eclipse.swt.snippets;
/*
 * SWT OpenGL snippet: draw a square
 * 
 * This snippet requires the experimental org.eclipse.swt.opengl plugin, which
 * is not included in swt by default. For information on this plugin see
 * http://dev.eclipse.org/viewcvs/index.cgi/%7Echeckout%7E/platform-swt-home/opengl/opengl.html
 * 
 * For a list of all SWT example snippets see
 * http://dev.eclipse.org/viewcvs/index.cgi/%7Echeckout%7E/platform-swt-home/dev.html#snippets
 */
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.*;
import org.eclipse.swt.graphics.*;
import org.eclipse.swt.layout.*;
import org.eclipse.swt.opengl.*;
import org.eclipse.swt.widgets.*;
public class Snippet174 {
  public static void main(String[] args) {
    Display display = new Display();
    Shell shell = new Shell(display);
    shell.setText("OpenGL in SWT");
    shell.setLayout(new FillLayout());
    final Canvas canvas = new Canvas(shell, SWT.NO_BACKGROUND);
    canvas.addControlListener(new ControlAdapter() {
      public void controlResized(ControlEvent e) {
        resize(canvas);
      }
    });
    final GLContext context = init(canvas);
    shell.addDisposeListener(new DisposeListener() {
      public void widgetDisposed(DisposeEvent e) {
        context.dispose();
      }
    });
    new Runnable() {
      public void run() {
        if (canvas.isDisposed())
          return;
        render();
        context.swapBuffers();
        canvas.getDisplay().timerExec(50, this);
      }
    }.run();
    shell.open();
    while (!shell.isDisposed()) {
      if (!display.readAndDispatch())
        display.sleep();
    }
    display.dispose();
  }
  static GLContext init(Canvas canvas) {
    GLContext context = new GLContext(canvas);
    context.setCurrent();
    resize(canvas);
    GL.glClearColor(1.0f, 1.0f, 1.0f, 1.0f);
    GL.glColor3f(0.0f, 0.0f, 0.0f);
    GL.glClearDepth(1.0f);
    GL.glEnable(GL.GL_DEPTH_TEST);
    GL.glHint(GL.GL_PERSPECTIVE_CORRECTION_HINT, GL.GL_NICEST);
    return context;
  }
  static void render() {
    GL.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT);
    GL.glLoadIdentity();
    GL.glTranslatef(0.0f, 0.0f, -6.0f);
    GL.glBegin(GL.GL_QUADS);
    GL.glVertex3f(-1.0f, 1.0f, 0.0f);
    GL.glVertex3f(1.0f, 1.0f, 0.0f);
    GL.glVertex3f(1.0f, -1.0f, 0.0f);
    GL.glVertex3f(-1.0f, -1.0f, 0.0f);
    GL.glEnd();
  }
  static void resize(Canvas canvas) {
    Rectangle rect = canvas.getClientArea();
    int width = rect.width;
    int height = Math.max(rect.height, 1);
    GL.glViewport(0, 0, width, height);
    GL.glMatrixMode(GL.GL_PROJECTION);
    GL.glLoadIdentity();
    float aspect = (float) width / (float) height;
    GLU.gluPerspective(45.0f, aspect, 0.5f, 400.0f);
    GL.glMatrixMode(GL.GL_MODELVIEW);
    GL.glLoadIdentity();
  }
}

           
         
  </source>
    
   
  <!-- end source code -->
   




== SWT Paint Example ==






   
  <!-- start source code -->
   
    <source lang="java">
 
import org.eclipse.swt.*;
import org.eclipse.swt.graphics.*;
import org.eclipse.swt.widgets.*;
import org.eclipse.swt.events.*;
import org.eclipse.swt.layout.*;
import org.eclipse.swt.accessibility.*;
import java.io.*;
import java.text.*;
import java.util.*;
public class PaintExample {
  private Composite mainComposite;
  private Canvas activeForegroundColorCanvas;
  private Canvas activeBackgroundColorCanvas;
  private Color paintColorBlack, paintColorWhite; // alias for paintColors[0] and [1]
  private Color[] paintColors;
  private Font paintDefaultFont; // do not free
  private static final int numPaletteRows = 3;
  private static final int numPaletteCols = 50;
  private ToolSettings toolSettings; // current active settings
  private PaintSurface paintSurface; // paint surface for drawing
  static final int Pencil_tool = 0;
  static final int Airbrush_tool = 1;
  static final int Line_tool = 2;
  static final int PolyLine_tool = 3;
  static final int Rectangle_tool = 4;
  static final int RoundedRectangle_tool = 5;
  static final int Ellipse_tool = 6;
  static final int Text_tool = 7;
  static final int None_fill = 8;
  static final int Outline_fill = 9;
  static final int Solid_fill = 10;
  static final int Solid_linestyle = 11;
  static final int Dash_linestyle = 12;
  static final int Dot_linestyle = 13;
  static final int DashDot_linestyle = 14;
  static final int Font_options = 15;
  
  static final int Default_tool = Pencil_tool;
  static final int Default_fill = None_fill;
  static final int Default_linestyle = Solid_linestyle;
  
  public static final Tool[] tools = {
    new Tool(Pencil_tool, "Pencil", "tool", SWT.RADIO),
    new Tool(Airbrush_tool, "Airbrush", "tool", SWT.RADIO),
    new Tool(Line_tool, "Line", "tool", SWT.RADIO),
    new Tool(PolyLine_tool, "PolyLine", "tool", SWT.RADIO),
    new Tool(Rectangle_tool, "Rectangle", "tool", SWT.RADIO),
    new Tool(RoundedRectangle_tool, "RoundedRectangle", "tool", SWT.RADIO),
    new Tool(Ellipse_tool, "Ellipse", "tool", SWT.RADIO),
    new Tool(Text_tool, "Text", "tool", SWT.RADIO),
    new Tool(None_fill, "None", "fill", SWT.RADIO, new Integer(ToolSettings.ftNone)),
    new Tool(Outline_fill, "Outline", "fill", SWT.RADIO, new Integer(ToolSettings.ftOutline)),
    new Tool(Solid_fill, "Solid", "fill", SWT.RADIO, new Integer(ToolSettings.ftSolid)),
    new Tool(Solid_linestyle, "Solid", "linestyle", SWT.RADIO, new Integer(SWT.LINE_SOLID)),
    new Tool(Dash_linestyle, "Dash", "linestyle", SWT.RADIO, new Integer(SWT.LINE_DASH)),
    new Tool(Dot_linestyle, "Dot", "linestyle", SWT.RADIO, new Integer(SWT.LINE_DOT)),
    new Tool(DashDot_linestyle, "DashDot", "linestyle", SWT.RADIO, new Integer(SWT.LINE_DASHDOT)),
    new Tool(Font_options, "Font", "options", SWT.PUSH)
  };
  /**
   * Creates an instance of a PaintExample embedded inside
   * the supplied parent Composite.
   * 
   * @param parent the container of the example
   */
  public PaintExample(Composite parent) {
    mainComposite = parent;
    initResources();
    initActions();
    init();
  }
  /**
   * Invokes as a standalone program.
   */
  public static void main(String[] args) {
    Display display = new Display();
    Shell shell = new Shell(display);
    shell.setText(getResourceString("window.title"));
    shell.setLayout(new GridLayout());
    PaintExample instance = new PaintExample(shell);
    instance.createToolBar(shell);
    Composite composite = new Composite(shell, SWT.NONE);
    composite.setLayout(new FillLayout());
    composite.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true));
    instance.createGUI(composite);
    instance.setDefaults();
    setShellSize(display, shell);
    shell.open();
    while (! shell.isDisposed()) {
      if (! display.readAndDispatch()) display.sleep();
    }
    instance.dispose();
  }
  
  /**
   * Creates the toolbar.
   * Note: Only called by standalone.
   */
  private void createToolBar(Composite parent) {
    ToolBar toolbar = new ToolBar (parent, SWT.NONE);
    String group = null;
    for (int i = 0; i < tools.length; i++) {
      Tool tool = tools[i];
      if (group != null && !tool.group.equals(group)) {
        new ToolItem (toolbar, SWT.SEPARATOR);
      }
      group = tool.group;
      ToolItem item = addToolItem(toolbar, tool);
      if (i == Default_tool || i == Default_fill || i == Default_linestyle) item.setSelection(true);
    }
  }
  /**
   * Adds a tool item to the toolbar.
   * Note: Only called by standalone.
   */
  private ToolItem addToolItem(final ToolBar toolbar, final Tool tool) {
    final String id = tool.group + "." + tool.name;
    ToolItem item = new ToolItem (toolbar, tool.type);
    item.setText (getResourceString(id + ".label"));
    item.setToolTipText(getResourceString(id + ".tooltip"));
    item.setImage(tool.image);
    item.addSelectionListener(new SelectionAdapter() {
      public void widgetSelected(SelectionEvent e) {
        tool.action.run();
      }
    });
    final int childID = toolbar.indexOf(item);
    toolbar.getAccessible().addAccessibleListener(new AccessibleAdapter() {
      public void getName(org.eclipse.swt.accessibility.AccessibleEvent e) {
        if (e.childID == childID) {
          e.result = getResourceString(id + ".description");
        }
      }
    });
    return item;
  }
  /**
   * Sets the default tool item states.
   */
  public void setDefaults() {
    setPaintTool(Default_tool);
    setFillType(Default_fill);
    setLineStyle(Default_linestyle);
    setForegroundColor(paintColorBlack);
    setBackgroundColor(paintColorWhite);
  }
  /**
   * Creates the GUI.
   */
  public void createGUI(Composite parent) {
    GridLayout gridLayout;
    GridData gridData;
    /*** Create principal GUI layout elements ***/    
    Composite displayArea = new Composite(parent, SWT.NONE);
    gridLayout = new GridLayout();
    gridLayout.numColumns = 1;
    displayArea.setLayout(gridLayout);
    // Creating these elements here avoids the need to instantiate the GUI elements
    // in strict layout order.  The natural layout ordering is an artifact of using
    // SWT layouts, but unfortunately it is not the same order as that required to
    // instantiate all of the non-GUI application elements to satisfy referential
    // dependencies.  It is possible to reorder the initialization to some extent, but
    // this can be very tedious.
    
    // paint canvas
    final Canvas paintCanvas = new Canvas(displayArea, SWT.BORDER | SWT.V_SCROLL | SWT.H_SCROLL |
      SWT.NO_REDRAW_RESIZE | SWT.NO_BACKGROUND);
    gridData = new GridData(GridData.FILL_HORIZONTAL | GridData.FILL_VERTICAL);
    paintCanvas.setLayoutData(gridData);
    paintCanvas.setBackground(paintColorWhite);
    
    // color selector frame
    final Composite colorFrame = new Composite(displayArea, SWT.NONE);
    gridData = new GridData(GridData.FILL_HORIZONTAL | GridData.VERTICAL_ALIGN_FILL);
    colorFrame.setLayoutData(gridData);
    // tool settings frame
    final Composite toolSettingsFrame = new Composite(displayArea, SWT.NONE);
    gridData = new GridData(GridData.FILL_HORIZONTAL | GridData.VERTICAL_ALIGN_FILL);
    toolSettingsFrame.setLayoutData(gridData);
    // status text
    final Text statusText = new Text(displayArea, SWT.BORDER | SWT.SINGLE | SWT.READ_ONLY);
    gridData = new GridData(GridData.FILL_HORIZONTAL | GridData.VERTICAL_ALIGN_FILL);
    statusText.setLayoutData(gridData);
    /*** Create the remaining application elements inside the principal GUI layout elements ***/  
    // paintSurface
    paintSurface = new PaintSurface(paintCanvas, statusText, paintColorWhite);
    // finish initializing the tool data
    tools[Pencil_tool].data = new PencilTool(toolSettings, paintSurface);
    tools[Airbrush_tool].data = new AirbrushTool(toolSettings, paintSurface);
    tools[Line_tool].data = new LineTool(toolSettings, paintSurface);
    tools[PolyLine_tool].data = new PolyLineTool(toolSettings, paintSurface);
    tools[Rectangle_tool].data = new RectangleTool(toolSettings, paintSurface);
    tools[RoundedRectangle_tool].data = new RoundedRectangleTool(toolSettings, paintSurface);
    tools[Ellipse_tool].data = new EllipseTool(toolSettings, paintSurface);
    tools[Text_tool].data = new TextTool(toolSettings, paintSurface);
    // colorFrame    
    gridLayout = new GridLayout();
    gridLayout.numColumns = 3;
    gridLayout.marginHeight = 0;
    gridLayout.marginWidth = 0;
    colorFrame.setLayout(gridLayout);
    // activeForegroundColorCanvas, activeBackgroundColorCanvas
    activeForegroundColorCanvas = new Canvas(colorFrame, SWT.BORDER);
    gridData = new GridData(GridData.HORIZONTAL_ALIGN_FILL);
    gridData.heightHint = 24;
    gridData.widthHint = 24;
    activeForegroundColorCanvas.setLayoutData(gridData);
    activeBackgroundColorCanvas = new Canvas(colorFrame, SWT.BORDER);
    gridData = new GridData(GridData.HORIZONTAL_ALIGN_FILL);
    gridData.heightHint = 24;
    gridData.widthHint = 24;
    activeBackgroundColorCanvas.setLayoutData(gridData);
    // paletteCanvas
    final Canvas paletteCanvas = new Canvas(colorFrame, SWT.BORDER | SWT.NO_BACKGROUND);
    gridData = new GridData(GridData.FILL_HORIZONTAL);
    gridData.heightHint = 24;
    paletteCanvas.setLayoutData(gridData);
    paletteCanvas.addListener(SWT.MouseDown, new Listener() {
      public void handleEvent(Event e) {
        Rectangle bounds = paletteCanvas.getClientArea();
        Color color = getColorAt(bounds, e.x, e.y);        
          
        if (e.button == 1) setForegroundColor(color);
        else setBackgroundColor(color);
      }
      private Color getColorAt(Rectangle bounds, int x, int y) {
        if (bounds.height <= 1 && bounds.width <= 1) return paintColorWhite;
        final int row = (y - bounds.y) * numPaletteRows / bounds.height;
        final int col = (x - bounds.x) * numPaletteCols / bounds.width;
        return paintColors[Math.min(Math.max(row * numPaletteCols + col, 0), paintColors.length - 1)];
      }
    });
    Listener refreshListener = new Listener() {
      public void handleEvent(Event e) {
        if (e.gc == null) return;
        Rectangle bounds = paletteCanvas.getClientArea();
        for (int row = 0; row < numPaletteRows; ++row) {
          for (int col = 0; col < numPaletteCols; ++col) {
            final int x = bounds.width * col / numPaletteCols;
            final int y = bounds.height * row / numPaletteRows;
            final int width = Math.max(bounds.width * (col + 1) / numPaletteCols - x, 1);
            final int height = Math.max(bounds.height * (row + 1) / numPaletteRows - y, 1);
            e.gc.setBackground(paintColors[row * numPaletteCols + col]);
            e.gc.fillRectangle(bounds.x + x, bounds.y + y, width, height);
          }
        }
      }
    };
    paletteCanvas.addListener(SWT.Resize, refreshListener);
    paletteCanvas.addListener(SWT.Paint, refreshListener);
    //paletteCanvas.redraw();
    
    // toolSettingsFrame
    gridLayout = new GridLayout();
    gridLayout.numColumns = 4;
    gridLayout.marginHeight = 0;
    gridLayout.marginWidth = 0;
    toolSettingsFrame.setLayout(gridLayout);
    Label label = new Label(toolSettingsFrame, SWT.NONE);
    label.setText(getResourceString("settings.AirbrushRadius.text"));
    final Scale airbrushRadiusScale = new Scale(toolSettingsFrame, SWT.HORIZONTAL);
    airbrushRadiusScale.setMinimum(5);
    airbrushRadiusScale.setMaximum(50);
    airbrushRadiusScale.setSelection(toolSettings.airbrushRadius);
    airbrushRadiusScale.setLayoutData(new GridData(GridData.FILL_HORIZONTAL | GridData.VERTICAL_ALIGN_FILL));
    airbrushRadiusScale.addSelectionListener(new SelectionAdapter() {
      public void widgetSelected(SelectionEvent e) {
        toolSettings.airbrushRadius = airbrushRadiusScale.getSelection();
        updateToolSettings();
      }
    });
    label = new Label(toolSettingsFrame, SWT.NONE);
    label.setText(getResourceString("settings.AirbrushIntensity.text"));
    final Scale airbrushIntensityScale = new Scale(toolSettingsFrame, SWT.HORIZONTAL);
    airbrushIntensityScale.setMinimum(1);
    airbrushIntensityScale.setMaximum(100);
    airbrushIntensityScale.setSelection(toolSettings.airbrushIntensity);
    airbrushIntensityScale.setLayoutData(new GridData(GridData.FILL_HORIZONTAL | GridData.VERTICAL_ALIGN_FILL));
    airbrushIntensityScale.addSelectionListener(new SelectionAdapter() {
      public void widgetSelected(SelectionEvent e) {
        toolSettings.airbrushIntensity = airbrushIntensityScale.getSelection();
        updateToolSettings();
      }
    });
  }
    
  /**
   * Disposes of all resources associated with a particular
   * instance of the PaintExample.
   */  
  public void dispose() {
    if (paintSurface != null) paintSurface.dispose();    
    if (paintColors != null) {
      for (int i = 0; i < paintColors.length; ++i) {
        final Color color = paintColors[i];
        if (color != null) color.dispose();
      }
    }
    paintDefaultFont = null;
    paintColors = null;
    paintSurface = null;
    freeResources();
  }
  /**
   * Frees the resource bundle resources.
   */
  public void freeResources() {
    for (int i = 0; i < tools.length; ++i) {
      Tool tool = tools[i];
      final Image image = tool.image;
      if (image != null) image.dispose();
      tool.image = null;
    }
  }
  
  /**
   * Returns the Display.
   * 
   * @return the display we"re using
   */
  public Display getDisplay() {
    return mainComposite.getDisplay();
  }
  
  /**
   * Gets a string from the resource bundle.
   * We don"t want to crash because of a missing String.
   * Returns the key if not found.
   */
  public static String getResourceString(String key) {
      return key;
  }
  /**
   * Gets a string from the resource bundle and binds it
   * with the given arguments. If the key is not found,
   * return the key.
   */
  public static String getResourceString(String key, Object[] args) {
    try {
      return MessageFormat.format(getResourceString(key), args);
    } catch (MissingResourceException e) {
      return key;
    } catch (NullPointerException e) {
      return "!" + key + "!";
    }
  }
  /**
   * Initialize colors, fonts, and tool settings.
   */
  private void init() {
    Display display = mainComposite.getDisplay();
    
    paintColorWhite = new Color(display, 255, 255, 255);
    paintColorBlack = new Color(display, 0, 0, 0);
    
    paintDefaultFont = display.getSystemFont();
    paintColors = new Color[numPaletteCols * numPaletteRows];
    paintColors[0] = paintColorBlack;
    paintColors[1] = paintColorWhite;
    for (int i = 2; i < paintColors.length; i++) {
      paintColors[i] = new Color(display,
        ((i*7)%255),((i*23)%255), ((i*51)%255));
    }
    toolSettings = new ToolSettings();
    toolSettings.rumonForegroundColor = paintColorBlack;
    toolSettings.rumonBackgroundColor = paintColorWhite;
    toolSettings.rumonFont = paintDefaultFont;
  }
  /**
   * Sets the action field of the tools
   */
  private void initActions() {
    for (int i = 0; i < tools.length; ++i) {
      final Tool tool = tools[i];
      String group = tool.group;
      if (group.equals("tool")) {
        tool.action = new Runnable() {
          public void run() {
            setPaintTool(tool.id);
          }
        };
      } else if (group.equals("fill")) {
        tool.action = new Runnable() {
          public void run() {
            setFillType(tool.id);
          }
        };
      } else if (group.equals("linestyle")) {
        tool.action = new Runnable() {
          public void run() {
            setLineStyle(tool.id);
          }
        };
      } else if (group.equals("options")) {
        tool.action = new Runnable() {
          public void run() {
            FontDialog fontDialog = new FontDialog(paintSurface.getShell(), SWT.PRIMARY_MODAL);
            FontData[] fontDatum = toolSettings.rumonFont.getFontData();
            if (fontDatum != null && fontDatum.length > 0) {
              fontDialog.setFontList(fontDatum);
            }
            fontDialog.setText(getResourceString("options.Font.dialog.title"));
            paintSurface.hideRubberband();
            FontData fontData = fontDialog.open();
            paintSurface.showRubberband();
            if (fontData != null) {
              try {
                Font font = new Font(mainComposite.getDisplay(), fontData);
                toolSettings.rumonFont = font;
                updateToolSettings();
              } catch (SWTException ex) {
              }
            }
          }
        };
      }
    }
  }
  /**
   * Loads the image resources.
   */
  public void initResources() {
    final Class clazz = PaintExample.class;
      try {
        for (int i = 0; i < tools.length; ++i) {
          Tool tool = tools[i];
          String id = tool.group + "." + tool.name;
          InputStream sourceStream = clazz.getResourceAsStream(getResourceString(id + ".image"));
          ImageData source = new ImageData(sourceStream);
          ImageData mask = source.getTransparencyMask();
          tool.image = new Image(null, source, mask);
          try {
            sourceStream.close();
          } catch (IOException e) {
            e.printStackTrace();
          }
        }
        return;
      } catch (Throwable t) {
      }
    String error = "Unable to load resources";
    freeResources();
    throw new RuntimeException(error);
  }
  /**
   * Grabs input focus.
   */
  public void setFocus() {
    mainComposite.setFocus();
  }
  
  /**
   * Sets the tool foreground color.
   * 
   * @param color the new color to use
   */
  public void setForegroundColor(Color color) {
    if (activeForegroundColorCanvas != null)
      activeForegroundColorCanvas.setBackground(color);
    toolSettings.rumonForegroundColor = color;
    updateToolSettings();
  }
  /**
   * Set the tool background color.
   * 
   * @param color the new color to use
   */
  public void setBackgroundColor(Color color) {
    if (activeBackgroundColorCanvas != null)
      activeBackgroundColorCanvas.setBackground(color);
    toolSettings.rumonBackgroundColor = color;
    updateToolSettings();
  }
  /**
   * Selects a tool given its ID.
   */
  public void setPaintTool(int id) {
    PaintTool paintTool = (PaintTool) tools[id].data;
    paintSurface.setPaintSession(paintTool);
    updateToolSettings();
  }
  
  /**
   * Selects a filltype given its ID.
   */
  public void setFillType(int id) {
    Integer fillType = (Integer) tools[id].data;
    toolSettings.rumonFillType = fillType.intValue();
    updateToolSettings();    
  }
  /**
   * Selects line type given its ID.
   */
  public void setLineStyle(int id) {
    Integer lineType = (Integer) tools[id].data;
    toolSettings.rumonLineStyle = lineType.intValue();
    updateToolSettings();    
  }
  /**
   * Sets the size of the shell to it"s "packed" size,
   * unless that makes it bigger than the display,
   * in which case set it to 9/10 of display size.
   */
  private static void setShellSize (Display display, Shell shell) {
    Rectangle bounds = display.getBounds();
    Point size = shell.ruputeSize (SWT.DEFAULT, SWT.DEFAULT);
    if (size.x > bounds.width) size.x = bounds.width * 9 / 10;
    if (size.y > bounds.height) size.y = bounds.height * 9 / 10;
    shell.setSize (size);
  }
  /**
   * Notifies the tool that its settings have changed.
   */
  private void updateToolSettings() {
    final PaintTool activePaintTool = paintSurface.getPaintTool();
    if (activePaintTool == null) return;
    
    activePaintTool.endSession();
    activePaintTool.set(toolSettings);
    activePaintTool.beginSession();
  }
}

/*******************************************************************************
 * Copyright (c) 2000, 2005 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
/**
 * Tool Settings objects group tool-related configuration information.
 */
class ToolSettings {
  public static final int ftNone = 0, ftOutline = 1, ftSolid = 2;
  /**
   * commonForegroundColor: current tool foreground colour
   */
  public Color commonForegroundColor;
  /**
   * commonBackgroundColor: current tool background colour
   */
  public Color commonBackgroundColor;
  /**
   * commonFont: current font
   */
  public Font commonFont;
  /**
   * commonFillType: current fill type
   * <p>One of ftNone, ftOutline, ftSolid.</p>
   */
  public int commonFillType = ftNone;
  /**
   * commonLineStyle: current line type
   */
  public int commonLineStyle = SWT.LINE_SOLID;
  
  /**
   * airbrushRadius: coverage radius in pixels
   */
  public int airbrushRadius = 10;
  
  /**
   * airbrushIntensity: average surface area coverage in region defined by radius per "jot"
   */
  public int airbrushIntensity = 30;
  
  /**
   * roundedRectangleCornerDiameter: the diameter of curvature of corners in a rounded rectangle
   */
  public int roundedRectangleCornerDiameter = 16;
}

/*******************************************************************************
 * Copyright (c) 2000, 2005 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
class Tool {
  public int id;
  public String name;
  public String group;
  public int type;
  public Runnable action;
  public Image image = null;
  public Object data;
  
  public Tool(int id, String name, String group, int type) {
    super();
    this.id = id;
    this.name = name;
    this.group = group;
    this.type = type;
  }
  public Tool(int id, String name, String group, int type, Object data) {
    this(id, name, group, type);
    this.data = data;
  }
}

/*******************************************************************************
 * Copyright (c) 2000, 2005 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
/**
 * A text drawing tool.
 */
class TextTool extends BasicPaintSession implements PaintTool {
  private ToolSettings settings;
  private String drawText = PaintExample.getResourceString("tool.Text.settings.defaulttext");
  /**
   * Constructs a PaintTool.
   * 
   * @param toolSettings the new tool settings
   * @param paintSurface the PaintSurface we will render on.
   */
  public TextTool(ToolSettings toolSettings, PaintSurface paintSurface) {
    super(paintSurface);
    set(toolSettings);
  }
  
  /**
   * Sets the tool"s settings.
   * 
   * @param toolSettings the new tool settings
   */
  public void set(ToolSettings toolSettings) {
    settings = toolSettings;
  }
  
  /**
   * Returns name associated with this tool.
   * 
   * @return the localized name of this tool
   */
  public String getDisplayName() {
    return PaintExample.getResourceString("tool.Text.label");
  }
  
  /**
   * Activates the tool.
   */
  public void beginSession() {
    getPaintSurface().setStatusMessage(PaintExample.getResourceString(
      "session.Text.message"));
  }
  
  /**
   * Deactivates the tool.
     */
  public void endSession() {
    getPaintSurface().clearRubberbandSelection();
  }
  
  /**
   * Aborts the current operation.
   */
  public void resetSession() {
    getPaintSurface().clearRubberbandSelection();
  }
  
  /**
   * Handles a mouseDown event.
   * 
   * @param event the mouse event detail information
   */
  public void mouseDown(MouseEvent event) {
    if (event.button == 1) {
      // draw with left mouse button
      getPaintSurface().rumitRubberbandSelection();
    } else {
      // set text with right mouse button
      getPaintSurface().clearRubberbandSelection();
      Shell shell = getPaintSurface().getShell();
      final Shell dialog = new Shell(shell, SWT.DIALOG_TRIM | SWT.APPLICATION_MODAL);
      dialog.setText(PaintExample.getResourceString("tool.Text.dialog.title"));
      dialog.setLayout(new GridLayout());
      Label label = new Label(dialog, SWT.NONE);
      label.setText(PaintExample.getResourceString("tool.Text.dialog.message"));
      label.setLayoutData(new GridData(SWT.FILL, SWT.CENTER, false, false));
      final Text field = new Text(dialog, SWT.SINGLE | SWT.BORDER);
      field.setText(drawText);
      field.selectAll();
      field.setLayoutData(new GridData(SWT.FILL, SWT.CENTER, true, false));
      Composite buttons = new Composite(dialog, SWT.NONE);
      GridLayout layout = new GridLayout(2, true);
      layout.marginWidth = 0;
      buttons.setLayout(layout);
      buttons.setLayoutData(new GridData(SWT.END, SWT.CENTER, false, false));
      Button ok = new Button(buttons, SWT.PUSH);
      ok.setText(PaintExample.getResourceString("OK"));
      ok.setLayoutData(new GridData(SWT.FILL, SWT.CENTER, false, false));
      ok.addSelectionListener(new SelectionAdapter() {
        public void widgetSelected(SelectionEvent e) {
          drawText = field.getText();
          dialog.dispose();
        }
      });
      Button cancel = new Button(buttons, SWT.PUSH);
      cancel.setText(PaintExample.getResourceString("Cancel"));
      cancel.addSelectionListener(new SelectionAdapter() {
        public void widgetSelected(SelectionEvent e) {
          dialog.dispose();
        }
      });
      dialog.setDefaultButton(ok);
      dialog.pack();
      dialog.open();
      Display display = dialog.getDisplay();
      while (! shell.isDisposed() && ! dialog.isDisposed()) {
        if (! display.readAndDispatch()) display.sleep();
      }
    }  
  }
  /**
   * Handles a mouseDoubleClick event.
   * 
   * @param event the mouse event detail information
   */
  public void mouseDoubleClick(MouseEvent event) {
  }
  /**
   * Handles a mouseUp event.
   * 
   * @param event the mouse event detail information
   */
  public void mouseUp(MouseEvent event) {
  }
  
  /**
   * Handles a mouseMove event.
   * 
   * @param event the mouse event detail information
   */
  public void mouseMove(MouseEvent event) {
    final PaintSurface ps = getPaintSurface();
    ps.setStatusCoord(ps.getCurrentPosition());
    ps.clearRubberbandSelection();
    ps.addRubberbandSelection(
      new TextFigure(settings.rumonForegroundColor, settings.rumonFont,
        drawText, event.x, event.y));
  }
}

/*******************************************************************************
 * Copyright (c) 2000, 2005 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
/**
 * 2D Rectangle object
 */
class TextFigure extends Figure {
  private Color  color;
  private Font   font;
  private String text;
  private int x, y;
  /**
   * Constructs a TextFigure
   * 
   * @param color the color for this object
   * @param font  the font for this object
   * @param text  the text to draw, tab and new-line expansion is performed
   * @param x     the virtual X coordinate of the top-left corner of the text bounding box
   * @param y     the virtual Y coordinate of the top-left corner of the text bounding box
   */
  public TextFigure(Color color, Font font, String text, int x, int y) {
    this.color = color; this.font = font; this.text = text; this.x = x; this.y = y;
  }
  public void draw(FigureDrawContext fdc) {
    Point p = fdc.toClientPoint(x, y);
    fdc.gc.setFont(font);
    fdc.gc.setForeground(color);
    fdc.gc.drawText(text, p.x, p.y, true);
  }
  public void addDamagedRegion(FigureDrawContext fdc, Region region) {
    Font oldFont = fdc.gc.getFont();
    fdc.gc.setFont(font);
    Point textExtent = fdc.gc.textExtent(text);
    fdc.gc.setFont(oldFont);
    region.add(fdc.toClientRectangle(x, y, x + textExtent.x, y + textExtent.y));
  }
}

/*******************************************************************************
 * Copyright (c) 2000, 2005 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
/**
 * 2D SolidRectangle object
 */
class SolidRoundedRectangleFigure extends Figure {
  private Color color;
  private int x1, y1, x2, y2, diameter;
  /**
   * Constructs a SolidRectangle
   * These objects are defined by any two diametrically opposing corners.
   * 
   * @param color the color for this object
   * @param x1 the virtual X coordinate of the first corner
   * @param y1 the virtual Y coordinate of the first corner
   * @param x2 the virtual X coordinate of the second corner
   * @param y2 the virtual Y coordinate of the second corner
   * @param diameter the diameter of curvature of all four corners
   */
  public SolidRoundedRectangleFigure(Color color, int x1, int y1, int x2, int y2, int diameter) {
    this.color = color; this.x1 = x1; this.y1 = y1; this.x2 = x2; this.y2 = y2;
    this.diameter = diameter;
  }
  public void draw(FigureDrawContext fdc) {
    Rectangle r = fdc.toClientRectangle(x1, y1, x2, y2);
    fdc.gc.setBackground(color);
    fdc.gc.fillRoundRectangle(r.x, r.y, r.width, r.height, diameter, diameter);
  }
  public void addDamagedRegion(FigureDrawContext fdc, Region region) {
    region.add(fdc.toClientRectangle(x1, y1, x2, y2));
  }
}

/*******************************************************************************
 * Copyright (c) 2000, 2005 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
/**
 * 2D SolidRectangle object
 */
class SolidRectangleFigure extends Figure {
  private Color color;
  private int x1, y1, x2, y2;
  /**
   * Constructs a SolidRectangle
   * These objects are defined by any two diametrically opposing corners.
   * 
   * @param color the color for this object
   * @param x1 the virtual X coordinate of the first corner
   * @param y1 the virtual Y coordinate of the first corner
   * @param x2 the virtual X coordinate of the second corner
   * @param y2 the virtual Y coordinate of the second corner
   */
  public SolidRectangleFigure(Color color, int x1, int y1, int x2, int y2) {
    this.color = color; this.x1 = x1; this.y1 = y1; this.x2 = x2; this.y2 = y2;
  }
  public void draw(FigureDrawContext fdc) {
    Rectangle r = fdc.toClientRectangle(x1, y1, x2, y2);
    fdc.gc.setBackground(color);
    fdc.gc.fillRectangle(r.x, r.y, r.width, r.height);
  }
  public void addDamagedRegion(FigureDrawContext fdc, Region region) {
    region.add(fdc.toClientRectangle(x1, y1, x2, y2));
  }
}

/*******************************************************************************
 * Copyright (c) 2000, 2005 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
/**
 * 2D Line object
 */
class SolidPolygonFigure extends Figure {
  private Color color;
  private int[] points;
  /**
   * Constructs a SolidPolygon
   * These objects are defined by a sequence of vertices.
   * 
   * @param color the color for this object
   * @param vertices the array of vertices making up the polygon
   * @param numPoint the number of valid points in the array (n >= 3)
   */
  public SolidPolygonFigure(Color color, Point[] vertices, int numPoints) {
    this.color = color;
    this.points = new int[numPoints * 2];
    for (int i = 0; i < numPoints; ++i) {
      points[i * 2] = vertices[i].x;
      points[i * 2 + 1] = vertices[i].y;
    }
  }
  public void draw(FigureDrawContext fdc) {
    int[] drawPoints = new int[points.length];
    for (int i = 0; i < points.length; i += 2) {
      drawPoints[i] = points[i] * fdc.xScale - fdc.xOffset;
      drawPoints[i + 1] = points[i + 1] * fdc.yScale - fdc.yOffset;
    }
    fdc.gc.setBackground(color);
    fdc.gc.fillPolygon(drawPoints);
  }
  public void addDamagedRegion(FigureDrawContext fdc, Region region) {
    int xmin = Integer.MAX_VALUE, ymin = Integer.MAX_VALUE;
    int xmax = Integer.MIN_VALUE, ymax = Integer.MIN_VALUE;
    for (int i = 0; i < points.length; i += 2) {
      if (points[i] < xmin) xmin = points[i];
      if (points[i] > xmax) xmax = points[i];
      if (points[i+1] < ymin) ymin = points[i+1];
      if (points[i+1] > ymax) ymax = points[i+1];
    }    
    region.add(fdc.toClientRectangle(xmin, ymin, xmax, ymax));
  }
}

/*******************************************************************************
 * Copyright (c) 2000, 2005 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
/**
 * 2D Solid Ellipse object
 */
class SolidEllipseFigure extends Figure {
  private Color color;
  private int x1, y1, x2, y2;
  /**
   * Constructs a SolidEllipse
   * These objects are defined by any two diametrically opposing corners of a box
   * bounding the ellipse.
   * 
   * @param color the color for this object
   * @param x1 the virtual X coordinate of the first corner
   * @param y1 the virtual Y coordinate of the first corner
   * @param x2 the virtual X coordinate of the second corner
   * @param y2 the virtual Y coordinate of the second corner
   */
  public SolidEllipseFigure(Color color, int x1, int y1, int x2, int y2) {
    this.color = color; this.x1 = x1; this.y1 = y1; this.x2 = x2; this.y2 = y2;
  }
  public void draw(FigureDrawContext fdc) {
    Rectangle r = fdc.toClientRectangle(x1, y1, x2, y2);
    fdc.gc.setBackground(color);
    fdc.gc.fillOval(r.x, r.y, r.width, r.height);
  }
  public void addDamagedRegion(FigureDrawContext fdc, Region region) {
    region.add(fdc.toClientRectangle(x1, y1, x2, y2));
  }
}

/*******************************************************************************
 * Copyright (c) 2000, 2005 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/

/**
 * The superclass for paint tools that contruct objects from individually
 * picked segments.
 */
abstract class SegmentedPaintSession extends BasicPaintSession {
  /**
   * The set of control points making up the segmented selection
   */
  private Vector /* of Point */ controlPoints = new Vector();
  /**
   * The previous figure (so that we can abort with right-button)
   */
  private Figure previousFigure = null;
  /**
   * The current figure (so that we can abort with right-button)
   */
  private Figure currentFigure = null;
  /**
   * Constructs a PaintSession.
   * 
   * @param paintSurface the drawing surface to use
   */
  protected SegmentedPaintSession(PaintSurface paintSurface) {
    super(paintSurface);
  }
  /**
   * Activates the tool.
   */
  public void beginSession() {
    getPaintSurface().setStatusMessage(PaintExample.getResourceString(
      "session.SegmentedInteractivePaint.message.anchorMode"));
    previousFigure = null;
    currentFigure = null;
    controlPoints.clear();
  }
  
  /**
   * Deactivates the tool.
     */
  public void endSession() {
    getPaintSurface().clearRubberbandSelection();
    if (previousFigure != null) getPaintSurface().drawFigure(previousFigure);
  }
  
  /**
   * Resets the tool.
   * Aborts any operation in progress.
   */
  public void resetSession() {
    getPaintSurface().clearRubberbandSelection();
    if (previousFigure != null) getPaintSurface().drawFigure(previousFigure);
    
    getPaintSurface().setStatusMessage(PaintExample.getResourceString(
      "session.SegmentedInteractivePaint.message.anchorMode"));
    previousFigure = null;
    currentFigure = null;
    controlPoints.clear();
  }
  /**
   * Handles a mouseDown event.
   * 
   * @param event the mouse event detail information
   */
  public void mouseDown(MouseEvent event) {
    if (event.button != 1) return;
    getPaintSurface().setStatusMessage(PaintExample.getResourceString(
      "session.SegmentedInteractivePaint.message.interactiveMode"));
    previousFigure = currentFigure;
    if (controlPoints.size() > 0) {
      final Point lastPoint = (Point) controlPoints.elementAt(controlPoints.size() - 1);
      if (lastPoint.x == event.x || lastPoint.y == event.y) return; // spurious event
    }
    controlPoints.add(new Point(event.x, event.y));
  }
  /**
   * Handles a mouseDoubleClick event.
   * 
   * @param event the mouse event detail information
   */
  public void mouseDoubleClick(MouseEvent event) {
    if (event.button != 1) return;
    if (controlPoints.size() >= 2) {
      getPaintSurface().clearRubberbandSelection();
      previousFigure = createFigure(
        (Point[]) controlPoints.toArray(new Point[controlPoints.size()]),
        controlPoints.size(), true);
    }
    resetSession();
  }
  /**
   * Handles a mouseUp event.
   * 
   * @param event the mouse event detail information
   */
  public void mouseUp(MouseEvent event) {
    if (event.button != 1) {
      resetSession(); // abort if right or middle mouse button pressed
      return;
    }
  }
  
  /**
   * Handles a mouseMove event.
   * 
   * @param event the mouse event detail information
   */
  public void mouseMove(MouseEvent event) {
    final PaintSurface ps = getPaintSurface();
    if (controlPoints.size() == 0) {
      ps.setStatusCoord(ps.getCurrentPosition());
      return; // spurious event
    } else {
      ps.setStatusCoordRange((Point) controlPoints.elementAt(controlPoints.size() - 1),
        ps.getCurrentPosition());
    }
    ps.clearRubberbandSelection();
    Point[] points = (Point[]) controlPoints.toArray(new Point[controlPoints.size() + 1]);
    points[controlPoints.size()] = ps.getCurrentPosition();
    currentFigure = createFigure(points, points.length, false);
    ps.addRubberbandSelection(currentFigure);
  }  
  /**
   * Template Method: Creates a Figure for drawing rubberband entities and the final product
   * 
   * @param points the array of control points
   * @param numPoints the number of valid points in the array (n >= 2)
   * @param closed true if the user double-clicked on the final control point
   */
  protected abstract Figure createFigure(Point[] points, int numPoints, boolean closed);
}

/*******************************************************************************
 * Copyright (c) 2000, 2005 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
/**
 * A drawing tool.
 */
class RoundedRectangleTool extends DragPaintSession implements PaintTool {
  private ToolSettings settings;
  /**
   * Constructs a RoundedRectangleTool.
   * 
   * @param toolSettings the new tool settings
   * @param paintSurface the PaintSurface we will render on.
   */
  public RoundedRectangleTool(ToolSettings toolSettings, PaintSurface paintSurface) {
    super(paintSurface);
    set(toolSettings);
  }
  
  /**
   * Sets the tool"s settings.
   * 
   * @param toolSettings the new tool settings
   */
  public void set(ToolSettings toolSettings) {
    settings = toolSettings;
  }
  
  /**
   * Returns name associated with this tool.
   * 
   * @return the localized name of this tool
   */
  public String getDisplayName() {
    return PaintExample.getResourceString("tool.RoundedRectangle.label");
  }
  /*
   * Template methods for drawing
   */
  protected Figure createFigure(Point a, Point b) {
    ContainerFigure container = new ContainerFigure();
    if (settings.rumonFillType != ToolSettings.ftNone)
      container.add(new SolidRoundedRectangleFigure(settings.rumonBackgroundColor,
        a.x, a.y, b.x, b.y, settings.roundedRectangleCornerDiameter));
    if (settings.rumonFillType != ToolSettings.ftSolid)
      container.add(new RoundedRectangleFigure(settings.rumonForegroundColor, settings.rumonBackgroundColor,
        settings.rumonLineStyle, a.x, a.y, b.x, b.y, settings.roundedRectangleCornerDiameter));
    return container;
  }
}

/*******************************************************************************
 * Copyright (c) 2000, 2005 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
/**
 * 2D Rectangle object
 */
class RoundedRectangleFigure extends Figure {
  private Color foregroundColor, backgroundColor;
  private int lineStyle, x1, y1, x2, y2, diameter;
  /**
   * Constructs a Rectangle
   * These objects are defined by any two diametrically opposing corners.
   * 
   * @param color the color for this object
   * @param lineStyle the line style for this object
   * @param x1 the virtual X coordinate of the first corner
   * @param y1 the virtual Y coordinate of the first corner
   * @param x2 the virtual X coordinate of the second corner
   * @param y2 the virtual Y coordinate of the second corner
   * @param diameter the diameter of curvature of all four corners
   */
  public RoundedRectangleFigure(Color foregroundColor, Color backgroundColor, int lineStyle, int x1, int y1, int x2, int y2, int diameter) {
    this.foregroundColor = foregroundColor;
    this.backgroundColor = backgroundColor;
    this.lineStyle = lineStyle;
    this.x1 = x1; this.y1 = y1; this.x2 = x2; this.y2 = y2;
    this.diameter = diameter;
  }
  public void draw(FigureDrawContext fdc) {
    Rectangle r = fdc.toClientRectangle(x1, y1, x2, y2);
    fdc.gc.setForeground(foregroundColor);
    fdc.gc.setBackground(backgroundColor);
    fdc.gc.setLineStyle(lineStyle);
    fdc.gc.drawRoundRectangle(r.x, r.y, r.width - 1, r.height - 1, diameter, diameter);
    fdc.gc.setLineStyle(SWT.LINE_SOLID);
  }
  public void addDamagedRegion(FigureDrawContext fdc, Region region) {
    region.add(fdc.toClientRectangle(x1, y1, x2, y2));
  }
}

/*******************************************************************************
 * Copyright (c) 2000, 2005 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
/**
 * A drawing tool.
 */
class RectangleTool extends DragPaintSession implements PaintTool {
  private ToolSettings settings;
  /**
   * Constructs a RectangleTool.
   * 
   * @param toolSettings the new tool settings
   * @param paintSurface the PaintSurface we will render on.
   */
  public RectangleTool(ToolSettings toolSettings, PaintSurface paintSurface) {
    super(paintSurface);
    set(toolSettings);
  }
  
  /**
   * Sets the tool"s settings.
   * 
   * @param toolSettings the new tool settings
   */
  public void set(ToolSettings toolSettings) {
    settings = toolSettings;
  }
  
  /**
   * Returns name associated with this tool.
   * 
   * @return the localized name of this tool
   */
  public String getDisplayName() {
    return PaintExample.getResourceString("tool.Rectangle.label");
  }
  /*
   * Template method for drawing
   */
  protected Figure createFigure(Point a, Point b) {
    switch (settings.rumonFillType) {
      default:
      case ToolSettings.ftNone:
        return new RectangleFigure(settings.rumonForegroundColor, settings.rumonBackgroundColor, settings.rumonLineStyle,
          a.x, a.y, b.x, b.y);
      case ToolSettings.ftSolid:
        return new SolidRectangleFigure(settings.rumonBackgroundColor, a.x, a.y, b.x, b.y);
      case ToolSettings.ftOutline: {
        ContainerFigure container = new ContainerFigure();
        container.add(new SolidRectangleFigure(settings.rumonBackgroundColor, a.x, a.y, b.x, b.y));
        container.add(new RectangleFigure(settings.rumonForegroundColor, settings.rumonBackgroundColor, settings.rumonLineStyle,
          a.x, a.y, b.x, b.y));
        return container;
      }
    }
  }
}

/*******************************************************************************
 * Copyright (c) 2000, 2005 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
/**
 * 2D Rectangle object
 */
class RectangleFigure extends Figure {
  private Color foregroundColor, backgroundColor;
  private int lineStyle, x1, y1, x2, y2;
  /**
   * Constructs a Rectangle
   * These objects are defined by any two diametrically opposing corners.
   * 
   * @param color the color for this object
   * @param lineStyle the line style for this object
   * @param x1 the virtual X coordinate of the first corner
   * @param y1 the virtual Y coordinate of the first corner
   * @param x2 the virtual X coordinate of the second corner
   * @param y2 the virtual Y coordinate of the second corner
   */
  public RectangleFigure(Color foregroundColor, Color backgroundColor, int lineStyle, int x1, int y1, int x2, int y2) {
    this.foregroundColor = foregroundColor;
    this.backgroundColor = backgroundColor;
    this.lineStyle = lineStyle;
    this.x1 = x1; this.y1 = y1; this.x2 = x2; this.y2 = y2;
  }
  public void draw(FigureDrawContext fdc) {
    Rectangle r = fdc.toClientRectangle(x1, y1, x2, y2);
    fdc.gc.setForeground(foregroundColor);
    fdc.gc.setBackground(backgroundColor);
    fdc.gc.setLineStyle(lineStyle);
    fdc.gc.drawRectangle(r.x, r.y, r.width - 1, r.height - 1);
    fdc.gc.setLineStyle(SWT.LINE_SOLID);
  }
  public void addDamagedRegion(FigureDrawContext fdc, Region region) {
    region.add(fdc.toClientRectangle(x1, y1, x2, y2));
  }
}

/*******************************************************************************
 * Copyright (c) 2000, 2005 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
/**
 * A polyline drawing tool.
 */
class PolyLineTool extends SegmentedPaintSession implements PaintTool {
  private ToolSettings settings;
  /**
   * Constructs a PolyLineTool.
   * 
   * @param toolSettings the new tool settings
   * @param paintSurface the PaintSurface we will render on.
   */
  public PolyLineTool(ToolSettings toolSettings, PaintSurface paintSurface) {
    super(paintSurface);
    set(toolSettings);
  }
  
  /**
   * Sets the tool"s settings.
   * 
   * @param toolSettings the new tool settings
   */
  public void set(ToolSettings toolSettings) {
    settings = toolSettings;
  }
  /**
   * Returns the name associated with this tool.
   * 
   * @return the localized name of this tool
   */
  public String getDisplayName() {
    return PaintExample.getResourceString("tool.PolyLine.label");
  }
  /*
   * Template methods for drawing
   */
  protected Figure createFigure(Point[] points, int numPoints, boolean closed) {
    ContainerFigure container = new ContainerFigure();
    if (closed && settings.rumonFillType != ToolSettings.ftNone && numPoints >= 3) {
      container.add(new SolidPolygonFigure(settings.rumonBackgroundColor, points, numPoints));
    }
    if (! closed || settings.rumonFillType != ToolSettings.ftSolid || numPoints < 3) {
      for (int i = 0; i < numPoints - 1; ++i) {
        final Point a = points[i];
        final Point b = points[i + 1];
        container.add(new LineFigure(settings.rumonForegroundColor, settings.rumonBackgroundColor, settings.rumonLineStyle,
          a.x, a.y, b.x, b.y));
      }
      if (closed) {
        final Point a = points[points.length - 1];
        final Point b = points[0];
        container.add(new LineFigure(settings.rumonForegroundColor, settings.rumonBackgroundColor, settings.rumonLineStyle,
          a.x, a.y, b.x, b.y));
      }
    }
    return container;
  }
}

/*******************************************************************************
 * Copyright (c) 2000, 2005 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
/**
 * 2D Point object
 */
class PointFigure extends Figure {
  private Color color;
  private int x, y;
  /**
   * Constructs a Point
   * 
   * @param color the color for this object
   * @param x the virtual X coordinate of the first end-point
   * @param y the virtual Y coordinate of the first end-point
   */
  public PointFigure(Color color, int x, int y) {
    this.color = color; this.x = x; this.y = y;
  }
  public void draw(FigureDrawContext fdc) {
    Point p = fdc.toClientPoint(x, y);
    fdc.gc.setBackground(color);
    fdc.gc.fillRectangle(p.x, p.y, 1, 1);
  }
  public void addDamagedRegion(FigureDrawContext fdc, Region region) {
    region.add(fdc.toClientRectangle(x, y, x, y));
  }
}

/*******************************************************************************
 * Copyright (c) 2000, 2005 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
/**
 * A pencil tool.
 */
class PencilTool extends ContinuousPaintSession implements PaintTool {
  private ToolSettings settings;
  
  /**
   * Constructs a pencil tool.
   * 
   * @param toolSettings the new tool settings
   * @param getPaintSurface() the PaintSurface we will render on.
   */
  public PencilTool(ToolSettings toolSettings, PaintSurface paintSurface) {
    super(paintSurface);
    set(toolSettings);
  }
  
  /**
   * Sets the tool"s settings.
   * 
   * @param toolSettings the new tool settings
   */
  public void set(ToolSettings toolSettings) {
    settings = toolSettings;
  }
  /**
   * Returns the name associated with this tool.
   * 
   * @return the localized name of this tool
   */
  public String getDisplayName() {
    return PaintExample.getResourceString("tool.Pencil.label");
  }
  /*
   * Template method for drawing
   */
  public void render(final Point point) {
    final PaintSurface ps = getPaintSurface();
    ps.drawFigure(new PointFigure(settings.rumonForegroundColor, point.x, point.y));
  }
}

/*******************************************************************************
 * Copyright (c) 2000, 2005 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
interface PaintTool extends PaintSession {
  /**
   * Sets the tool"s settings.
   * 
   * @param toolSettings the new tool settings
   */
  public void set(ToolSettings toolSettings);
}

/*******************************************************************************
 * Copyright (c) 2000, 2005 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
/**
 * Manages a simple drawing surface.
 */
class PaintSurface {
  private Point currentPosition = new Point(0, 0);
  private Canvas paintCanvas;
  private PaintSession paintSession;
  private Image image;
  private Image paintImage; // buffer for refresh blits
  private int   imageWidth, imageHeight;
  private int   visibleWidth, visibleHeight;
  private FigureDrawContext displayFDC = new FigureDrawContext();
  private FigureDrawContext imageFDC = new FigureDrawContext();
  private FigureDrawContext paintFDC = new FigureDrawContext();
  /* Rubberband */
  private ContainerFigure rubberband = new ContainerFigure();
    // the active rubberband selection
  private int rubberbandHiddenNestingCount = 0;
    // always >= 0, if > 0 rubberband has been hidden
  /* Status */
  private Text statusText;
  private String statusActionInfo, statusMessageInfo, statusCoordInfo;
  /**
   * Constructs a PaintSurface.
   * <p>
   * paintCanvas must have SWT.NO_REDRAW_RESIZE and SWT.NO_BACKGROUND styles,
   *     and may have SWT.V_SCROLL and/or SWT.H_SCROLL.
   * </p>
   * @param paintCanvas the Canvas object in which to render
   * @param paintStatus the PaintStatus object to use for providing user feedback
   * @param fillColor the color to fill the canvas with initially
   */
  public PaintSurface(Canvas paintCanvas, Text statusText, Color fillColor) {
    this.paintCanvas = paintCanvas;
    this.statusText = statusText;
    clearStatus();
    /* Set up the drawing surface */
    Rectangle displayRect = paintCanvas.getDisplay().getClientArea();
    imageWidth = displayRect.width;
    imageHeight = displayRect.height;
    image = new Image(paintCanvas.getDisplay(), imageWidth, imageHeight);
    imageFDC.gc = new GC(image);
    imageFDC.gc.setBackground(fillColor);
    imageFDC.gc.fillRectangle(0, 0, imageWidth, imageHeight);
    displayFDC.gc = new GC(paintCanvas);
    /* Initialize the session */
    setPaintSession(null);
    /* Add our listeners */
    paintCanvas.addDisposeListener(new DisposeListener() {
      public void widgetDisposed(DisposeEvent e) {
        displayFDC.gc.dispose();
      }      
    });
    paintCanvas.addMouseListener(new MouseAdapter() {
      public void mouseDown(MouseEvent event) {
        processMouseEventCoordinates(event);
        if (paintSession != null) paintSession.mouseDown(event);
      }
      public void mouseUp(MouseEvent event) {
        processMouseEventCoordinates(event);
        if (paintSession != null) paintSession.mouseUp(event);
      }
      public void mouseDoubleClick(MouseEvent event) {
        processMouseEventCoordinates(event);
        if (paintSession != null) paintSession.mouseDoubleClick(event);
      }      
    });
    paintCanvas.addMouseMoveListener(new MouseMoveListener() {
      public void mouseMove(MouseEvent event) {
        processMouseEventCoordinates(event);
        if (paintSession != null) paintSession.mouseMove(event);
      }
    });
    paintCanvas.addPaintListener(new PaintListener() {
      public void paintControl(PaintEvent event) {
        if (rubberband.isEmpty()) {
          // Nothing to merge, so we just refresh
          event.gc.drawImage(image,
            displayFDC.xOffset + event.x, displayFDC.yOffset + event.y, event.width, event.height,
            event.x, event.y, event.width, event.height);
        } else {
          /*
           * Avoid flicker when merging overlayed objects by constructing the image on
           * a backbuffer first, then blitting it to the screen.
           */
          // Check that the backbuffer is large enough
          if (paintImage != null) {
            Rectangle rect = paintImage.getBounds();
            if ((event.width + event.x > rect.width) ||
              (event.height + event.y > rect.height)) {
              paintFDC.gc.dispose();
              paintImage.dispose();
              paintImage = null;
            }
          }
          if (paintImage == null) {
            Display display = getDisplay();
            Rectangle rect = display.getClientArea();
            paintImage = new Image(display,
              Math.max(rect.width, event.width + event.x),
              Math.max(rect.height, event.height + event.y));
            paintFDC.gc = new GC(paintImage);
          }
          // Setup clipping and the FDC
          Region clipRegion = new Region();
          event.gc.getClipping(clipRegion);          
          paintFDC.gc.setClipping(clipRegion);
          clipRegion.dispose();
          paintFDC.xOffset = displayFDC.xOffset;
          paintFDC.yOffset = displayFDC.yOffset;
          paintFDC.xScale = displayFDC.xScale;
          paintFDC.yScale = displayFDC.yScale;
          
          // Merge the overlayed objects into the image, then blit
          paintFDC.gc.drawImage(image,
            displayFDC.xOffset + event.x, displayFDC.yOffset + event.y, event.width, event.height,
            event.x, event.y, event.width, event.height);
          rubberband.draw(paintFDC);
          event.gc.drawImage(paintImage,
            event.x, event.y, event.width, event.height,
            event.x, event.y, event.width, event.height);
        }
      }
    });
    paintCanvas.addControlListener(new ControlAdapter() {
      public void controlResized(ControlEvent event) {
        handleResize();
      }      
    });
    /* Set up the paint canvas scroll bars */
    ScrollBar horizontal = paintCanvas.getHorizontalBar();
    horizontal.setVisible(true);
    horizontal.addSelectionListener(new SelectionAdapter() {
      public void widgetSelected(SelectionEvent event) {
        scrollHorizontally((ScrollBar)event.widget);
      }
    });
    ScrollBar vertical = paintCanvas.getVerticalBar();
    vertical.setVisible(true);
    vertical.addSelectionListener(new SelectionAdapter() {
      public void widgetSelected(SelectionEvent event) {
        scrollVertically((ScrollBar)event.widget);
      }
    });
    handleResize();
  }
  
  /**
   * Disposes of the PaintSurface"s resources.
   */
  public void dispose() {
    imageFDC.gc.dispose();
    image.dispose();
    if (paintImage != null) {
      paintImage.dispose();
      paintFDC.gc.dispose();
    }
    currentPosition = null;
    paintCanvas = null;
    paintSession = null;
    image = null;
    paintImage = null;
    displayFDC = null;
    imageFDC = null;
    paintFDC = null;
    rubberband = null;
    statusText = null;
    statusActionInfo = null;
    statusMessageInfo = null;
    statusCoordInfo = null;
  }
  /**
   * Called when we must grab focus.
   */
  public void setFocus()  {
    paintCanvas.setFocus();
  }
  /**
   * Returns the Display on which the PaintSurface resides.
   * @return the Display
   */
  public Display getDisplay() {
    return paintCanvas.getDisplay();
  }
  /**
   * Returns the Shell in which the PaintSurface resides.
   * @return the Shell
   */
  public Shell getShell() {
    return paintCanvas.getShell();
  }
  /**
   * Sets the current paint session.
   * <p>
   * If oldPaintSession != paintSession calls oldPaintSession.end()
   * and paintSession.begin()
   * </p>
   * 
   * @param paintSession the paint session to activate; null to disable all sessions
   */
  public void setPaintSession(PaintSession paintSession) {
    if (this.paintSession != null) {
      if (this.paintSession == paintSession) return;
      this.paintSession.endSession();
    }
    this.paintSession = paintSession;
    clearStatus();
    if (paintSession != null) {
      setStatusAction(paintSession.getDisplayName());
      paintSession.beginSession();
    } else {
      setStatusAction(PaintExample.getResourceString("tool.Null.label"));
      setStatusMessage(PaintExample.getResourceString("session.Null.message"));
    }
  }
  /**
   * Returns the current paint session.
   * 
   * @return the current paint session, null if none is active
   */
  public PaintSession getPaintSession() {
    return paintSession;
  }
  /**
   * Returns the current paint tool.
   * 
   * @return the current paint tool, null if none is active (though some other session
   *         might be)
   */
  public PaintTool getPaintTool() {
    return (paintSession != null && paintSession instanceof PaintTool) ?
      (PaintTool)paintSession : null;
  }
  /**
   * Returns the current position in an interactive operation.
   *
   * @return the last known position of the pointer
   */
  public Point getCurrentPosition() {
    return currentPosition;
  }
  /**
   * Draws a Figure object to the screen and to the backing store permanently.
   * 
   * @param object the object to draw onscreen
   */
  public void drawFigure(Figure object) {
    object.draw(imageFDC);
    object.draw(displayFDC);
  }
  /**
   * Adds a Figure object to the active rubberband selection.
   * <p>
   * This object will be drawn to the screen as a preview and refreshed appropriately
   * until the selection is either cleared or committed.
   * </p>
   * 
   * @param object the object to add to the selection
   */
  public void addRubberbandSelection(Figure object) {
    rubberband.add(object);
    if (! isRubberbandHidden()) object.draw(displayFDC);
  }
  /**
   * Clears the active rubberband selection.
   * <p>
   * Erases any rubberband objects on the screen then clears the selection.
   * </p>
   */
  public void clearRubberbandSelection() {
    if (! isRubberbandHidden()) {
      Region region = new Region();
      rubberband.addDamagedRegion(displayFDC, region);
      Rectangle r = region.getBounds();
      paintCanvas.redraw(r.x, r.y, r.width, r.height, true);
      region.dispose();
    }
    rubberband.clear();
  }
  /**
   * Commits the active rubberband selection.
   * <p>
   * Redraws any rubberband objects on the screen as permanent objects then clears the selection.
   * </p>
   */
  public void commitRubberbandSelection() {
    rubberband.draw(imageFDC);
    if (isRubberbandHidden()) rubberband.draw(displayFDC);
    rubberband.clear();
  }
  
  /**
   * Hides the rubberband (but does not eliminate it).
   * <p>
   * Increments by one the rubberband "hide" nesting count.  The rubberband
   * is hidden from view (but remains active) if it wasn"t already hidden.
   * </p>
   */
  public void hideRubberband() {
    if (rubberbandHiddenNestingCount++ <= 0) {
      Region region = new Region();
      rubberband.addDamagedRegion(displayFDC, region);
      Rectangle r = region.getBounds();
      paintCanvas.redraw(r.x, r.y, r.width, r.height, true);
      region.dispose();
    }
  }    
  /**
   * Shows (un-hides) the rubberband.
   * <p>
   * Decrements by one the rubberband "hide" nesting count.  The rubberband
   * is only made visible when showRubberband() has been called once for each
   * previous hideRubberband().  It is not permitted to call showRubberband() if
   * the rubber band is not presently hidden.
   * </p>
   */
  public void showRubberband() {
    if (rubberbandHiddenNestingCount <= 0)
      throw new IllegalStateException("rubberbandHiddenNestingCount > 0");
    if (--rubberbandHiddenNestingCount == 0) {
      rubberband.draw(displayFDC);
    }
  }
  
  /**
   * Determines if the rubberband is hidden.
   * 
   * @return true iff the rubber is hidden
   */
  public boolean isRubberbandHidden() {
    return rubberbandHiddenNestingCount > 0;
  }
  /**
   * Handles a horizontal scroll event
   * 
   * @param scrollbar the horizontal scroll bar that posted this event
   */
  public void scrollHorizontally(ScrollBar scrollBar) {
    if (image == null) return;
    if (imageWidth > visibleWidth) {
      final int oldOffset = displayFDC.xOffset;
      final int newOffset = Math.min(scrollBar.getSelection(), imageWidth - visibleWidth);
      if (oldOffset != newOffset) {
        paintCanvas.update();
        displayFDC.xOffset = newOffset;
        paintCanvas.scroll(Math.max(oldOffset - newOffset, 0), 0, Math.max(newOffset - oldOffset, 0), 0,
          visibleWidth, visibleHeight, false);
      }
    }
  }
  /**
   * Handles a vertical scroll event
   * 
   * @param scrollbar the vertical scroll bar that posted this event
   */
  public void scrollVertically(ScrollBar scrollBar) {
    if (image == null) return;
    if (imageHeight > visibleHeight) {
      final int oldOffset = displayFDC.yOffset;
      final int newOffset = Math.min(scrollBar.getSelection(), imageHeight - visibleHeight);
      if (oldOffset != newOffset) {
        paintCanvas.update();
        displayFDC.yOffset = newOffset;
        paintCanvas.scroll(0, Math.max(oldOffset - newOffset, 0), 0, Math.max(newOffset - oldOffset, 0),
          visibleWidth, visibleHeight, false);
      }
    }
  }
  
  /**
   * Handles resize events
   */
  private void handleResize() {
    paintCanvas.update();
    Rectangle visibleRect = paintCanvas.getClientArea();
    visibleWidth = visibleRect.width;
    visibleHeight = visibleRect.height;
    ScrollBar horizontal = paintCanvas.getHorizontalBar();
    if (horizontal != null) {
      displayFDC.xOffset = Math.min(horizontal.getSelection(), imageWidth - visibleWidth);
      if (imageWidth <= visibleWidth) {
        horizontal.setEnabled(false);
        horizontal.setSelection(0);
      } else {
        horizontal.setEnabled(true);
        horizontal.setValues(displayFDC.xOffset, 0, imageWidth, visibleWidth,
          8, visibleWidth);
      }
    }
    ScrollBar vertical = paintCanvas.getVerticalBar();
    if (vertical != null) {
      displayFDC.yOffset = Math.min(vertical.getSelection(), imageHeight - visibleHeight);
      if (imageHeight <= visibleHeight) {
        vertical.setEnabled(false);
        vertical.setSelection(0);
      } else {
        vertical.setEnabled(true);
        vertical.setValues(displayFDC.yOffset, 0, imageHeight, visibleHeight,
          8, visibleHeight);
      }
    }
  }
  /**
   * Virtualizes MouseEvent coordinates and stores the current position.
   */
  private void processMouseEventCoordinates(MouseEvent event) {
    currentPosition.x = event.x =
      Math.min(Math.max(event.x, 0), visibleWidth - 1) + displayFDC.xOffset;
    currentPosition.y = event.y =
      Math.min(Math.max(event.y, 0), visibleHeight - 1) + displayFDC.yOffset;
  }
  
  /**
   * Clears the status bar.
   */
  public void clearStatus() {
    statusActionInfo = "";
    statusMessageInfo = "";
    statusCoordInfo = "";
    updateStatus();
  }
  /**
   * Sets the status bar action text.
   *
   * @param action the action in progress, null to clear
   */
  public void setStatusAction(String action) {
    statusActionInfo = (action != null) ? action : "";
    updateStatus();
  }
  
  /**
   * Sets the status bar message text.
   * 
   * @param message the message to display, null to clear
   */
  public void setStatusMessage(String message) {
    statusMessageInfo = (message != null) ? message : "";
    updateStatus();
  }
  /**
   * Sets the coordinates in the status bar.
   * 
   * @param coord the coordinates to display, null to clear
   */
  public void setStatusCoord(Point coord) {
    statusCoordInfo = (coord != null) ? PaintExample.getResourceString("status.Coord.format", new Object[]
      { new Integer(coord.x), new Integer(coord.y)}) : "";
    updateStatus();
  }
  /**
   * Sets the coordinate range in the status bar.
   * 
   * @param a the "from" coordinate, must not be null
   * @param b the "to" coordinate, must not be null
   */
  public void setStatusCoordRange(Point a, Point b) {
    statusCoordInfo = PaintExample.getResourceString("status.CoordRange.format", new Object[]
      { new Integer(a.x), new Integer(a.y), new Integer(b.x), new Integer(b.y)});
    updateStatus();
  }
  /**
   * Updates the display.
   */
  private void updateStatus() {
    statusText.setText(
      PaintExample.getResourceString("status.Bar.format", new Object[]
      { statusActionInfo, statusMessageInfo, statusCoordInfo }));
  }
}

/*******************************************************************************
 * Copyright (c) 2000, 2005 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
/**
 * Manages an interactive paint session.
 * Note that the coordinates received via the listener interfaces are virtualized to zero-origin
 * relative to the painting surface.
 */ 
interface PaintSession extends MouseListener, MouseMoveListener {
  /**
   * Returns the paint surface associated with this paint session
   * 
   * @return the associated PaintSurface
   */
  public PaintSurface getPaintSurface();
  /**
   * Activates the session.
   * 
   * Note: When overriding this method, call super.beginSession() at method start.
   */
  public abstract void beginSession();
  
  /**
   * Deactivates the session.
     *
   * Note: When overriding this method, call super.endSession() at method exit.
     */
  public abstract void endSession();
  
  /**
   * Resets the session.
   * Aborts any operation in progress.
   * 
   * Note: When overriding this method, call super.resetSession() at method exit.
   */
  public abstract void resetSession();
  
  
  /**
   * Returns the name associated with this tool.
   * 
   * @return the localized name of this tool
   */
  public String getDisplayName();
}

/*******************************************************************************
 * Copyright (c) 2000, 2005 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
/**
 * A line drawing tool
 */
class LineTool extends DragPaintSession implements PaintTool {
  private ToolSettings settings;
  /**
   * Constructs a LineTool.
   * 
   * @param toolSettings the new tool settings
   * @param paintSurface the PaintSurface we will render on.
   */
  public LineTool(ToolSettings toolSettings, PaintSurface paintSurface) {
    super(paintSurface);
    set(toolSettings);
  }
  
  /**
   * Sets the tool"s settings.
   * 
   * @param toolSettings the new tool settings
   */
  public void set(ToolSettings toolSettings) {
    settings = toolSettings;
  }
  
  /**
   * Returns name associated with this tool.
   * 
   * @return the localized name of this tool
   */
  public String getDisplayName() {
    return PaintExample.getResourceString("tool.Line.label");
  }
  /*
   * Template methods for drawing
   */
  protected Figure createFigure(Point a, Point b) {
    return new LineFigure(settings.rumonForegroundColor, settings.rumonBackgroundColor, settings.rumonLineStyle,
      a.x, a.y, b.x, b.y);
  }
}

/*******************************************************************************
 * Copyright (c) 2000, 2005 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
/**
 * 2D Line object
 */
class LineFigure extends Figure {
  private Color foregroundColor, backgroundColor;
  private int lineStyle, x1, y1, x2, y2;
  /**
   * Constructs a Line
   * These objects are defined by their two end-points.
   * 
   * @param color the color for this object
   * @param lineStyle the line style for this object
   * @param x1 the virtual X coordinate of the first end-point
   * @param y1 the virtual Y coordinate of the first end-point
   * @param x2 the virtual X coordinate of the second end-point
   * @param y2 the virtual Y coordinate of the second end-point
   */
  public LineFigure(Color foregroundColor, Color backgroundColor, int lineStyle, int x1, int y1, int x2, int y2) {
    this.foregroundColor = foregroundColor;
    this.backgroundColor = backgroundColor;
    this.lineStyle = lineStyle;
    this.x1 = x1; this.y1 = y1; this.x2 = x2; this.y2 = y2;
  }
  public void draw(FigureDrawContext fdc) {
    Point p1 = fdc.toClientPoint(x1, y1);
    Point p2 = fdc.toClientPoint(x2, y2);
    fdc.gc.setForeground(foregroundColor);
    fdc.gc.setBackground(backgroundColor);
    fdc.gc.setLineStyle(lineStyle);
    fdc.gc.drawLine(p1.x, p1.y, p2.x, p2.y);
    fdc.gc.setLineStyle(SWT.LINE_SOLID);
  }
  public void addDamagedRegion(FigureDrawContext fdc, Region region) {
    region.add(fdc.toClientRectangle(x1, y1, x2, y2));
  }
}

/*******************************************************************************
 * Copyright (c) 2000, 2005 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
class FigureDrawContext {
  /*
   * <p>
   * The GC must be set up as follows
   * (it will be returned to this state upon completion of drawing operations)
   * <ul>
   *   <li>setXORMode(false)
   * </ul>
   * </p>
   */
  public GC gc = null;
  public int xOffset = 0, yOffset = 0; // substract to get GC coords
  public int xScale = 1, yScale = 1;
  
  public Rectangle toClientRectangle(int x1, int y1, int x2, int y2) {
    return new Rectangle(
      Math.min(x1, x2) * xScale - xOffset,
      Math.min(y1, y2) * yScale - yOffset,
      (Math.abs(x2 - x1) + 1) * xScale,
      (Math.abs(y2 - y1) + 1) * yScale);
  }
  public Point toClientPoint(int x, int y) {
    return new Point(x * xScale - xOffset, y * yScale - yOffset);
  }
}

/*******************************************************************************
 * Copyright (c) 2000, 2005 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
/**
 * Superinterface for all drawing objects.
 * All drawing objects know how to render themselved to the screen and can draw a
 * temporary version of themselves for previewing the general appearance of the
 * object onscreen before it gets committed.
 */
abstract class Figure {
  /**
   * Draws this object.
   * 
   * @param fdc a parameter block specifying drawing-related information
   */
  public abstract void draw(FigureDrawContext fdc);
  /**
   * Computes the damaged screen region caused by drawing this object (imprecise), then
   * appends it to the supplied region.
   * 
   * @param fdc a parameter block specifying drawing-related information
   * @param region a region to which additional damage areas will be added
   */
  public abstract void addDamagedRegion(FigureDrawContext fdc, Region region);
}

/*******************************************************************************
 * Copyright (c) 2000, 2005 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
/**
 * A drawing tool.
 */
class EllipseTool extends DragPaintSession implements PaintTool {
  private ToolSettings settings;
  /**
   * Constructs a EllipseTool.
   * 
   * @param toolSettings the new tool settings
   * @param paintSurface the PaintSurface we will render on.
   */
  public EllipseTool(ToolSettings toolSettings, PaintSurface paintSurface) {
    super(paintSurface);
    set(toolSettings);
  }
  /**
   * Sets the tool"s settings.
   * 
   * @param toolSettings the new tool settings
   */
  public void set(ToolSettings toolSettings) {
    settings = toolSettings;
  }
  /**
   * Returns name associated with this tool.
   * 
   * @return the localized name of this tool
   */
  public String getDisplayName() {
    return PaintExample.getResourceString("tool.Ellipse.label");
  }
  /*
   * Template methods for drawing
   */
  protected Figure createFigure(Point a, Point b) {
    ContainerFigure container = new ContainerFigure();
    if (settings.rumonFillType != ToolSettings.ftNone)
      container.add(new SolidEllipseFigure(settings.rumonBackgroundColor, a.x, a.y, b.x, b.y));
    if (settings.rumonFillType != ToolSettings.ftSolid)
      container.add(new EllipseFigure(settings.rumonForegroundColor, settings.rumonBackgroundColor, settings.rumonLineStyle,
        a.x, a.y, b.x, b.y));
    return container;
  }
}

/*******************************************************************************
 * Copyright (c) 2000, 2005 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
/**
 * 2D Ellipse object
 */
class EllipseFigure extends Figure {
  private Color foregroundColor, backgroundColor;
  private int lineStyle, x1, y1, x2, y2;
  /**
   * Constructs an Ellipse
   * These objects are defined by any two diametrically opposing corners of a box
   * bounding the ellipse.
   * 
   * @param color the color for this object
   * @param lineStyle the line style for this object
   * @param x1 the virtual X coordinate of the first corner
   * @param y1 the virtual Y coordinate of the first corner
   * @param x2 the virtual X coordinate of the second corner
   * @param y2 the virtual Y coordinate of the second corner
   */
  public EllipseFigure(Color foregroundColor, Color backgroundColor, int lineStyle, int x1, int y1, int x2, int y2) {
    this.foregroundColor = foregroundColor;
    this.backgroundColor = backgroundColor;
    this.lineStyle = lineStyle;
    this.x1 = x1; this.y1 = y1; this.x2 = x2; this.y2 = y2;
  }
  public void draw(FigureDrawContext fdc) {
    Rectangle r = fdc.toClientRectangle(x1, y1, x2, y2);
    fdc.gc.setForeground(foregroundColor);
    fdc.gc.setBackground(backgroundColor);
    fdc.gc.setLineStyle(lineStyle);
    fdc.gc.drawOval(r.x, r.y, r.width - 1, r.height - 1);
    fdc.gc.setLineStyle(SWT.LINE_SOLID);
  }
  public void addDamagedRegion(FigureDrawContext fdc, Region region) {
    region.add(fdc.toClientRectangle(x1, y1, x2, y2));
  }
}

/*******************************************************************************
 * Copyright (c) 2000, 2005 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
/**
 * The superclass for paint tools that use click-drag-release motions to
 * draw objects.
 */
abstract class DragPaintSession extends BasicPaintSession {
  /**
   * True if a click-drag is in progress
   */
  private boolean dragInProgress = false;
  
  /**
   * The position of the first click in a click-drag
   */
  private Point anchorPosition = new Point(-1, -1);
  /**
   * A temporary point
   */
  private Point tempPosition = new Point(-1, -1);
  
  /**
   * Constructs a PaintSession.
   * 
   * @param getPaintSurface() the drawing surface to use
   */
  protected DragPaintSession(PaintSurface paintSurface) {
    super(paintSurface);
  }
  /**
   * Activates the tool.
   */
  public void beginSession() {
    getPaintSurface().
      setStatusMessage(PaintExample.getResourceString("session.DragInteractivePaint.message"));
    anchorPosition.x = -1;
    dragInProgress = false;
  }
  
  /**
   * Deactivates the tool.
     */
  public void endSession() {
  }
  
  /**
   * Resets the tool.
   * Aborts any operation in progress.
   */
  public void resetSession() {
    getPaintSurface().clearRubberbandSelection();
    anchorPosition.x = -1;
    dragInProgress = false;
  }
  /**
   * Handles a mouseDown event.
   * 
   * @param event the mouse event detail information
   */
  public void mouseDown(MouseEvent event) {
    if (event.button != 1) return;
    if (dragInProgress) return; // spurious event
    dragInProgress = true;
    
    anchorPosition.x = event.x;
    anchorPosition.y = event.y;
  }
  /**
   * Handles a mouseDoubleClick event.
   * 
   * @param event the mouse event detail information
   */
  public void mouseDoubleClick(MouseEvent event) {
  }
  /**
   * Handles a mouseUp event.
   * 
   * @param event the mouse event detail information
   */
  public void mouseUp(MouseEvent event) {
    if (event.button != 1) {
      resetSession(); // abort if right or middle mouse button pressed
      return;
    }
    if (! dragInProgress) return; // spurious event
    dragInProgress = false;
    if (anchorPosition.x == -1) return; // spurious event
    
    getPaintSurface().rumitRubberbandSelection();
  }
  
  /**
   * Handles a mouseMove event.
   * 
   * @param event the mouse event detail information
   */
  public void mouseMove(MouseEvent event) {
    final PaintSurface ps = getPaintSurface();
    if (! dragInProgress) {
      ps.setStatusCoord(ps.getCurrentPosition());
      return;
    }
    ps.setStatusCoordRange(anchorPosition, ps.getCurrentPosition());
    ps.clearRubberbandSelection();
    tempPosition.x = event.x;
    tempPosition.y = event.y;
    ps.addRubberbandSelection(createFigure(anchorPosition, tempPosition));
  }
  
  /**
   * Template Method: Creates a Figure for drawing rubberband entities and the final product
   * 
   * @param anchor the anchor point
   * @param cursor the point marking the current pointer location
   */
  protected abstract Figure createFigure(Point anchor, Point cursor);
}

/*******************************************************************************
 * Copyright (c) 2000, 2005 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
/**
 * The superclass for paint tools that draw continuously along the path
 * traced by the mouse"s movement while the button is depressed
 */
abstract class ContinuousPaintSession extends BasicPaintSession {
  /**
   * True if a click-drag is in progress.
   */
  private boolean dragInProgress = false;
  
  /**
   * A cached Point array for drawing.
   */
  private Point[] points = new Point[] { new Point(-1, -1), new Point(-1, -1) };
  /**
   * The time to wait between retriggers in milliseconds.
   */
  private int retriggerInterval = 0;
  
  /**
   * The currently valid RetriggerHandler
   */
  protected Runnable retriggerHandler = null;
  /**
   * Constructs a ContinuousPaintSession.
   * 
   * @param paintSurface the drawing surface to use
   */
  protected ContinuousPaintSession(PaintSurface paintSurface) {
    super(paintSurface);
  }
  /**
   * Sets the retrigger timer.
   * <p>
   * After the timer elapses, if the mouse is still hovering over the same point with the
   * drag button pressed, a new render order is issued and the timer is restarted.
   * </p>
   * @param interval the time in milliseconds to wait between retriggers, 0 to disable
   */
  public void setRetriggerTimer(int interval) {
    retriggerInterval = interval;
  }
  /**
   * Activates the tool.
   */
  public void beginSession() {
    getPaintSurface().
      setStatusMessage(PaintExample.getResourceString("session.ContinuousPaint.message"));
    dragInProgress = false;
  }
  
  /**
   * Deactivates the tool.
     */
  public void endSession() {
    abortRetrigger();
  }
  
  /**
   * Aborts the current operation.
   */
  public void resetSession() {
    abortRetrigger();
  }
  /**
   * Handles a mouseDown event.
   * 
   * @param event the mouse event detail information
   */
  public final void mouseDown(MouseEvent event) {
    if (event.button != 1) return;
    if (dragInProgress) return; // spurious event
    dragInProgress = true;
    points[0].x = event.x;
    points[0].y = event.y;
    render(points[0]);
    prepareRetrigger();
  }
  /**
   * Handles a mouseDoubleClick event.
   * 
   * @param event the mouse event detail information
   */
  public final void mouseDoubleClick(MouseEvent event) {
  }
  /**
   * Handles a mouseUp event.
   * 
   * @param event the mouse event detail information
   */
  public final void mouseUp(MouseEvent event) {
    if (event.button != 1) return;
    if (! dragInProgress) return; // spurious event
    abortRetrigger();
    mouseSegmentFinished(event);
    dragInProgress = false;
  }
  
  /**
   * Handles a mouseMove event.
   * 
   * @param event the mouse event detail information
   */
  public final void mouseMove(MouseEvent event) {
    final PaintSurface ps = getPaintSurface();
    ps.setStatusCoord(ps.getCurrentPosition());
    if (! dragInProgress) return;
    mouseSegmentFinished(event);
    prepareRetrigger();
  }
  
  /**
   * Handle a rendering segment
   * 
   * @param event the mouse event detail information
   */
  private final void mouseSegmentFinished(MouseEvent event) {
    if (points[0].x == -1) return; // spurious event
    if (points[0].x != event.x || points[0].y != event.y) {
      // draw new segment
      points[1].x = event.x;
      points[1].y = event.y;
      renderContinuousSegment();
    }
  }
  /**
   * Draws a continuous segment from points[0] to points[1].
   * Assumes points[0] has been drawn already.
   * 
   * @post points[0] will refer to the same point as points[1]
   */
  protected void renderContinuousSegment() {
    /* A lazy but effective line drawing algorithm */
    final int dX = points[1].x - points[0].x;
    final int dY = points[1].y - points[0].y;
    int absdX = Math.abs(dX);
    int absdY = Math.abs(dY);
    if ((dX == 0) && (dY == 0)) return;
    
    if (absdY > absdX) {
      final int incfpX = (dX << 16) / absdY;
      final int incY = (dY > 0) ? 1 : -1;
      int fpX = points[0].x << 16; // X in fixedpoint format
      while (--absdY >= 0) {
        points[0].y += incY;
        points[0].x = (fpX += incfpX) >> 16;
        render(points[0]);
      }
      if (points[0].x == points[1].x) return;
      points[0].x = points[1].x;
    } else {
      final int incfpY = (dY << 16) / absdX;
      final int incX = (dX > 0) ? 1 : -1;
      int fpY = points[0].y << 16; // Y in fixedpoint format
      while (--absdX >= 0) {
        points[0].x += incX;
        points[0].y = (fpY += incfpY) >> 16;
        render(points[0]);
      }
      if (points[0].y == points[1].y) return;
      points[0].y = points[1].y;
    }
    render(points[0]);
  }    
  /**
   * Prepare the retrigger timer
   */
  private final void prepareRetrigger() {
    if (retriggerInterval > 0) {
      /*
       * timerExec() provides a lightweight mechanism for running code at intervals from within
       * the event loop when timing accuracy is not important.
       *
       * Since it is not possible to cancel a timerExec(), we remember the Runnable that is
       * active in order to distinguish the valid one from the stale ones.  In practice,
       * if the interval is 1/100th of a second, then creating a few hundred new RetriggerHandlers
       * each second will not cause a significant performance hit.
       */
      Display display = getPaintSurface().getDisplay();
      retriggerHandler = new Runnable() {
        public void run() {
          if (retriggerHandler == this) {
            render(points[0]);
            prepareRetrigger();
          }
        }
      };      
      display.timerExec(retriggerInterval, retriggerHandler);
    }
  }
  /**
   * Aborts the retrigger timer
   */
  private final void abortRetrigger() {
    retriggerHandler = null;
  }
  
  /**
   * Template method: Renders a point.
   * @param point, the point to render
   */
  protected abstract void render(Point point);
}

/*******************************************************************************
 * Copyright (c) 2000, 2005 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
/**
 * Container for Figure objects with stacking preview mechanism.
 */
class ContainerFigure extends Figure {
  private static final int INITIAL_ARRAY_SIZE = 16;
  
  Figure[]   objectStack = null;
  int      nextIndex = 0;
  /**
   * Constructs an empty Container
   */
  public ContainerFigure() {
  }
  /**
   * Adds an object to the container for later drawing.
   * 
   * @param object the object to add to the drawing list
   */
  public void add(Figure object) {
    if (objectStack == null) {
      objectStack = new Figure[INITIAL_ARRAY_SIZE];
    } else if (objectStack.length <= nextIndex) {
      Figure[] newObjectStack = new Figure[objectStack.length * 2];
      System.arraycopy(objectStack, 0, newObjectStack, 0, objectStack.length);
      objectStack = newObjectStack;
    }
    objectStack[nextIndex] = object;
    ++nextIndex;
  }
  /**
   * Determines if the container is empty.
   * @return true if the container is empty
   */
  public boolean isEmpty() {
    return nextIndex == 0;
  }
  /**
   * Adds an object to the container and draws its preview then updates the supplied preview state.
   * 
   * @param object the object to add to the drawing list
   * @param gc the GC to draw on
   * @param offset the offset to add to virtual coordinates to get display coordinates
   * @param rememberedState the state returned by a previous drawPreview() or addAndPreview()
   *        using this Container, may be null if there was no such previous call
   * @return object state that must be passed to erasePreview() later to erase this object
   */
//  public Object addAndPreview(Figure object, GC gc, Point offset, Object rememberedState) {
//    Object[] stateStack = (Object[]) rememberedState;
//    if (stateStack == null) {
//      stateStack = new Object[INITIAL_ARRAY_SIZE];
//    } else if (stateStack.length <= nextIndex) {
//      Object[] newStateStack = new Object[stateStack.length * 2];
//      System.arraycopy(stateStack, 0, newStateStack, 0, stateStack.length);
//      stateStack = newStateStack;
//    }
//    add(object);
//    stateStack[nextIndex - 1] = object.drawPreview(gc, offset);
//    return stateStack;
//  }
  /**
   * Clears the container.
   * <p>
   * Note that erasePreview() cannot be called after this point to erase any previous
   * drawPreview()"s.
   * </p>
   */
  public void clear() {
    while (--nextIndex > 0) objectStack[nextIndex] = null;
    nextIndex = 0;
  }
  public void draw(FigureDrawContext fdc) {
    for (int i = 0; i < nextIndex; ++i) objectStack[i].draw(fdc);
  }
  public void addDamagedRegion(FigureDrawContext fdc, Region region) {
    for (int i = 0; i < nextIndex; ++i) objectStack[i].addDamagedRegion(fdc, region);
  }
}

/*******************************************************************************
 * Copyright (c) 2000, 2005 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
abstract class BasicPaintSession implements PaintSession {
  /**
   * The paint surface
   */
  private PaintSurface paintSurface;
  /**
   * Constructs a PaintSession.
   * 
   * @param paintSurface the drawing surface to use
   */
  protected BasicPaintSession(PaintSurface paintSurface) {
    this.paintSurface = paintSurface;
  }
  /**
   * Returns the paint surface associated with this paint session.
   * 
   * @return the associated PaintSurface
   */
  public PaintSurface getPaintSurface() {
    return paintSurface;
  }
}

/*******************************************************************************
 * Copyright (c) 2000, 2005 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
/**
 * An airbrush tool.
 */
class AirbrushTool extends ContinuousPaintSession implements PaintTool {
  private ToolSettings settings;
  private Random random;
  private int cachedRadiusSquared;
  private int cachedNumPoints;
  
  /**
   * Constructs a Tool.
   * 
   * @param toolSettings the new tool settings
   * @param paintSurface the PaintSurface we will render on.
   */
  public AirbrushTool(ToolSettings toolSettings, PaintSurface paintSurface) {
    super(paintSurface);
    random = new Random();
    setRetriggerTimer(10);
    set(toolSettings);
  }
  
  /**
   * Sets the tool"s settings.
   * 
   * @param toolSettings the new tool settings
   */
  public void set(ToolSettings toolSettings) {
    // compute things we need to know for drawing
    settings = toolSettings;
    cachedRadiusSquared = settings.airbrushRadius * settings.airbrushRadius;
    cachedNumPoints = 314 * settings.airbrushIntensity * cachedRadiusSquared / 250000;
    if (cachedNumPoints == 0 && settings.airbrushIntensity != 0)
      cachedNumPoints = 1;
  }
  /**
   * Returns the name associated with this tool.
   * 
   * @return the localized name of this tool
   */
  public String getDisplayName() {
    return PaintExample.getResourceString("tool.Airbrush.label");
  }
  /*
   * Template method for drawing
   */
  protected void render(Point point) {
    // Draws a bunch (cachedNumPoints) of random pixels within a specified circle (cachedRadiusSquared).
    ContainerFigure cfig = new ContainerFigure();
    for (int i = 0; i < cachedNumPoints; ++i) {
      int randX, randY;
      do {
        randX = (int) ((random.nextDouble() - 0.5) * settings.airbrushRadius * 2.0);
        randY = (int) ((random.nextDouble() - 0.5) * settings.airbrushRadius * 2.0);
      } while (randX * randX + randY * randY > cachedRadiusSquared);
      cfig.add(new PointFigure(settings.rumonForegroundColor, point.x + randX, point.y + randY));
    }
    getPaintSurface().drawFigure(cfig);
  }
}

           
         
  </source>
    
   
  <!-- end source code -->
   




== SWT useful utilities ==






   
  <!-- start source code -->
   
    <source lang="java">
 
/*
 * (c) Copyright 2004 by Heng Yuan
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included
 * in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * ITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 * DEALINGS IN THE SOFTWARE.
 */
package cookxml.cookswt.util;
import java.util.HashMap;
import org.eclipse.swt.SWT;
import org.eclipse.swt.graphics.*;
import org.eclipse.swt.widgets.*;
/**
 * SWT useful utilities.
 *
 * @since CookSwt 1.0
 * @author Heng Yuan
 */
public class SwtUtils
{
  /**
   * automatically dispose Color resource
   */
  public static boolean autoDisposeColor = true;
  /**
   * automatically dispose Font resource
   */
  public static boolean autoDisposeFont = true;
  /**
   * automatically dispose Image resource
   */
  public static boolean autoDisposeImage = true;
  /**
   * automatically dispose Image resource
   */
  public static boolean autoDisposeCursor = true;
  /**
   * This is a table of system colors that cannot be disposed.
   */
  private static HashMap s_systemColorTable;
  /**
   * This is a table of system cursors that cannot be disposed.
   */
  private static HashMap s_systemCursorTable;
  /**
   * This is a table of system images that cannot be disposed.
   */
  private static HashMap s_systemImageTable;
  /**
   * Setup the system color table for the given device.
   *
   * @param  device the display device.
   */
  private static void setupSystemColorTable (Device device)
  {
    HashMap colorTable = new HashMap ();
    for (int i = 0; i <= 35; ++i)
    {
      Color c = device.getSystemColor (i);
      colorTable.put (c, c);
    }
    s_systemColorTable = colorTable;
  }
  /**
   * Setup the system cursor table for the given device.
   *
   * @param  display the display device.
   */
  private static void setupSystemCursorTable (Display display)
  {
    HashMap cursorTable = new HashMap ();
    for (int i = 0; i <= 21; ++i)
    {
      Cursor c = display.getSystemCursor (i);
      cursorTable.put (c, c);
    }
    s_systemCursorTable = cursorTable;
  }
  /**
   * Setup the system cursor table for the given device.
   *
   * @param  display the display device.
   */
  private static void setupSystemImageTable (Display display)
  {
    HashMap imageTable = new HashMap ();
    Image image;
    image = display.getSystemImage (SWT.ICON_ERROR);
    imageTable.put (image, image);
    image = display.getSystemImage (SWT.ICON_INFORMATION);
    imageTable.put (image, image);
    image = display.getSystemImage (SWT.ICON_QUESTION);
    imageTable.put (image, image);
    image = display.getSystemImage (SWT.ICON_WARNING);
    imageTable.put (image, image);
    image = display.getSystemImage (SWT.ICON_WORKING);
    imageTable.put (image, image);
    s_systemImageTable = imageTable;
  }
  /**
   * Check if a color is a system color.  A system color cannot be disposed.
   *
   * @param  color The color to be disposed.
   * @param  device The device that contains the color.
   */
  public static boolean isSystemColor (Color color, Device device)
  {
    if (s_systemColorTable == null)
      setupSystemColorTable (device);
    return s_systemColorTable.get (color) == color;
  }
  /**
   * Check if a color is a system color.  A system color cannot be disposed.
   *
   * @param  cursor The cursor to be disposed.
   * @param  display The display device.
   */
  public static boolean isSystemCursor (Cursor cursor, Display display)
  {
    if (s_systemCursorTable == null)
      setupSystemCursorTable (display);
    return s_systemCursorTable.get (cursor) == cursor;
  }
  /**
   * Check if a color is a system color.  A system color cannot be disposed.
   *
   * @param  image The image to be disposed.
   * @param  display The display device.
   */
  public static boolean isSystemImage (Image image, Display display)
  {
    if (s_systemImageTable == null)
      setupSystemImageTable (display);
    return s_systemImageTable.get (image) == image;
  }
  /**
   * Check if a color is a system color.  A system color cannot be disposed.
   *
   * @param  font The font to be disposed.
   * @param  device The display device.
   */
  public static boolean isSystemFont (Font font, Device device)
  {
    return device.getSystemFont () == font;
  }
  /**
   * Dispose a color if it is not a system color.
   *
   * @param  color The color to be disposed.
   * @param  device The device that contains the color.
   */
  public static void disposeColor (Color color, Device device)
  {
    if (color.isDisposed ())
      return;
    if (!isSystemColor (color, device))
    {
      assert disposeDebug ("Dispose color: " + color);
      color.dispose ();
    }
  }
  /**
   * Dispose a color if it is not a system color.
   *
   * @param  image The image to be disposed.
   * @param  device The device that contains the color.
   */
  public static void disposeImage (Image image, Display device)
  {
    if (image.isDisposed ())
      return;
    if (!isSystemImage (image, device))
    {
      assert disposeDebug ("Dispose image: " + image);
      image.dispose ();
    }
  }
  /**
   * Attach a DisposeListener that dispose the resource when the widget
   * object is disposed.
   *
   * @param  widget the widget to listen to.
   * @param  color the resource to be disposed.
   */
  public static void attachColorDisposeListener (Widget widget, Color color)
  {
    if (autoDisposeColor &&
      !isSystemColor (color, widget.getDisplay ()))
      widget.addDisposeListener (new ColorDisposeListener (color));
  }
  /**
   * Attach a DisposeListener that dispose the resource when the widget
   * object is disposed.
   *
   * @param  widget the widget to listen to.
   * @param  cursor the resource to be disposed.
   */
  public static void attachCursorDisposeListener (Widget widget, Cursor cursor)
  {
    if (autoDisposeCursor &&
      !isSystemCursor (cursor, widget.getDisplay ()))
      widget.addDisposeListener (new CursorDisposeListener (cursor));
  }
  /**
   * Attach a DisposeListener that dispose the resource when the widget
   * object is disposed.
   *
   * @param  widget the widget to listen to.
   * @param  font the resource to be disposed.
   */
  public static void attachFontDisposeListener (Widget widget, Font font)
  {
    if (autoDisposeFont &&
      !isSystemFont (font, widget.getDisplay ()))
      widget.addDisposeListener (new FontDisposeListener (font));
  }
  /**
   * Attach a DisposeListener that dispose the resource when the widget
   * object is disposed.
   *
   * @param  widget the widget to listen to.
   * @param  image the resource to be disposed.
   */
  public static void attachImageDisposeListener (Widget widget, Image image)
  {
    if (autoDisposeImage &&
       !isSystemImage (image, widget.getDisplay ()))
      widget.addDisposeListener (new ImageDisposeListener (image));
  }
  /**
   * Attach a dropdown menu to a drop down ToolItem.  The drop down menu will be
   * automatically positioned and displayed at under the ToolItem.
   *
   * @param  item the drop down tool item
   * @param  menu the drop down menu
   */
  public static void attachToolItemDropDownMenu (ToolItem item, Menu menu)
  {
    item.addSelectionListener (new DropDownListener (menu));
  }
  /**
   * Open all the shells inside the Display object and dispose the Display
   * after all shells are disposed.
   *
   * @param display the Display object.
   */
  public static void showDisplay (Display display)
  {
    // open shells for display
    Shell[] shells = display.getShells ();
    for (int i = 0; i < shells.length; ++i)
    {
      if (!shells[i].isDisposed () && !shells[i].isVisible ())
        shells[i].open ();
    }
    // exit after all shells are disposed
    while (!display.isDisposed ())
    {
      shells = display.getShells ();
      boolean canExit = true;
      for (int i = 0; i < shells.length; ++i)
      {
        if (!shells[i].isDisposed ())
        {
          canExit = false;
          break;
        }
      }
      if (canExit)
        break;
      if (!display.readAndDispatch ())
        display.sleep ();
    }
    if (!display.isDisposed ())
      display.dispose ();
  }
  /**
   * This function is supposed to work in conjunction with assert to generate
   * a debug message but does not really throw an Exception
   *
   * @param  msg the message to be printed.
   * @return  true
   */
  public static boolean disposeDebug (String msg)
  {
    System.out.println (msg);
    return true;
  }
}
   
  </source>
    
   
  <!-- end source code -->
   




== Transparency ==






   
  <!-- start source code -->
   
    <source lang="java">
 
/******************************************************************************
 * All Right Reserved. 
 * Copyright (c) 1998, 2004 Jackwind Li Guojie
 * 
 * Created on 2004-4-21 21:49:01 by JACK
 * $Id$
 * 
 *****************************************************************************/

import org.eclipse.swt.SWT;
import org.eclipse.swt.events.PaintEvent;
import org.eclipse.swt.events.PaintListener;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.graphics.ImageData;
import org.eclipse.swt.graphics.RGB;
import org.eclipse.swt.layout.FillLayout;
import org.eclipse.swt.widgets.Canvas;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Shell;
public class Transparency {
  Display display = new Display();
  Shell shell = new Shell(display);
  public Transparency() {
    shell.setLayout(new FillLayout());
    
    ImageData imageData = new ImageData("jexp.gif");
    
    final Image image = new Image(display, imageData);
    RGB white = new RGB(255, 255, 255);
    for(int i=0; i<imageData.width; i++) {
      for(int j=0; j<imageData.height; j++) {
        RGB rgb = imageData.palette.getRGB(imageData.getPixel(i, j));
        int threshold = 220;
        if(rgb.red > threshold && rgb.green > threshold && rgb.blue > threshold)
          imageData.setPixel(i, j, imageData.palette.getPixel(white));
      }
    }
    
    imageData.transparentPixel = imageData.palette.getPixel(new RGB(255, 255, 255));
    
    final Image image2 = new Image(display, imageData);
    
    final Canvas canvas = new Canvas(shell, SWT.NULL);
    canvas.addPaintListener(new PaintListener() {
      public void paintControl(PaintEvent e) {
        e.gc.drawImage(image, 10, 20);
        e.gc.drawImage(image2, 200, 20);
      }
    });
    shell.setSize(400, 140);
    shell.open();
    //textUser.forceFocus();
    // Set up the event loop.
    while (!shell.isDisposed()) {
      if (!display.readAndDispatch()) {
        // If no more entries in event queue
        display.sleep();
      }
    }
    display.dispose();
  }
  private void init() {
  }
  public static void main(String[] args) {
    new Transparency();
  }
}

           
         
  </source>
    
   
  <!-- end source code -->
   




== Use of Java2D on SWT or Draw2D graphical context ==






   
  <!-- start source code -->
   
    <source lang="java">
 
/*
 * -----------------------------------------------------------------------------
 * (c) Copyright IBM Corp. 2004 All rights reserved.
 * 
 * The sample program(s) is/are owned by International Business Machines
 * Corporation or one of its subsidiaries ("IBM") and is/are copyrighted and
 * licensed, not sold.
 * 
 * You may copy, modify, and distribute this/these sample program(s) in any form
 * without payment to IBM, for any purpose including developing, using,
 * marketing or distributing programs that include or are derivative works of
 * the sample program(s).
 * 
 * The sample program(s) is/are provided to you on an "AS IS" basis, without
 * warranty of any kind. IBM HEREBY EXPRESSLY DISCLAIMS ALL WARRANTIES, EITHER
 * EXPRESS OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. Some jurisdictions do
 * not allow for the exclusion or limitation of implied warranties, so the above
 * limitations or exclusions may not apply to you. IBM shall not be liable for
 * any damages you suffer as a result of using, modifying or distributing the
 * sample program(s) or its/their derivatives.
 * 
 * Each copy of any portion of this/these sample program(s) or any derivative
 * work, must include the above copyright notice and disclaimer of warranty.
 * 
 * -----------------------------------------------------------------------------
 */
import java.awt.GradientPaint;
import java.awt.Graphics2D;
import java.awt.RenderingHints;
import java.awt.image.BufferedImage;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.PaintEvent;
import org.eclipse.swt.events.PaintListener;
import org.eclipse.swt.graphics.GC;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.graphics.ImageData;
import org.eclipse.swt.graphics.PaletteData;
import org.eclipse.swt.graphics.Point;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Canvas;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Shell;
public class SWTTest {
  public static void main(String[] args) {
    Display display = new Display();
    Shell shell = new Shell(display);
    shell.setSize(350, 350);
    shell.setLayout(new GridLayout());
    Canvas canvas = new Canvas(shell, SWT.NO_BACKGROUND);
    GridData data = new GridData(GridData.FILL_BOTH);
    canvas.setLayoutData(data);
    final Graphics2DRenderer renderer = new Graphics2DRenderer();
    canvas.addPaintListener(new PaintListener() {
      public void paintControl(PaintEvent e) {
        Point controlSize = ((Control) e.getSource()).getSize();
        GC gc = e.gc; // gets the SWT graphics context from the event
        renderer.prepareRendering(gc); // prepares the Graphics2D
        // renderer
        // gets the Graphics2D context and switch on the antialiasing
        Graphics2D g2d = renderer.getGraphics2D();
        g2d.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING,
            RenderingHints.VALUE_TEXT_ANTIALIAS_ON);
        // paints the background with a color gradient
        g2d.setPaint(new GradientPaint(0.0f, 0.0f,
            java.awt.Color.yellow, (float) controlSize.x,
            (float) controlSize.y, java.awt.Color.white));
        g2d.fillRect(0, 0, controlSize.x, controlSize.y);
        // draws rotated text
        g2d.setFont(new java.awt.Font("SansSerif", java.awt.Font.BOLD,
            16));
        g2d.setColor(java.awt.Color.blue);
        g2d.translate(controlSize.x / 2, controlSize.y / 2);
        int nbOfSlices = 18;
        for (int i = 0; i < nbOfSlices; i++) {
          g2d.drawString("Angle = " + (i * 360 / nbOfSlices)
              + "\u00B0", 30, 0);
          g2d.rotate(-2 * Math.PI / nbOfSlices);
        }
        // now that we are done with Java2D, renders Graphics2D
        // operation
        // on the SWT graphics context
        renderer.render(gc);
        // now we can continue with pure SWT paint operations
        gc.drawOval(0, 0, controlSize.x, controlSize.y);
      }
    });
    shell.open();
    while (!shell.isDisposed()) {
      if (!display.readAndDispatch())
        display.sleep();
    }
    display.dispose();
    renderer.dispose();
    System.exit(0);
  }
}
/*
 * -----------------------------------------------------------------------------
 * (c) Copyright IBM Corp. 2004 All rights reserved.
 * 
 * The sample program(s) is/are owned by International Business Machines
 * Corporation or one of its subsidiaries ("IBM") and is/are copyrighted and
 * licensed, not sold.
 * 
 * You may copy, modify, and distribute this/these sample program(s) in any form
 * without payment to IBM, for any purpose including developing, using,
 * marketing or distributing programs that include or are derivative works of
 * the sample program(s).
 * 
 * The sample program(s) is/are provided to you on an "AS IS" basis, without
 * warranty of any kind. IBM HEREBY EXPRESSLY DISCLAIMS ALL WARRANTIES, EITHER
 * EXPRESS OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. Some jurisdictions do
 * not allow for the exclusion or limitation of implied warranties, so the above
 * limitations or exclusions may not apply to you. IBM shall not be liable for
 * any damages you suffer as a result of using, modifying or distributing the
 * sample program(s) or its/their derivatives.
 * 
 * Each copy of any portion of this/these sample program(s) or any derivative
 * work, must include the above copyright notice and disclaimer of warranty.
 * 
 * -----------------------------------------------------------------------------
 */
/**
 * Helper class allowing the use of Java2D on SWT or Draw2D graphical context.
 * 
 * @author Yannick Saillet
 */
class Graphics2DRenderer {
  private static final PaletteData PALETTE_DATA = new PaletteData(0xFF0000,
      0xFF00, 0xFF);
  private BufferedImage awtImage;
  private Image swtImage;
  private ImageData swtImageData;
  private int[] awtPixels;
  /** RGB value to use as transparent color */
  private static final int TRANSPARENT_COLOR = 0x123456;
  /**
   * Prepare to render on a SWT graphics context.
   */
  public void prepareRendering(GC gc) {
    org.eclipse.swt.graphics.Rectangle clip = gc.getClipping();
    prepareRendering(clip.x, clip.y, clip.width, clip.height);
  }
  /**
   * Prepare to render on a Draw2D graphics context.
   */
  public void prepareRendering(org.eclipse.draw2d.Graphics graphics) {
    org.eclipse.draw2d.geometry.Rectangle clip = graphics
        .getClip(new org.eclipse.draw2d.geometry.Rectangle());
    prepareRendering(clip.x, clip.y, clip.width, clip.height);
  }
  /**
   * Prepare the AWT offscreen image for the rendering of the rectangular
   * region given as parameter.
   */
  private void prepareRendering(int clipX, int clipY, int clipW, int clipH) {
    // check that the offscreen images are initialized and large enough
    checkOffScreenImages(clipW, clipH);
    // fill the region in the AWT image with the transparent color
    java.awt.Graphics awtGraphics = awtImage.getGraphics();
    awtGraphics.setColor(new java.awt.Color(TRANSPARENT_COLOR));
    awtGraphics.fillRect(clipX, clipY, clipW, clipH);
  }
  /**
   * Returns the Graphics2D context to use.
   */
  public Graphics2D getGraphics2D() {
    if (awtImage == null)
      return null;
    return (Graphics2D) awtImage.getGraphics();
  }
  /**
   * Complete the rendering by flushing the 2D renderer on a SWT graphical
   * context.
   */
  public void render(GC gc) {
    if (awtImage == null)
      return;
    org.eclipse.swt.graphics.Rectangle clip = gc.getClipping();
    transferPixels(clip.x, clip.y, clip.width, clip.height);
    gc.drawImage(swtImage, clip.x, clip.y, clip.width, clip.height, clip.x,
        clip.y, clip.width, clip.height);
  }
  /**
   * Complete the rendering by flushing the 2D renderer on a Draw2D graphical
   * context.
   */
  public void render(org.eclipse.draw2d.Graphics graphics) {
    if (awtImage == null)
      return;
    org.eclipse.draw2d.geometry.Rectangle clip = graphics
        .getClip(new org.eclipse.draw2d.geometry.Rectangle());
    transferPixels(clip.x, clip.y, clip.width, clip.height);
    graphics.drawImage(swtImage, clip.x, clip.y, clip.width, clip.height,
        clip.x, clip.y, clip.width, clip.height);
  }
  /**
   * Transfer a rectangular region from the AWT image to the SWT image.
   */
  private void transferPixels(int clipX, int clipY, int clipW, int clipH) {
    int step = swtImageData.depth / 8;
    byte[] data = swtImageData.data;
    awtImage.getRGB(clipX, clipY, clipW, clipH, awtPixels, 0, clipW);
    for (int i = 0; i < clipH; i++) {
      int idx = (clipY + i) * swtImageData.bytesPerLine + clipX * step;
      for (int j = 0; j < clipW; j++) {
        int rgb = awtPixels[j + i * clipW];
        for (int k = swtImageData.depth - 8; k >= 0; k -= 8) {
          data[idx++] = (byte) ((rgb >> k) & 0xFF);
        }
      }
    }
    if (swtImage != null)
      swtImage.dispose();
    swtImage = new Image(Display.getDefault(), swtImageData);
  }
  /**
   * Dispose the resources attached to this 2D renderer.
   */
  public void dispose() {
    if (awtImage != null)
      awtImage.flush();
    if (swtImage != null)
      swtImage.dispose();
    awtImage = null;
    swtImageData = null;
    awtPixels = null;
  }
  /**
   * Ensure that the offscreen images are initialized and are at least as
   * large as the size given as parameter.
   */
  private void checkOffScreenImages(int width, int height) {
    int currentImageWidth = 0;
    int currentImageHeight = 0;
    if (swtImage != null) {
      currentImageWidth = swtImage.getImageData().width;
      currentImageHeight = swtImage.getImageData().height;
    }
    // if the offscreen images are too small, recreate them
    if (width > currentImageWidth || height > currentImageHeight) {
      dispose();
      width = Math.max(width, currentImageWidth);
      height = Math.max(height, currentImageHeight);
      awtImage = new BufferedImage(width, height,
          BufferedImage.TYPE_INT_ARGB);
      swtImageData = new ImageData(width, height, 24, PALETTE_DATA);
      swtImageData.transparentPixel = TRANSPARENT_COLOR;
      awtPixels = new int[width * height];
    }
  }
}

           
         
  </source>
    
   
  <!-- end source code -->
   




== Utility methods for drawing graphics ==






   
  <!-- start source code -->
   
    <source lang="java">
 
//Send questions, comments, bug reports, etc. to the authors:
//Rob Warner (rwarner@interspatial.ru)
//Robert Harris (rbrt_harris@yahoo.ru)
import org.eclipse.swt.*;
import org.eclipse.swt.graphics.*;
import org.eclipse.swt.widgets.Display;
/**
 * This class contains utility methods for drawing graphics
 */
public class GraphicsUtils {
  /**
   * Draws text vertically (rotates plus or minus 90 degrees). Uses the current
   * font, color, and background.
   * <dl>
   * <dt><b>Styles: </b></dt>
   * <dd>UP, DOWN</dd>
   * </dl>
   * 
   * @param string the text to draw
   * @param x the x coordinate of the top left corner of the drawing rectangle
   * @param y the y coordinate of the top left corner of the drawing rectangle
   * @param gc the GC on which to draw the text
   * @param style the style (SWT.UP or SWT.DOWN)
   *          <p>
   *          Note: Only one of the style UP or DOWN may be specified.
   *          </p>
   */
  public static void drawVerticalText(String string, int x, int y, GC gc,
      int style) {
    // Get the current display
    Display display = Display.getCurrent();
    if (display == null) SWT.error(SWT.ERROR_THREAD_INVALID_ACCESS);
    // Determine string"s dimensions
    FontMetrics fm = gc.getFontMetrics();
    Point pt = gc.textExtent(string);
    // Create an image the same size as the string
    Image stringImage = new Image(display, pt.x, pt.y);
    // Create a GC so we can draw the image
    GC stringGc = new GC(stringImage);
    // Set attributes from the original GC to the new GC
    stringGc.setForeground(gc.getForeground());
    stringGc.setBackground(gc.getBackground());
    stringGc.setFont(gc.getFont());
    // Draw the text onto the image
    stringGc.drawText(string, 0, 0);
    // Draw the image vertically onto the original GC
    drawVerticalImage(stringImage, x, y, gc, style);
    // Dispose the new GC
    stringGc.dispose();
    // Dispose the image
    stringImage.dispose();
  }
  /**
   * Draws an image vertically (rotates plus or minus 90 degrees)
   * <dl>
   * <dt><b>Styles: </b></dt>
   * <dd>UP, DOWN</dd>
   * </dl>
   * 
   * @param image the image to draw
   * @param x the x coordinate of the top left corner of the drawing rectangle
   * @param y the y coordinate of the top left corner of the drawing rectangle
   * @param gc the GC on which to draw the image
   * @param style the style (SWT.UP or SWT.DOWN)
   *          <p>
   *          Note: Only one of the style UP or DOWN may be specified.
   *          </p>
   */
  public static void drawVerticalImage(Image image, int x, int y, GC gc, int style) {
    // Get the current display
    Display display = Display.getCurrent();
    if (display == null) SWT.error(SWT.ERROR_THREAD_INVALID_ACCESS);
    // Use the image"s data to create a rotated image"s data
    ImageData sd = image.getImageData();
    ImageData dd = new ImageData(sd.height, sd.width, sd.depth, sd.palette);
    // Determine which way to rotate, depending on up or down
    boolean up = (style & SWT.UP) == SWT.UP;
    // Run through the horizontal pixels
    for (int sx = 0; sx < sd.width; sx++) {
      // Run through the vertical pixels
      for (int sy = 0; sy < sd.height; sy++) {
        // Determine where to move pixel to in destination image data
        int dx = up ? sy : sd.height - sy - 1;
        int dy = up ? sd.width - sx - 1 : sx;
        // Swap the x, y source data to y, x in the destination
        dd.setPixel(dx, dy, sd.getPixel(sx, sy));
      }
    }
    // Create the vertical image
    Image vertical = new Image(display, dd);
    // Draw the vertical image onto the original GC
    gc.drawImage(vertical, x, y);
    // Dispose the vertical image
    vertical.dispose();
  }
  /**
   * Creates an image containing the specified text, rotated either plus or minus
   * 90 degrees.
   * <dl>
   * <dt><b>Styles: </b></dt>
   * <dd>UP, DOWN</dd>
   * </dl>
   * 
   * @param text the text to rotate
   * @param font the font to use
   * @param foreground the color for the text
   * @param background the background color
   * @param style direction to rotate (up or down)
   * @return Image
   *         <p>
   *         Note: Only one of the style UP or DOWN may be specified.
   *         </p>
   */
  public static Image createRotatedText(String text, Font font, Color foreground,
      Color background, int style) {
    // Get the current display
    Display display = Display.getCurrent();
    if (display == null) SWT.error(SWT.ERROR_THREAD_INVALID_ACCESS);
    // Create a GC to calculate font"s dimensions
    GC gc = new GC(display);
    gc.setFont(font);
    // Determine string"s dimensions
    FontMetrics fm = gc.getFontMetrics();
    Point pt = gc.textExtent(text);
    // Dispose that gc
    gc.dispose();
    // Create an image the same size as the string
    Image stringImage = new Image(display, pt.x, pt.y);
    // Create a gc for the image
    gc = new GC(stringImage);
    gc.setFont(font);
    gc.setForeground(foreground);
    gc.setBackground(background);
    // Draw the text onto the image
    gc.drawText(text, 0, 0);
    // Draw the image vertically onto the original GC
    Image image = createRotatedImage(stringImage, style);
    // Dispose the new GC
    gc.dispose();
    // Dispose the horizontal image
    stringImage.dispose();
    // Return the rotated image
    return image;
  }
  /**
   * Creates a rotated image (plus or minus 90 degrees)
   * <dl>
   * <dt><b>Styles: </b></dt>
   * <dd>UP, DOWN</dd>
   * </dl>
   * 
   * @param image the image to rotate
   * @param style direction to rotate (up or down)
   * @return Image
   *         <p>
   *         Note: Only one of the style UP or DOWN may be specified.
   *         </p>
   */
  public static Image createRotatedImage(Image image, int style) {
    // Get the current display
    Display display = Display.getCurrent();
    if (display == null) SWT.error(SWT.ERROR_THREAD_INVALID_ACCESS);
    // Use the image"s data to create a rotated image"s data
    ImageData sd = image.getImageData();
    ImageData dd = new ImageData(sd.height, sd.width, sd.depth, sd.palette);
    // Determine which way to rotate, depending on up or down
    boolean up = (style & SWT.UP) == SWT.UP;
    // Run through the horizontal pixels
    for (int sx = 0; sx < sd.width; sx++) {
      // Run through the vertical pixels
      for (int sy = 0; sy < sd.height; sy++) {
        // Determine where to move pixel to in destination image data
        int dx = up ? sy : sd.height - sy - 1;
        int dy = up ? sd.width - sx - 1 : sx;
        // Swap the x, y source data to y, x in the destination
        dd.setPixel(dx, dy, sd.getPixel(sx, sy));
      }
    }
    // Create the vertical image
    return new Image(display, dd);
  }
}

           
         
  </source>
    
   
  <!-- end source code -->
   




== XOR ==






   
  <!-- start source code -->
   
    <source lang="java">
 

/******************************************************************************
 * All Right Reserved. 
 * Copyright (c) 1998, 2004 Jackwind Li Guojie
 * 
 * Created on 2004-4-19 15:31:18 by JACK
 * $Id$
 * 
 *****************************************************************************/

import org.eclipse.swt.SWT;
import org.eclipse.swt.events.PaintEvent;
import org.eclipse.swt.events.PaintListener;
import org.eclipse.swt.layout.FillLayout;
import org.eclipse.swt.widgets.Canvas;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Shell;
public class XOR {
  Display display = new Display();
  Shell shell = new Shell(display);
  public XOR() {
    shell.setLayout(new FillLayout());
    final Canvas canvas = new Canvas(shell, SWT.NULL);
    canvas.setBackground(display.getSystemColor(SWT.COLOR_WHITE));
    
    canvas.addPaintListener(new PaintListener() {
      public void paintControl(PaintEvent e) {
        e.gc.setXORMode(true);
        
        e.gc.setBackground(display.getSystemColor(SWT.COLOR_GREEN));
        e.gc.fillOval(60, 10, 100, 100); // Top 
        
        e.gc.setBackground(display.getSystemColor(SWT.COLOR_RED));
        e.gc.fillOval(10, 60, 120, 120); // left bottom    
        
        e.gc.setBackground(display.getSystemColor(SWT.COLOR_BLUE));
        e.gc.fillOval(110, 60, 100, 100); // right bottom    
        
      }
    });
    
    shell.setSize(300, 220);
    shell.open();
    //textUser.forceFocus();
    // Set up the event loop.
    while (!shell.isDisposed()) {
      if (!display.readAndDispatch()) {
        // If no more entries in event queue
        display.sleep();
      }
    }
    display.dispose();
  }
  private void init() {
  }
  public static void main(String[] args) {
    new XOR();
  }
}
           
         
  </source>
    
   
  <!-- end source code -->