Java/J2ME/2D

Содержание

1 Box Text Canvas
2 Illustrate Graphics MIDlet
3 Key Canvas
4 Offscreen MIDlet
5 Pacer
6 Pointer Example
7 Quatsch MIDlet
8 Show various anchor points
9 Simple Canvas
10 Text Example
11 Text MIDlet
12 Translate Coordinates
13 Translate coordinate system
14 Use pointer events to draw onto the Canvas

Box Text Canvas

   <source lang="java">

import javax.microedition.lcdui.Canvas; import javax.microedition.lcdui.Font; import javax.microedition.lcdui.Graphics; public class BoxTextCanvas extends Canvas {

 private Font mFont;
 public BoxTextCanvas() {
   mFont = Font.getFont(Font.FACE_PROPORTIONAL, Font.STYLE_PLAIN, Font.SIZE_LARGE);
 }
 public void paint(Graphics g) {
   int w = getWidth();
   int h = getHeight();
   g.setColor(0xffffff);
   g.fillRect(0, 0, w, h);
   g.setColor(0x000000);
   String s = "dolce";
   int stringWidth = mFont.stringWidth(s);
   int stringHeight = mFont.getHeight();
   int x = (w - stringWidth) / 2;
   int y = h / 2;
   g.setFont(mFont);
   g.drawString(s, x, y, Graphics.TOP | Graphics.LEFT);
   g.drawRect(x, y, stringWidth, stringHeight);
 }

}

      </source>

Illustrate Graphics MIDlet

   <source lang="java">

