Examples of javax.microedition.lcdui.Graphics

javax.microedition.lcdui.Graphics

drawRect(x, y, w, h); // 2

Statement (1) fills a rectangle w pixels wide and h pixels high. Statement (2) draws a rectangle whose left and top edges are within the area filled by statement (1). However, the bottom and right edges lie one pixel outside the filled area. This is counterintuitive, but it preserves the invariant that

 g.drawLine(x, y, x+w, y); g.drawLine(x+w, y, x+w, y+h); g.drawLine(x+w, y+h, x, y+h); g.drawLine(x, y+h, x, y);

has an effect identical to statement (2) above.

The exact pixels painted by drawLine() and drawArc() are not specified. Pixels touched by a fill operation must either exactly overlap or directly abut pixels touched by the corresponding draw operation. A fill operation must never leave a gap between the filled area and the pixels touched by the corresponding draw operation, nor may the fill operation touch pixels outside the area bounded by the corresponding draw operation.

Clipping

The clip is the set of pixels in the destination of the Graphics object that may be modified by graphics rendering operations.

There is a single clip per Graphics object. The only pixels modified by graphics operations are those that lie within the clip. Pixels outside the clip are not modified by any graphics operations.

Operations are provided for intersecting the current clip with a given rectangle and for setting the current clip outright. The application may specify the clip by supplying a clip rectangle using coordinates relative to the current coordinate system.

It is legal to specify a clip rectangle whose width or height is zero or negative. In this case the clip is considered to be empty, that is, no pixels are contained within it. Therefore, if any graphics operations are issued under such a clip, no pixels will be modified.

It is legal to specify a clip rectangle that extends beyond or resides entirely beyond the bounds of the destination. No pixels exist outside the bounds of the destination, and the area of the clip rectangle that is outside the destination is ignored. Only the pixels that lie both within the destination and within the specified clip rectangle are considered to be part of the clip.

