用java swt实现的一个2d效果,很漂亮!

代码如下:

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.Combo;
import  org.eclipse.swt.widgets.Composite;
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.computeSize ( 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.computeTrim ( 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.computeSize ( 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 ) ;
   }
}