/* J2ME in a Nutshell By Kim Topley ISBN: 0-596-00253-X

/

import javax.microedition.lcdui.Canvas; import javax.microedition.lcdui.rumand; import javax.microedition.lcdui.rumandListener; import javax.microedition.lcdui.Display; import javax.microedition.lcdui.Displayable; import javax.microedition.lcdui.Font; import javax.microedition.lcdui.Graphics; import javax.microedition.lcdui.List; import javax.microedition.midlet.MIDlet; public class GraphicsMIDlet extends MIDlet implements CommandListener {

   // The MIDlet"s Display object
   private Display display;
       
   // Flag indicating first call of startApp
   protected boolean started;
   
   // Exit command
   private Command exitCommand;
   
   // Back to examples list command
   private Command backCommand;
   
   // The example selection list
   private List examplesList;
   
   // The Canvases used to demonstrate different Items
   private Canvas[] canvases;
   
   // The example names. Used to populate the list.
   private String[] examples = {
       "Lines", "Rectangles", "RectangleFills",
       "Arcs", "FilledArcs", "Text"
   };
   protected void startApp() {
       if (!started) {
           started = true;
           display = Display.getDisplay(this);
           
           // Create the common commands
           createCommands();
           
           // Create the canvases
           createCanvases();
           
           // Create the list of examples
           createList();
           
           // Start with the List
           display.setCurrent(examplesList);
       }
   }
   protected void pauseApp() {
   }
   protected void destroyApp(boolean unconditional) {
   }
   public void commandAction(Command c, Displayable d) {
       if (d == examplesList) {
           // New example selected
           int index = examplesList.getSelectedIndex();
           display.setCurrent(canvases[index]);
       } else if (c == exitCommand) {
           // Exit. No need to call destroyApp
           // because it is empty.
           notifyDestroyed();
       } else if (c == backCommand) {
           // Go back to main selection list
           display.setCurrent(examplesList);
       }
   }
   
   private void createCommands() {
       exitCommand = new Command("Exit", Command.EXIT, 0);
       backCommand = new Command("Back", Command.BACK, 1);
   }
   
   private void createList() {
       examplesList = new List("Select Example", List.IMPLICIT);
       for (int i = 0; i < examples.length; i++) {
           examplesList.append(examples[i], null);
       } 
       examplesList.setCommandListener(this);
   }
   
   private void createCanvases() {
       canvases = new Canvas[examples.length];
       canvases[0] = createLinesCanvas();
       canvases[1] = createRectanglesCanvas();
       canvases[2] = createRectangleFillsCanvas();
       canvases[3] = createArcsCanvas();
       canvases[4] = createFilledArcsCanvas();
       canvases[5] = createTextCanvas();
       
   }
   private void addCommands(Displayable d) {
       d.addCommand(exitCommand);
       d.addCommand(backCommand);
       d.setCommandListener(this);
   }
   
   // Create the Canvas for the line drawing example
   private Canvas createLinesCanvas() {
       Canvas canvas = new LineCanvas();        
       addCommands(canvas);
       return canvas;
   }    
       
   // Create the Canvas for the rectangles example
   private Canvas createRectanglesCanvas() {
       Canvas canvas = new RectanglesCanvas();        
       addCommands(canvas);
       return canvas;
   }
       
   // Create the Canvas for the filled rectangles example
   private Canvas createRectangleFillsCanvas() {
       Canvas canvas = new RectangleFillsCanvas();        
       addCommands(canvas);
       return canvas;
   }
       
   // Create the Canvas for the arcs example
   private Canvas createArcsCanvas() {
       Canvas canvas = new ArcsCanvas();        
       addCommands(canvas);
       return canvas;
   }
          
   // Create the Canvas for the filled arcs example
   private Canvas createFilledArcsCanvas() {
       Canvas canvas = new FilledArcsCanvas();        
       addCommands(canvas);
       return canvas;
   }    
              
   // Create the Canvas for the text example
   private Canvas createTextCanvas() {
       Canvas canvas = new TextCanvas();        
       addCommands(canvas);
       return canvas;
   }

} // A canvas that illustrates line drawing class LineCanvas extends Canvas {

   public void paint(Graphics g) {
       int width = getWidth();
       int height = getHeight();
       // Fill the background using black
       g.setColor(0);
       g.fillRect(0, 0, width, height);
       // White horizontal line
       g.setColor(0xFFFFFF);
       g.drawLine(0, height/2, width - 1, height/2);
       // Yellow dotted horizontal line
       g.setStrokeStyle(Graphics.DOTTED);
       g.setColor(0xFFFF00);
       g.drawLine(0, height/4, width - 1, height/4);
       // Solid diagonal line in brightest gray
       g.setGrayScale(255);
       g.setStrokeStyle(Graphics.SOLID);
       g.drawLine(0, 0, width - 1, height - 1);
   }

} // A canvas that illustrates rectangles class RectanglesCanvas extends Canvas {

   public void paint(Graphics g) {
       int width = getWidth();
       int height = getHeight();
       // Create a white background
       g.setColor(0xffffff);
       g.fillRect(0, 0, width, height);
       
       // Draw a solid rectangle
       g.setColor(0);
       g.drawRect(width/4, 0, width/2, height/4);
               
       // Draw a dotted rectangle inside
       // the solid rectangle.
       g.setStrokeStyle(Graphics.DOTTED);
       g.drawRect(width/4 + 4, 4, width/2 - 8, height/4 - 8);
       
       // Draw a rounded rectangle
       g.setStrokeStyle(Graphics.SOLID);
       g.drawRoundRect(width/4, height/2, width/2, height/4, 16, 8);
   }

} // A canvas that illustrates filled rectangles class RectangleFillsCanvas extends Canvas {

   public void paint(Graphics g) {
       int width = getWidth();
       int height = getHeight();
       // Create a black background
       g.setColor(0);
       g.fillRect(0, 0, width, height);
       // Draw a filled rectangle with
       // a dotted rectangle around it
       g.setStrokeStyle(Graphics.DOTTED);
       g.setColor(0x00ff00);
       g.fillRect(width/4, height/4, width/2, height/2);
       g.setColor(0xffff00);
       g.drawRect(width/4, height/4, width/2, height/2);
   }

} // A canvas that illustrates arcs class ArcsCanvas extends Canvas {

   public void paint(Graphics g) {
       int width = getWidth();
       int height = getHeight();
       // Create a black background
       g.setColor(0);
       g.fillRect(0, 0, width, height);
       // A quarter circle, clockwise 90 degrees
       // from the 3 o"clock position. Show the
       // bounding rectangle as well.
       g.setColor(0xffffff);
       g.drawArc(0, 0, width/2, height/2, 0, 90);
       g.setStrokeStyle(Graphics.DOTTED);
       g.setColor(0xffff00);
       g.drawRect(0, 0, width/2, height/2);
       // A quarter circle, anticlockwise 90 degrees
       // from the 3 o"clock position. 
       g.setStrokeStyle(Graphics.SOLID);
       g.setColor(0xffffff);
       g.drawArc(width/2, 0, width/2, height/2, 0, -90);
       g.setStrokeStyle(Graphics.DOTTED);
       g.setColor(0xffff00);
       g.drawRect(width/2, 0, width/2, height/2);
      
       // An elliptical arc from the six o"clock
       // position, counterclockwise 180 degrees
       g.setStrokeStyle(Graphics.SOLID);
       g.setColor(0xffffff);
       g.drawArc(0, height/2, width, height/2, -90, -180);
       g.setStrokeStyle(Graphics.DOTTED);
       g.setColor(0xffff00);
       g.drawRect(0, height/2, width, height/2);        
   }

} // A canvas that illustrates filled arcs class FilledArcsCanvas extends Canvas {

   public void paint(Graphics g) {
       int width = getWidth();
       int height = getHeight();
       // Create a black background
       g.setColor(0);
       g.fillRect(0, 0, width, height);
       // A quarter circle, clockwise 90 degrees
       // from the 3 o"clock position. Show the
       // bounding rectangle as well.
       g.setColor(0xffffff);
       g.fillArc(0, 0, width/2, height/2, 0, 90);
       g.setStrokeStyle(Graphics.DOTTED);
       g.setColor(0xffff00);
       g.drawRect(0, 0, width/2, height/2);
       // A quarter circle, anticlockwise 90 degrees
       // from the 3 o"clock position. 
       g.setStrokeStyle(Graphics.SOLID);
       g.setColor(0xffffff);
       g.fillArc(width/2, 0, width/2, height/2, 0, -90);
       g.setStrokeStyle(Graphics.DOTTED);
       g.setColor(0xffff00);
       g.drawRect(width/2, 0, width/2, height/2);
      
       // An elliptical arc from the six o"clock
       // position, counterclockwise 180 degrees
       g.setStrokeStyle(Graphics.SOLID);
       g.setColor(0xffffff);
       g.fillArc(0, height/2, width, height/2, -90, -180);
       g.setStrokeStyle(Graphics.DOTTED);
       g.setColor(0xffff00);
       g.drawRect(0, height/2, width, height/2);        
   }

} // A canvas that illustrates text rendering class TextCanvas extends Canvas {

   public void paint(Graphics g) {
       int width = getWidth();
       int height = getHeight();
       // Create a black background
       g.setColor(0);
       g.fillRect(0, 0, width, height);
       
       // Top-left of canvas
       g.setColor(0xffffff);
       g.drawString("Top left", 0, 0, Graphics.TOP | Graphics.LEFT);
       
       // Draw another string one line below
       Font font = g.getFont();
       g.drawString("Below top left", 0, font.getHeight(), Graphics.TOP | Graphics.LEFT);
       
       // Bottom-right of canvas
       g.drawString("Bottom right", width, height, Graphics.BOTTOM | Graphics.RIGHT);
       
       // Mixed fonts and colors
       String str = "Multi-font ";        
       font = Font.getFont(Font.FACE_PROPORTIONAL, Font.STYLE_UNDERLINED, Font.SIZE_LARGE);
       g.setFont(font);
       g.drawString(str, 0, height/2, Graphics.LEFT | Graphics.BASELINE);
       
       int x = font.stringWidth(str);
       g.setColor(0x00ff00);
       g.setFont(Font.getFont(Font.FACE_PROPORTIONAL, Font.STYLE_BOLD | Font.STYLE_ITALIC, Font.SIZE_MEDIUM));
       g.drawString("and multi-color", x, height/2, Graphics.LEFT | Graphics.BASELINE);
   }

}

      </source>

Key Canvas

   <source lang="java">

import javax.microedition.lcdui.Canvas; import javax.microedition.lcdui.Font; import javax.microedition.lcdui.Graphics; public class KeyCanvas extends Canvas {

 private Font mFont;
 private String mMessage = "[Press keys]";
 public KeyCanvas() {
   mFont = Font.getFont(Font.FACE_PROPORTIONAL, Font.STYLE_PLAIN, Font.SIZE_MEDIUM);
 }
 public void paint(Graphics g) {
   int w = getWidth();
   int h = getHeight();
   // Clear the Canvas.
   g.setGrayScale(255);
   g.fillRect(0, 0, w - 1, h - 1);
   g.setGrayScale(0);
   g.drawRect(0, 0, w - 1, h - 1);
   g.setFont(mFont);
   int x = w / 2;
   int y = h / 2;
   g.drawString(mMessage, x, y, Graphics.BASELINE | Graphics.HCENTER);
 }
 protected void keyPressed(int keyCode) {
   int gameAction = getGameAction(keyCode);
   switch (gameAction) {
   case UP:
     mMessage = "UP";
     break;
   case DOWN:
     mMessage = "DOWN";
     break;
   case LEFT:
     mMessage = "LEFT";
     break;
   case RIGHT:
     mMessage = "RIGHT";
     break;
   case FIRE:
     mMessage = "FIRE";
     break;
   case GAME_A:
     mMessage = "GAME_A";
     break;
   case GAME_B:
     mMessage = "GAME_B";
     break;
   case GAME_C:
     mMessage = "GAME_C";
     break;
   case GAME_D:
     mMessage = "GAME_D";
     break;
   default:
     mMessage = "";
     break;
   }
   repaint();
 }

}

      </source>

Offscreen MIDlet

   <source lang="java">

import javax.microedition.lcdui.Canvas; import javax.microedition.lcdui.rumand; import javax.microedition.lcdui.rumandListener; import javax.microedition.lcdui.Display; import javax.microedition.lcdui.Displayable; import javax.microedition.lcdui.Graphics; import javax.microedition.lcdui.Image; import javax.microedition.midlet.MIDlet; public class OffscreenMIDlet extends MIDlet {

 public void startApp() {
   Displayable d = new OffscreenCanvas();
   d.addCommand(new Command("Exit", Command.EXIT, 0));
   d.setCommandListener(new CommandListener() {
     public void commandAction(Command c, Displayable s) {
       notifyDestroyed();
     }
   });
   Display.getDisplay(this).setCurrent(d);
 }
 public void pauseApp() {
 }
 public void destroyApp(boolean unconditional) {
 }

} class OffscreenCanvas extends Canvas {

 private Image mImage;
 public void paint(Graphics g) {
   if (mImage == null)
     initialize();
   g.drawImage(mImage, 0, 0, Graphics.TOP | Graphics.LEFT);
 }
 private void initialize() {
   int w = getWidth();
   int h = getHeight();
   mImage = Image.createImage(w, h);
   Graphics g = mImage.getGraphics();
   g.drawRect(0, 0, w - 1, h - 1);
   g.drawLine(0, 0, w - 1, h - 1);
   g.drawLine(w - 1, 0, 0, h - 1);
 }

}

      </source>

Pacer

   <source lang="java">

import javax.microedition.lcdui.*; import javax.microedition.midlet.*; public class Pacer extends MIDlet{

 public void startApp() { 
   Displayable d = new PacerCanvas();
   
   d.addCommand(new Command("Exit", Command.EXIT, 0));
   d.setCommandListener(new CommandListener() { 
     public void commandAction(Command c, Displayable s) { 
       notifyDestroyed();
     } 
   } );
   
   Display.getDisplay(this).setCurrent(d);
 } 
 
 public void pauseApp() { } 
 public void destroyApp(boolean unconditional) { }

} class PacerCanvas extends Canvas {

 public void paint(Graphics g) { 
   int w = getWidth();
   int h = getHeight();
   
   g.setColor(0xffffff);
   g.fillRect(0, 0, w, h);
   g.setColor(0x000000);
   for (int x = 0; x < w; x += 10)
     g.drawLine(0, w - x, x, 0);
   
   int z = 50;
   g.drawRect(z, z, 20, 20);
   z += 20;
   g.fillRoundRect(z, z, 20, 20, 5, 5);
   z += 20;
   g.drawArc(z, z, 20, 20, 0, 360);
 }

}

      </source>

Pointer Example

   <source lang="java">

/* J2ME: The Complete Reference James Keogh Publisher: McGraw-Hill ISBN 0072227109

/

//jad file (please verify the jar size) /* MIDlet-Name: PointerExample MIDlet-Version: 1.0 MIDlet-Vendor: MyCompany MIDlet-Jar-URL: PointerExample.jar MIDlet-1: PointerExample, , PointerExample MicroEdition-Configuration: CLDC-1.0 MicroEdition-Profile: MIDP-1.0 MIDlet-JAR-SIZE: 100

/

import javax.microedition.midlet.*; import javax.microedition.lcdui.*; public class PointerExample extends MIDlet {

 private Display  display;       
 private MyClass canvas;   
 public PointerExample()
 {
   display = Display.getDisplay(this);
   canvas  = new MyClass (this);
 }
 protected void startApp()
 {
   display.setCurrent( canvas );
 }
 protected void pauseApp()
 { 
 }
 protected void destroyApp( boolean unconditional )
 { 
 }
 public void exitMIDlet()
 {
   destroyApp(true);
   notifyDestroyed();
 }

} class MyClass extends Canvas implements CommandListener {

 private Command exit;          
 private Command erase;  
 private boolean eraseFlag = false;
 private boolean isFirstPaint;
 private int sX = 0,sY = 0, cX = 0, cY = 0;
 private PointerExample pointerExample;
 public MyClass (PointerExample pointerExample)
 {
   this.pointerExample = pointerExample;
   exit = new Command("Exit", Command.EXIT, 1);
   erase = new Command("Erase", Command.SCREEN, 1);    
   addCommand(exit);
   addCommand(erase);
   setCommandListener(this);
   isFirstPaint = true;
 } 
 protected void paint(Graphics graphics)
 {
   if (eraseFlag || isFirstPaint)
   {
     graphics.setColor(255, 255, 255);
     graphics.fillRect(0, 0, getWidth(), getHeight());
     eraseFlag = isFirstPaint = false;
     sX = 0;
     sY = 0;
     cX = 0;
     cY = 0;
     return;
   }
   graphics.setColor(0, 0, 0);
   graphics.drawLine(sX, sY, cX, cY);
   sX = cX;
   sY = cY;
 }
 public void commandAction(Command command, Displayable displayable)
 {
   if (command == exit)
     pointerExample.exitMIDlet();
   else if (command == erase)
   {
     eraseFlag = true; 
     repaint();
   }
 }
 protected void pointerPressed(int x, int y)
 {
   sX = x;
   sY = y;
 }
 protected void pointerDragged(int x, int y)
 {
   cX = x;
   cY = y;       
   repaint();
 }

}

      </source>

Quatsch MIDlet

   <source lang="java">

/* Wireless Java 2nd edition Jonathan Knudsen Publisher: Apress ISBN: 1590590775

/

import java.io.IOException; import javax.microedition.lcdui.*; import javax.microedition.lcdui.game.*; import javax.microedition.midlet.MIDlet; public class QuatschMIDlet extends MIDlet

   implements CommandListener {
 private Display mDisplay;
 
 private QuatschCanvas mQuatschCanvas;
 private Form mShowForm;
 private Command mExitCommand, mShowCommand, mOkCommand;
 
 public void startApp() {
   if (mQuatschCanvas == null) {
     try {
       mQuatschCanvas = new QuatschCanvas("/quatsch.png",
           "/atmosphere.png", "/background_tiles.png");
       mQuatschCanvas.start();
       mExitCommand = new Command("Exit", Command.EXIT, 0);
       mShowCommand = new Command("Show/Hide", Command.SCREEN, 0);
       mOkCommand = new Command("OK", Command.OK, 0);
       mQuatschCanvas.addCommand(mExitCommand);
       mQuatschCanvas.addCommand(mShowCommand);
       mQuatschCanvas.setCommandListener(this);
     }
     catch (IOException ioe) {
       System.out.println(ioe);
     }
   }
   
   mDisplay = Display.getDisplay(this);
   mDisplay.setCurrent(mQuatschCanvas);
 }
 
 public void pauseApp() {}
 
 public void destroyApp(boolean unconditional) {
   mQuatschCanvas.stop();
 }
 
 public void commandAction(Command c, Displayable s) {
   if (c.getCommandType() == Command.EXIT) {
     destroyApp(true);
     notifyDestroyed();
   }
   else if (c == mShowCommand) {
     if (mShowForm == null) {
       mShowForm = new Form("Show/Hide");
       ChoiceGroup cg = new ChoiceGroup("Layers", Choice.MULTIPLE);
       cg.append("Fog", null);
       cg.append("Dr. Quatsch", null);
       cg.append("Background", null);
       mShowForm.append(cg);
       mShowForm.addCommand(mOkCommand);
       mShowForm.setCommandListener(this);
     }
     ChoiceGroup cg = (ChoiceGroup)mShowForm.get(0);
     cg.setSelectedIndex(0, mQuatschCanvas.isVisible(0));
     cg.setSelectedIndex(1, mQuatschCanvas.isVisible(1));
     cg.setSelectedIndex(2, mQuatschCanvas.isVisible(2));
     mDisplay.setCurrent(mShowForm);
   }
   else if (c == mOkCommand) {
     ChoiceGroup cg = (ChoiceGroup)mShowForm.get(0);
     mQuatschCanvas.setVisible(0, cg.isSelected(0));
     mQuatschCanvas.setVisible(1, cg.isSelected(1));
     mQuatschCanvas.setVisible(2, cg.isSelected(2));
     mDisplay.setCurrent(mQuatschCanvas);
   }
 }

} class QuatschCanvas extends GameCanvas implements Runnable {

 private boolean mTrucking;
 
 private LayerManager mLayerManager;
 
 private TiledLayer mAtmosphere;
 private TiledLayer mBackground;
 private int mAnimatedIndex;
 
 private Sprite mQuatsch;
 private int mState, mDirection;
 
 private static final int kStanding = 1;
 private static final int kRunning = 2;
 
 private static final int kLeft = 1;
 private static final int kRight = 2;
 
 private static final int[] kRunningSequence = { 0, 1, 2 };
 private static final int[] kStandingSequence = { 3 };
 
 public QuatschCanvas(String quatschImageName,
     String atmosphereImageName, String backgroundImageName)
     throws IOException {
   super(true);
   
   // Create a LayerManager.
   mLayerManager = new LayerManager();
   int w = getWidth();
   int h = getHeight();
   mLayerManager.setViewWindow(96, 0, w, h);
   
   createBackground(backgroundImageName);
   createAtmosphere(atmosphereImageName);
   createQuatsch(quatschImageName);
 }
 
 private void createBackground(String backgroundImageName)
     throws IOException {
   // Create the tiled layer.
   Image backgroundImage = Image.createImage(backgroundImageName);
   int[] map = {
     1, 2, 0, 0, 0, 0, 0, 0,
     3, 3, 2, 0, 0, 0, 5, 0,
     3, 3, 3, 2, 4, 1, 3, 2,
     6, 6, 6, 6, 6, 6, 6, 6
   };
   mBackground = new TiledLayer(8, 4, backgroundImage, 48, 48);
   mBackground.setPosition(12, 0);
   for (int i = 0; i < map.length; i++) {
     int column = i % 8;
     int row = (i - column) / 8;
     mBackground.setCell(column, row, map[i]);
   }
   mAnimatedIndex = mBackground.createAnimatedTile(8);
   mBackground.setCell(3, 0, mAnimatedIndex);
   mBackground.setCell(5, 0, mAnimatedIndex);
   mLayerManager.append(mBackground);
 }
   
 private void createAtmosphere(String atmosphereImageName)
     throws IOException {
   // Create the atmosphere layer
   Image atmosphereImage = Image.createImage(atmosphereImageName);
   mAtmosphere = new TiledLayer(8, 1, atmosphereImage,
       atmosphereImage.getWidth(), atmosphereImage.getHeight());
   mAtmosphere.fillCells(0, 0, 8, 1, 1);
   mAtmosphere.setPosition(0, 96);
   mLayerManager.insert(mAtmosphere, 0);
 }
 private void createQuatsch(String quatschImageName)
     throws IOException {
   // Create the sprite.
   Image quatschImage = Image.createImage(quatschImageName);
   mQuatsch = new Sprite(quatschImage, 48, 48);
   mQuatsch.setPosition(96 + (getWidth() - 48) / 2, 96);
   mQuatsch.defineReferencePixel(24, 24);
   setDirection(kLeft);
   setState(kStanding);
   mLayerManager.insert(mQuatsch, 1);
 }
 public void start() {
   mTrucking = true;
   Thread t = new Thread(this);
   t.start();
 }
 
 public void run() {
   int w = getWidth();
   int h = getHeight();
   Graphics g = getGraphics();
   int frameCount = 0;
   int factor = 2;
   int animatedDelta = 0;
   
   while (mTrucking) {
     if (isShown()) {
       int keyStates = getKeyStates();
       if ((keyStates & LEFT_PRESSED) != 0) {
         setDirection(kLeft);
         setState(kRunning);
         mBackground.move(3, 0);
         mAtmosphere.move(3, 0);
         mQuatsch.nextFrame();
       }
       else if ((keyStates & RIGHT_PRESSED) != 0) {
         setDirection(kRight);
         setState(kRunning);
         mBackground.move(-3, 0);
         mAtmosphere.move(-3, 0);
         mQuatsch.nextFrame();
       }
       else {
         setState(kStanding);
       }
       
       frameCount++;
       if (frameCount % factor == 0) {
         int delta = 1;
         if (frameCount / factor < 10) delta = -1;
         mAtmosphere.move(delta, 0);
         if (frameCount / factor == 20) frameCount = 0;
         mBackground.setAnimatedTile(mAnimatedIndex,
             8 + animatedDelta++);
         if (animatedDelta == 3) animatedDelta = 0;
       }
       g.setColor(0x5b1793);
       g.fillRect(0, 0, w, h);
       
       mLayerManager.paint(g, 0, 0);
       
       flushGraphics();
     }
     
     try { Thread.sleep(80); }
     catch (InterruptedException ie) {}
   }
 }
 
 public void stop() {
   mTrucking = false;
 }
 
 public void setVisible(int layerIndex, boolean show) {
   Layer layer = mLayerManager.getLayerAt(layerIndex);
   layer.setVisible(show);
 }
 
 public boolean isVisible(int layerIndex) {
   Layer layer = mLayerManager.getLayerAt(layerIndex);
   return layer.isVisible();
 }
 
 private void setDirection(int newDirection) {
   if (newDirection == mDirection) return;
   if (mDirection == kLeft)
     mQuatsch.setTransform(Sprite.TRANS_MIRROR);
   else if (mDirection == kRight)
     mQuatsch.setTransform(Sprite.TRANS_NONE);
   mDirection = newDirection;
 }
 
 private void setState(int newState) {
   if (newState == mState) return;
   switch (newState) {
     case kStanding:
       mQuatsch.setFrameSequence(kStandingSequence);
       mQuatsch.setFrame(0);
       break;
     case kRunning:
       mQuatsch.setFrameSequence(kRunningSequence);
       break;
     default:
       break;
   }
   mState = newState;
 }

}

      </source>

Show various anchor points

   <source lang="java">

/*--------------------------------------------------

Text.java
Show various anchor points
Example from the book: Core J2ME Technology
Copyright John W. Muchow http://www.CoreJ2ME.ru
You may use/modify for any non-commercial purpose
-------------------------------------------------*/

