SWT Graphics Example : 2D « SWT JFace Eclipse « Java

Home
Java
1.2D Graphics GUI
2.3D
3.Advanced Graphics
4.Ant
5.Apache Common
6.Chart
7.Class
8.Collections Data Structure
9.Data Type
10.Database SQL JDBC
11.Design Pattern
12.Development Class
13.EJB3
14.Email
15.Event
16.File Input Output
17.Game
18.Generics
19.GWT
20.Hibernate
21.I18N
22.J2EE
23.J2ME
24.JavaFX
25.JDK 6
26.JDK 7
27.JNDI LDAP
28.JPA
29.JSP
30.JSTL
31.Language Basics
32.Network Protocol
33.PDF RTF
34.Reflection
35.Regular Expressions
36.Scripting
37.Security
38.Servlets
39.Spring
40.Swing Components
41.Swing JFC
42.SWT JFace Eclipse
43.Threads
44.Tiny Application
45.Velocity
46.Web Services SOA
47.XML
Java » SWT JFace Eclipse » 2D 




SWT Graphics Example
SWT Graphics Example
 

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(3false);
    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 = (GridDatatabList.getLayoutData();
          data.widthHint = event.x
              - tabList.computeTrim(0000).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, 00);
          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(1false);
    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 = (ToolItemevent.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 = (MenuItemevent.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((ImagetabBackground[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((ImagetabBackground[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(1false);
    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, 1616);
    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 = (Stringiter.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 = (TreeItemevent.item;
        if (item != null) {
          setTab((GraphicsTabitem.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++) {
        ((Imageimages.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((ColortabBackground[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 = (GridDatacontrolPanel.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 == || 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(00, width, height);
    gc.drawLine(width, 00, 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 * * pos / POINTS;
      radial[i * 2(int) ((+ Math.cos(r)) * centerX);
      radial[i * 1(int) ((+ Math.sin(r)) * centerY);
      pos = (pos + POINTS / 2% POINTS;
    }
    Display display = Display.getCurrent();
    gc.setFillRule(fillRuleCb.getSelectionIndex() != ? 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 * 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 - size2(height - size2, 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 = (floatMath.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 - textHeight2;
      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, 00, rect.width, rect.height, 00, width, height);
    gc.setClipping((Rectanglenull);
    gc.setForeground(display.getSystemColor(SWT.COLOR_BLUE));
    gc.drawPath(path);
  }
}



           
         
  














Related examples in the same category
1.SWT 2D Chart: FlowchartSWT 2D Chart: Flowchart
2.Use of Java2D on SWT or Draw2D graphical contextUse of Java2D on SWT or Draw2D graphical context
3.SWT 2D UnicodeSWT 2D Unicode
4.SWT 2D Simple DemoSWT 2D Simple Demo
5.SWT Draw 2DSWT Draw 2D
6.SWT Draw2D Example
7.XORXOR
8.Animations ExampleAnimations Example
9.Alpha Fade InAlpha Fade In
10.DrawingsDrawings
11.Draw Text DemoDraw Text Demo
12.GC Creation
13.PalettesPalettes
14.TransparencyTransparency
15.Draw2D SampleDraw2D Sample
16.Class AnalyzerClass Analyzer
17.Demonstrates animation. It uses double buffering.Demonstrates animation. It uses double buffering.
18.Demonstrates drawing an ArcDemonstrates drawing an Arc
19.Demonstrates drawing polygonsDemonstrates drawing polygons
20.Demonstrates drawing points. It draws a sine waveDemonstrates drawing points. It draws a sine wave
21.Draw Round RectangleDraw Round Rectangle
22.Displays information about the display deviceDisplays information about the display device
23.Demonstrates the effects of the flags on the constructorDemonstrates the effects of the flags on the constructor
24.Demonstrates how to draw vertical textDemonstrates how to draw vertical text
25.Utility methods for drawing graphics
26.Demonstrates drawing linesDemonstrates drawing lines
27.Demonstrates animationDemonstrates animation
28.Demonstrates how to draw textDemonstrates how to draw text
29.Demonstrates drawing ovalsDemonstrates drawing ovals
30.Demonstrates how to draw text in colorsDemonstrates how to draw text in colors
31.SWT Paint Example
32.SWT OpenGL snippet: draw a square
33.Drawing with transformations, paths and alpha blendingDrawing with transformations, paths and alpha blending
34.Draw lines and polygons with different cap and join stylesDraw lines and polygons with different cap and join styles
35.GC: implement a simple scribble programGC: implement a simple scribble program
36.GC: measure a stringGC: measure a string
37.GC example: draw a thick lineGC example: draw a thick line
38.How to draw directly on an SWT ControlHow to draw directly on an SWT Control
39.SWT useful utilities
java2s.com  | Contact Us | Privacy Policy
Copyright 2009 - 12 Demo Source and Support. All rights reserved.
All other trademarks are property of their respective owners.