Operations on the coordinate system, such as {@link Graphics#translate(int,int) translate()}, do not modify the clip. The methods {@link Graphics#getClipX() getClipX()}, {@link Graphics#getClipY() getClipY()}, {@link Graphics#getClipWidth() getClipWidth()} and{@link Graphics#getClipHeight() getClipHeight()}must return a rectangle that, if passed to setClip without an intervening change to the Graphics object's coordinate system, must result in the identical set of pixels in the clip. The rectangle returned from the getClip family of methods may differ from the clip rectangle that was requested in {@link Graphics#setClip(int,int,int,int) setClip()}. This can occur if the coordinate system has been changed or if the implementation has chosen to intersect the clip rectangle with the bounds of the destination of the Graphics object.

If a graphics operation is affected by the clip, the pixels touched by that operation must be the same ones that would be touched as if the clip did not affect the operation. For example, consider a clip represented by the rectangle (cx, cy, cw, ch) and a point (x1, y1) that lies outside this rectangle and a point (x2, y2) that lies within this rectangle. In the following code fragment,

 g.setClip(0, 0, canvas.getWidth(), canvas.getHeight()); g.drawLine(x1, y1, x2, y2); // 3 g.setClip(cx, cy, cw, ch); g.drawLine(x1, y1, x2, y2); // 4

The pixels touched by statement (4) must be identical to the pixels within (cx, cy, cw, ch) touched by statement (3).

Anchor Points

The drawing of text is based on "anchor points". Anchor points are used to minimize the amount of computation required when placing text. For example, in order to center a piece of text, an application needs to call stringWidth() or charWidth() to get the width and then perform a combination of subtraction and division to compute the proper location. The method to draw text is defined as follows:

 public void drawString(String text, int x, int y, int anchor);

This method draws text in the current color, using the current font with its anchor point at (x,y). The definition of the anchor point must be one of the horizontal constants (LEFT, HCENTER, RIGHT) combined with one of the vertical constants (TOP, BASELINE, BOTTOM) using the bit-wise OR operator. Zero may also be used as the value of an anchor point. Using zero for the anchor point value gives results identical to using TOP | LEFT.

Vertical centering of the text is not specified since it is not considered useful, it is hard to specify, and it is burdensome to implement. Thus, the VCENTER value is not allowed in the anchor point parameter of text drawing calls.

The actual position of the bounding box of the text relative to the (x, y) location is determined by the anchor point. These anchor points occur at named locations along the outer edge of the bounding box. Thus, if f is g's current font (as returned by g.getFont(), the following calls will all have identical results:

 g.drawString(str, x, y, TOP|LEFT); g.drawString(str, x + f.stringWidth(str)/2, y, TOP|HCENTER); g.drawString(str, x + f.stringWidth(str), y, TOP|RIGHT); g.drawString(str, x, y + f.getBaselinePosition(), BASELINE|LEFT); g.drawString(str, x + f.stringWidth(str)/2, y + f.getBaselinePosition(), BASELINE|HCENTER); g.drawString(str, x + f.stringWidth(str), y + f.getBaselinePosition(), BASELINE|RIGHT); drawString(str, x, y + f.getHeight(), BOTTOM|LEFT); drawString(str, x + f.stringWidth(str)/2, y + f.getHeight(), BOTTOM|HCENTER); drawString(str, x + f.stringWidth(str), y + f.getHeight(), BOTTOM|RIGHT);

For text drawing, the inter-character and inter-line spacing (leading) specified by the font designer are included as part of the values returned in the {@link Font#stringWidth(java.lang.String) stringWidth()}and {@link Font#getHeight() getHeight()}calls of class {@link Font Font}. For example, given the following code:

 // (5) g.drawString(string1+string2, x, y, TOP|LEFT); // (6) g.drawString(string1, x, y, TOP|LEFT); g.drawString(string2, x + f.stringWidth(string1), y, TOP|LEFT);

Code fragments (5) and (6) behave similarly if not identically. This occurs because f.stringWidth() includes the inter-character spacing. The exact spacing of may differ between these calls if the system supports font kerning.

Similarly, reasonable vertical spacing may be achieved simply by adding the font height to the Y-position of subsequent lines. For example:

 g.drawString(string1, x, y, TOP|LEFT); g.drawString(string2, x, y + f.fontHeight(), TOP|LEFT);

draws string1 and string2 on separate lines with an appropriate amount of inter-line spacing.

The stringWidth() of the string and the fontHeight() of the font in which it is drawn define the size of the bounding box of a piece of text. As described above, this box includes inter-line and inter-character spacing. The implementation is required to put this space below and to right of the pixels actually belonging to the characters drawn. Applications that wish to position graphics closely with respect to text (for example, to paint a rectangle around a string of text) may assume that there is space below and to the right of a string and that there is no space above and to the left of the string.

Anchor points are also used for positioning of images. Similar to text drawing, the anchor point for an image specifies the point on the bounding rectangle of the destination that is to positioned at the (x,y) location given in the graphics request. Unlike text, vertical centering of images is well-defined, and thus the VCENTER value may be used within the anchor point parameter of image drawing requests. Because images have no notion of a baseline, the BASELINE value may not be used within the anchor point parameter of image drawing requests.

Reference

Porter-Duff: Porter, T., and T. Duff. "Compositing Digital Images." Computer Graphics V18 N3 (SIGGRAPH 1984), p. 253-259.

@since MIDP 1.0

            final int firstElement,
            final int lastElement) {


        final Image img = (BUFFER == null ? canvas : BUFFER);


        final Graphics g = img.getGraphics();
        final int w = img.getWidth();
        final int h = img.getHeight();


        final int color_bg = cp.colors[ColorScheme.COLOR_BACKGROUND];


        g.setColor(color_bg);
        g.fillRect(0, 0, w, h);
        
        page.drawSelected(g, cp, firstElement, lastElement);


        renderRotate(img);
    }

View Full Code Here

    private void renderRotate(final Image img) {
        /*
         * Rotate, if necessary
         */
        if (orientation != BookCanvas.ORIENTATION_0) {
            final Graphics gx = canvas.getGraphics();
            gx.drawRegion(img, 0, 0, img.getWidth(), img.getHeight(),
                    orientation, 0, 0,
                    Graphics.LEFT | Graphics.TOP);
        }
    }

View Full Code Here


        int sourceWidth = image.getWidth();
        int sourceHeight = image.getHeight();


        Image thumb = Image.createImage(thumbWidth, thumbHeight);
        Graphics g = thumb.getGraphics();


        int dx, dy;
        int anchor = Graphics.LEFT | Graphics.TOP;


        for (int y = 0; y < thumbHeight; y++) {
            for (int x = 0; x < thumbWidth; x++) {
                g.setClip(x, y, 1, 1);
                dx = x * sourceWidth / thumbWidth;
                dy = y * sourceHeight / thumbHeight;
                g.drawImage(image, x - dx, y - dy, anchor);
            }
        }


        return thumb;
    }

View Full Code Here

 *
 */
public class GraphicsSample {
  
  public static void main(String [] options) throws Exception {
    Graphics g = new Graphics();
    g.drawLine(5,5,60,60);
    g.drawRect(62, 10, 25, 35);
    g.refresh();
    Button.waitForPress();
  }

View Full Code Here

    public static Image getAdjustedImage(Image image, int _width, int _height)
    {
        int srcWidth = image.getWidth();
  int srcHeight = image.getHeight();
  Image tmp = Image.createImage(_width, srcHeight);
  Graphics g = tmp.getGraphics();
  int ratio = (srcWidth << 16) / _height;
  int pos = ratio/2;


  //Horizontal Resize


  for (int x = 0; x < _width; x++) 
        {
            g.setClip(x, 0, 1, srcHeight);
      g.drawImage(image, x - (pos >> 16), 0, Graphics.LEFT | Graphics.TOP);
            pos += ratio;
        }


   Image resizedImage = Image.createImage(_width, _height);
   g = resizedImage.getGraphics();
   ratio = (srcHeight << 16) / _height;
   pos = ratio/2;


   //Vertical resize


    for (int y = 0; y < _height; y++) 
          {
              g.setClip(0, y, _width, 1);
              g.drawImage(tmp, 0, y - (pos >> 16), Graphics.LEFT | Graphics.TOP);
              pos += ratio;
          }
         return resizedImage;
    }

View Full Code Here

0 1 2

TOP

Related Classes of javax.microedition.lcdui.Graphics

bm.ui.DataList

bm.ui.Menu

bm.ui.ProgressMeterComp

bm.ui.Toolbar

com.ael.Utilities

com.sun.me.gci.surface.GCIDrawingSurface

com.tinygo.GobanCanvas

cz.cacek.ebook.AbstractView

gr.skill.World

GraphicsSample

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.