import javax.microedition.midlet.*; import javax.microedition.lcdui.*; public class Text extends MIDlet {

 private Display  display;       // The display
 private TextCanvas canvas;      // Canvas to display text
 private AnchorPtList anchorPt;  // List to query for anchor point
 private int anchorPoint = Graphics.BASELINE | Graphics.HCENTER;

 public Text()
 {
   display = Display.getDisplay(this);
   canvas  = new TextCanvas(this);
   anchorPt = new AnchorPtList("Anchor point", List.IMPLICIT, this);    
 }

 protected void startApp()
 {
   showCanvas();  
 }

 protected void pauseApp()
 { }
 protected void destroyApp( boolean unconditional )
 { }
 public void showCanvas()
 {
   display.setCurrent(canvas);
 }
 public void showList()
 {
   display.setCurrent(anchorPt);
 }
  
 public int getAnchorPoint()
 {
   return anchorPoint;
 }
 
 public void setAnchorPoint(int anchorPoint)
 {
   this.anchorPoint = anchorPoint;
 }

 public void exitMIDlet()
 {
   destroyApp(true);
   notifyDestroyed();
 }

} /*--------------------------------------------------

Class TextCanvas
Draw text at specified anchor point
-------------------------------------------------*/

class TextCanvas extends Canvas implements CommandListener {

 private Command cmExit;  // Exit midlet
 private Command cmGetAnchorPt;
 private Text midlet;

 public TextCanvas(Text midlet)
 {
   this.midlet = midlet;
   
   // Create commands & listen for events
   cmExit = new Command("Exit", Command.EXIT, 1);
   cmGetAnchorPt = new Command("Anchor", Command.SCREEN, 2);
   
   addCommand(cmExit);
   addCommand(cmGetAnchorPt);
   setCommandListener(this);
 } 
 /*--------------------------------------------------
 * Draw text 
 *-------------------------------------------------*/
 protected void paint(Graphics g)
 {
   int xcenter = getWidth() / 2,
       ycenter = getHeight() / 2;

   // Due to a bug in MIDP 1.0.3 we need to 
   // force a clear of the display
   g.setColor(255, 255, 255);                  // White pen
   g.fillRect(0, 0, getWidth(), getHeight());
   g.setColor(0, 0, 0);                        // Black pen
   // Choose a font
   g.setFont(Font.getFont(Font.FACE_SYSTEM, Font.STYLE_PLAIN, Font.SIZE_MEDIUM));
    
   // Draw a dot at the center of the display
   g.drawLine(xcenter, ycenter, xcenter, ycenter);
   
   // x and y are always at the center of the display 
   // Move the text around x and y based on the anchor point 
   g.drawString("go j2me!", xcenter, ycenter, midlet.getAnchorPoint());
 }
 /*--------------------------------------------------
 * Exit midlet or show anchor point selection list
 *-------------------------------------------------*/
 public void commandAction(Command c, Displayable d)
 {
   if (c == cmExit)
     midlet.exitMIDlet();
   else if (c == cmGetAnchorPt)
   {
     midlet.showList();      
   }
 }

} /*--------------------------------------------------

Class AnchorPtList
List to query for an anchor point
-------------------------------------------------*/

class AnchorPtList extends List implements CommandListener {

 private Text midlet;
 
 public AnchorPtList(String title, int listType, Text midlet)
 {
   // Call list constructor
   super(title, listType); 
   this.midlet = midlet;
   append("Top/Left", null);
   append("Top/HCenter", null);
   append("Top/Right", null);
   
   append("Baseline/Left", null);    
   append("Baseline/HCenter", null);
   append("Baseline/Right", null);
   
   append("Bottom/Left", null);    
   append("Bottom/HCenter", null);
   append("Bottom/Right", null);        
   
   setCommandListener(this);
 }
 /*--------------------------------------------------
 * Commands to set anchor point
 *-------------------------------------------------*/
 public void commandAction(Command c, Displayable s)
 {
   switch (getSelectedIndex())
   {
     case 0:
         midlet.setAnchorPoint(Graphics.TOP | Graphics.LEFT);
       break;
     case 1:
         midlet.setAnchorPoint(Graphics.TOP | Graphics.HCENTER);
       break;
       
     case 2:
       midlet.setAnchorPoint(Graphics.TOP | Graphics.RIGHT);
       break;        
     case 3:
       midlet.setAnchorPoint(Graphics.BASELINE | Graphics.LEFT);
       break;        
     case 4:
       midlet.setAnchorPoint(Graphics.BASELINE | Graphics.HCENTER);
       break;        
     case 5:
       midlet.setAnchorPoint(Graphics.BASELINE | Graphics.RIGHT);
       break;        
     case 6:
       midlet.setAnchorPoint(Graphics.BOTTOM | Graphics.LEFT);
       break;        
     case 7:
       midlet.setAnchorPoint(Graphics.BOTTOM | Graphics.HCENTER);
       break;        
     case 8:
       midlet.setAnchorPoint(Graphics.BOTTOM | Graphics.RIGHT);
       break;        
       
     default:
       midlet.setAnchorPoint(Graphics.BASELINE | Graphics.HCENTER);
   }
   midlet.showCanvas();
 }

}

      </source>

Simple Canvas

   <source lang="java">

/* Title: J2ME Games With MIDP2 Authors: Carol Hamer Publisher: Apress ISBN: 1590593820

/

import javax.microedition.midlet.*; import javax.microedition.lcdui.*; /**

* This is the main class of the hello world demo.
*
* @author Carol Hamer
*/

public class Hello extends MIDlet implements CommandListener {

 /**
  * The canvas is the region of the screen that has been allotted 
  * to the game.
  */
 HelloCanvas myCanvas;
 /**
  * The Command objects appear as buttons in this example.
  */
 private Command exitCommand = new Command("Exit", Command.EXIT, 99);
 /**
  * The Command objects appear as buttons in this example.
  */
 private Command toggleCommand = new Command("Toggle Msg", Command.SCREEN, 1);
 /**
  * Initialize the canvas and the commands.
  */
 public Hello() {
   myCanvas = new HelloCanvas();
   myCanvas.addCommand(exitCommand);
   myCanvas.addCommand(toggleCommand);
   // we set one command listener to listen to all 
   // of the commands on the canvas:
   myCanvas.setCommandListener(this);
 }
 //----------------------------------------------------------------
 //  implementation of MIDlet
 /**
  * Start the application.
  */
 public void startApp() throws MIDletStateChangeException {
   // display my canvas on the screen:
   Display.getDisplay(this).setCurrent(myCanvas);
   myCanvas.repaint();
 }
 
 /**
  * If the MIDlet was using resources, it should release 
  * them in this method.
  */
 public void destroyApp(boolean unconditional) 
     throws MIDletStateChangeException {
 }
 /**
  * This method is called to notify the MIDlet to enter a paused 
  * state.  The MIDlet should use this opportunity to release 
  * shared resources.
  */
 public void pauseApp() {
 }
 //----------------------------------------------------------------
 //  implementation of CommandListener
 /*
  * Respond to a command issued on the Canvas.
  * (either reset or exit).
  */
 public void commandAction(Command c, Displayable s) {
   if(c == toggleCommand) {
     myCanvas.toggleHello();
   } else if(c == exitCommand) {
     try {
 destroyApp(false);
 notifyDestroyed();
     } catch (MIDletStateChangeException ex) {
     }
   }
 }

}

/**

* This class represents the region of the screen that has been allotted 
* to the game.
* 
* @author Carol Hamer
*/

class HelloCanvas extends Canvas {

 //---------------------------------------------------------
 //   fields
 /**
  * whether or not the screen should currently display the 
  * "hello world" message.
  */
 boolean mySayHello = true;
 //-----------------------------------------------------
 //    initialization and game state changes
 /**
  * toggle the hello message.
  */
 void toggleHello() {
   mySayHello = !mySayHello;
   repaint();
 }
 //-------------------------------------------------------
 //  graphics methods
 /**
  * clear the screen and display the hello world message if appropriate.
  */
 public void paint(Graphics g) {
   // get the dimensions of the screen:
   int width = getWidth();
   int height = getHeight();
   // clear the screen (paint it white):
   g.setColor(0xffffff);
   // The first two args give the coordinates of the top 
   // left corner of the rectangle.  (0,0) corresponds 
   // to the top left corner of the screen.
   g.fillRect(0, 0, width, height);
   // display the hello world message if appropriate:.
   if(mySayHello) {
     Font font = g.getFont();
     int fontHeight = font.getHeight();
     int fontWidth = font.stringWidth("Hello World!");
     // set the text color to red:
     g.setColor(255, 0, 0);
     g.setFont(font);
     // write the string in the center of the screen
     g.drawString("Hello World!", (width - fontWidth)/2, 
      (height - fontHeight)/2,
      g.TOP|g.LEFT);
   }
 }

}

      </source>

Text Example

   <source lang="java">

//jad file (please verify the jar size) /* MIDlet-Name: TextExample MIDlet-Version: 1.0 MIDlet-Vendor: MyCompany MIDlet-Jar-URL: TextExample.jar MIDlet-1: TextExample, , TextExample MicroEdition-Configuration: CLDC-1.0 MicroEdition-Profile: MIDP-1.0 MIDlet-JAR-SIZE: 100

/

import javax.microedition.lcdui.Canvas; import javax.microedition.lcdui.rumand; import javax.microedition.lcdui.rumandListener; import javax.microedition.lcdui.Display; import javax.microedition.lcdui.Displayable; import javax.microedition.lcdui.Font; import javax.microedition.lcdui.Graphics; import javax.microedition.midlet.MIDlet; public class TextExampleMIDlet extends MIDlet {

 private Display display;
 private MyCanvas canvas;
 public TextExampleMIDlet() {
   display = Display.getDisplay(this);
   canvas = new MyCanvas(this);
 }
 protected void startApp() {
   display.setCurrent(canvas);
 }
 protected void pauseApp() {
 }
 protected void destroyApp(boolean unconditional) {
 }
 public void exitMIDlet() {
   destroyApp(true);
   notifyDestroyed();
 }

} class MyCanvas extends Canvas implements CommandListener {

 private Command exit;
 private TextExampleMIDlet textExample;
 public MyCanvas(TextExampleMIDlet textExample) {
   this.textExample = textExample;
   exit = new Command("Exit", Command.EXIT, 1);
   addCommand(exit);
   setCommandListener(this);
 }
 protected void paint(Graphics graphics) {
   graphics.setColor(255, 255, 255);
   graphics.fillRect(0, 0, getWidth(), getHeight());
   graphics.setColor(255, 0, 0);
   graphics.setFont(Font.getFont(Font.FACE_PROPORTIONAL, Font.STYLE_BOLD, Font.SIZE_SMALL));
   graphics.drawString("Profound statement.", 50, 10, Graphics.HCENTER | Graphics.BASELINE);
 }
 public void commandAction(Command command, Displayable displayable) {
   if (command == exit) {
     textExample.exitMIDlet();
   }
 }

}

      </source>

Text MIDlet

   <source lang="java">

import javax.microedition.lcdui.Canvas; import javax.microedition.lcdui.rumand; import javax.microedition.lcdui.rumandListener; import javax.microedition.lcdui.Display; import javax.microedition.lcdui.Displayable; import javax.microedition.lcdui.Graphics; import javax.microedition.midlet.MIDlet; public class TextMIDlet extends MIDlet {

 public void startApp() {
   Displayable d = new TextCanvas();
   d.addCommand(new Command("Exit", Command.EXIT, 0));
   d.setCommandListener(new CommandListener() {
     public void commandAction(Command c, Displayable s) {
       notifyDestroyed();
     }
   });
   Display.getDisplay(this).setCurrent(d);
 }
 public void pauseApp() {
 }
 public void destroyApp(boolean unconditional) {
 }

} class TextCanvas extends Canvas {

 public void paint(Graphics g) {
   int w = getWidth();
   int h = getHeight();
   g.setColor(0xffffff);
   g.fillRect(0, 0, w, h);
   g.setColor(0x000000);
   g.drawString("corner", 0, 0, Graphics.TOP | Graphics.LEFT);
   g.drawString("corner", w, 0, Graphics.TOP | Graphics.RIGHT);
   g.drawString("corner", 0, h, Graphics.BOTTOM | Graphics.LEFT);
   g.drawString("corner", w, h, Graphics.BOTTOM | Graphics.RIGHT);
   g.drawString("Sin Wagon", w / 2, h / 2, Graphics.BASELINE | Graphics.HCENTER);
 }

}

      </source>

Translate Coordinates

   <source lang="java">

/* J2ME: The Complete Reference James Keogh Publisher: McGraw-Hill ISBN 0072227109

/

//jad file (please verify the jar size) /* MIDlet-Name: TranslateCoordinates MIDlet-Version: 1.0 MIDlet-Vendor: MyCompany MIDlet-Jar-URL: TranslateCoordinates.jar MIDlet-1: TranslateCoordinates, , TranslateCoordinates MicroEdition-Configuration: CLDC-1.0 MicroEdition-Profile: MIDP-1.0 MIDlet-JAR-SIZE: 100

/

import javax.microedition.midlet.*; import javax.microedition.lcdui.*; public class TranslateCoordinates extends MIDlet {

 private Display  display;     
 private MyCanvas canvas;   
 public TranslateCoordinates ()
 {
   display = Display.getDisplay(this);
   canvas  = new MyCanvas (this);
 }
 protected void startApp()
 {
   display.setCurrent( canvas );
 }
 protected void pauseApp()
 { 
 }
 protected void destroyApp( boolean unconditional )
 { 
 }
 public void exitMIDlet()
 {
   destroyApp(true);
   notifyDestroyed();
 }
 class MyCanvas extends Canvas implements CommandListener
 {
   private Command exit;  
   private TranslateCoordinates translateCoordinates;
   private Image image = null;
   public MyCanvas(TranslateCoordinates translateCoordinates)
   {
     this. translateCoordinates = translateCoordinates;
     exit = new Command("Exit", Command.EXIT, 1);
     addCommand(exit);
     setCommandListener(this);
     try
     {
       image = Image.createImage(70, 70);
       Graphics graphics = image.getGraphics();
       graphics.setColor(255,0,0);
       graphics.fillArc(10, 10, 60, 50, 180, 180);      
     }
     catch (Exception error)
     {
       Alert alert = new Alert("Failure", 
                        "Creating Image", null, null);
       alert.setTimeout(Alert.FOREVER);
       display.setCurrent(alert);
     }    
   } 
   protected void paint(Graphics graphics)
   {
     if (image != null)
     {
      graphics.setColor(255,255,255);
      graphics.fillRect(0, 0, getWidth(), getHeight());
      graphics.translate(45, 45);
      graphics.drawImage(image, 0, 0, 
                     Graphics.VCENTER | Graphics.HCENTER);    }
   }
   public void commandAction(Command command, Displayable display)
   {
     if (command == exit)
     {
       translateCoordinates.exitMIDlet();
     }
   }
 }

}

      </source>

Translate coordinate system

   <source lang="java">

/*--------------------------------------------------

Translate.java
Translate coordinate system
Example from the book: Core J2ME Technology
Copyright John W. Muchow http://www.CoreJ2ME.ru
You may use/modify for any non-commercial purpose
-------------------------------------------------*/

import javax.microedition.midlet.*; import javax.microedition.lcdui.*; public class Translate extends MIDlet {

 private Display  display;     // The display
 private TranslateCanvas canvas;   // Canvas 

 public Translate()
 {
   display = Display.getDisplay(this);
   canvas  = new TranslateCanvas(this);
 }

 protected void startApp()
 {
   display.setCurrent( canvas );
 }

 protected void pauseApp()
 { }
 protected void destroyApp( boolean unconditional )
 { }

 public void exitMIDlet()
 {
   destroyApp(true);
   notifyDestroyed();
 }

} /*--------------------------------------------------

Class Translate
Draw image using translated coordinates
-------------------------------------------------*/

class TranslateCanvas extends Canvas implements CommandListener {

 private Command cmExit;  // Exit midlet
 private Translate midlet;
 private Image im = null;
 private int translatex = 0, translatey = 0;

 public TranslateCanvas(Translate midlet)
 {
   this.midlet = midlet;
   
   // Create exit command & listen for events
   cmExit = new Command("Exit", Command.EXIT, 1);
   addCommand(cmExit);
   setCommandListener(this);
   try
   {
     // Create immutable image
     im = Image.createImage("/bolt.png");
   }
   catch (java.io.IOException e)
   {
     System.err.println("Unable to locate or read .png file");
   }    
 } 
 protected void paint(Graphics g)
 {
   if (im != null)
   {
     // Clear the background
     g.setColor(255, 255, 255);
     g.fillRect(0, 0, getWidth(), getHeight());
     
     // Translate coordinates
     g.translate(translatex, translatey);      
   
     // Always draw at 0,0
     g.drawImage(im, 0, 0, Graphics.LEFT | Graphics.TOP);
   }
 }
 public void commandAction(Command c, Displayable d)
 {
   if (c == cmExit)
     midlet.exitMIDlet();
 }
 
 protected void keyPressed(int keyCode)
 {
   switch (getGameAction(keyCode))
   {
     case UP: 
     
       // If scrolling off the top, roll around to bottom
       if (translatey - im.getHeight() < 0)
         translatey = getHeight() - im.getHeight();
       else
         translatey -= im.getHeight();          
       break;
     
     case DOWN:
       // If scrolling off the bottom, roll around to top
       if ((translatey + im.getHeight() + im.getHeight()) > getHeight())
         translatey = 0;
       else
         translatey += im.getHeight();          
       break;
       
     case LEFT:
     
       // If scrolling off the left, bring around to right
       if (translatex - im.getWidth() < 0)
         translatex = getWidth() - im.getWidth();
       else
         translatex -= im.getWidth();          
       break;
     case RIGHT:
     
       // If scrolling off the right, bring around to left
       if ((translatex + im.getWidth() + translatex) > getWidth())
         translatex = 0;
       else
         translatex += im.getWidth();          
       break;
   }        
   repaint();
 }

}

      </source>

Use pointer events to draw onto the Canvas

   <source lang="java">

/*--------------------------------------------------

Doodle.java
Use pointer events to draw onto the Canvas
Example from the book: Core J2ME Technology
Copyright John W. Muchow http://www.CoreJ2ME.ru
You may use/modify for any non-commercial purpose
-------------------------------------------------*/

import javax.microedition.midlet.*; import javax.microedition.lcdui.*; public class Doodle extends MIDlet {

 private Display  display;       // The display
 private DoodleCanvas canvas;   // Canvas 

 public Doodle()
 {
   display = Display.getDisplay(this);
   canvas  = new DoodleCanvas(this);
 }

 protected void startApp()
 {
   display.setCurrent( canvas );
 }

 protected void pauseApp()
 { }
 protected void destroyApp( boolean unconditional )
 { }

 public void exitMIDlet()
 {
   destroyApp(true);
   notifyDestroyed();
 }

} /*--------------------------------------------------

Class DoodleCanvas
Pointer event handling
-------------------------------------------------*/

class DoodleCanvas extends Canvas implements CommandListener {

 private Command cmExit;          // Exit midlet
 
 private Command cmClear;         // Clear display
 
 private int startx = 0,   // Where pointer was clicked
             
             starty = 0,
             
             currentx = 0, // Current location
             
             currenty = 0;
 private Doodle midlet;
 private boolean clearDisplay = false;
 /*--------------------------------------------------
 * Constructor
 *-------------------------------------------------*/
 public DoodleCanvas(Doodle midlet)
 {
   this.midlet = midlet;
   
   // Create exit command & listen for events
   cmExit = new Command("Exit", Command.EXIT, 1);
   cmClear = new Command("Clear", Command.SCREEN, 1);    
   addCommand(cmExit);
   addCommand(cmClear);
   setCommandListener(this);
 } 
 /*--------------------------------------------------
 * Paint the text representing the key code 
 *-------------------------------------------------*/
 protected void paint(Graphics g)
 {
   // Clear the background (to white)
   if (clearDisplay)
   {
     g.setColor(255, 255, 255);
     g.fillRect(0, 0, getWidth(), getHeight());
     
     clearDisplay = false;
     startx = currentx = starty = currenty = 0;
     
     return;
   }
   
   // Draw with black pen
   g.setColor(0, 0, 0);
   
   // Draw line
   g.drawLine(startx, starty, currentx, currenty);
   
   // New starting point is the current position
   startx = currentx;
   starty = currenty;
 }
 /*--------------------------------------------------
 * Command event handling
 *-------------------------------------------------*/  
 public void commandAction(Command c, Displayable d)
 {
   if (c == cmExit)
     midlet.exitMIDlet();
   else if (c == cmClear)
   {
     clearDisplay = true; 
     repaint();
   }
 }
 /*--------------------------------------------------
 * Pointer pressed
 *-------------------------------------------------*/  
 protected void pointerPressed(int x, int y)
 {
   startx = x;
   starty = y;
 }
 /*--------------------------------------------------
 * Pointer moved
 *-------------------------------------------------*/  
 protected void pointerDragged(int x, int y)
 {
   currentx = x;
   currenty = y;       
   repaint();
 }

}

      </source>

Java/J2ME/2D

Содержание

Box Text Canvas

Illustrate Graphics MIDlet

Key Canvas

Offscreen MIDlet

Pacer

Pointer Example

Quatsch MIDlet

Show various anchor points

Simple Canvas

Text Example

Text MIDlet

Translate Coordinates

Translate coordinate system

Use pointer events to draw onto the Canvas

Навигация

Персональные инструменты

Пространства имён

Варианты

Просмотры

Ещё

Поиск

Разделы

Навигация

Инструменты