Colors: the Color class Drawing: the Paint and Canvas classes Drawing the Sudoku puzzle
Download 257.75 Kb.
|
| 2D Graphics
Contents
Android provides two very powerful graphics libraries: one for 2D graphics and one for 3D graphics. The 2D graphics library is available in the android.graphics package. Basic classes in this package include: Color, Paint, and Canvas. 1. Colors The Color class defines methods for creating and converting colors. An Android color is represented as 4 components, one each for alpha, red, green, blue (ARGB). Each component ranges between 0..255 with 0 meaning no contribution for that component, and 255 meaning 100% contribution. Red, green and blue are primary colors which combined in certain proportions can generate any color. Alpha is a measure of transparency. The lowest value, 0, indicates the color is completely transparent. It does not really matter what the values of RGB are, if Alpha is 0. The highest value, 255, indicates the color is completely opaque. Values in the middle are used for translucent/semitransparent colors. They let you see some of what is underneath the object being drawn in the foreground. Note that Android colors are packed into a 32-bit integer (8 bits for each of the 4 components), and for efficiency, Android code uses integers to store colors instead of objects of the color class. E  xamples:
opaque-blue: 255, 0, 0, 255 opaque-yellow: 255, 255, 255, 0 translucent-purple: 127, 255, 0, 255 translucent-cyan: 200, 0, 255, 255 opaque-white: 255, 255, 255, 255 opaque-black: 255, 0, 0, 0 Colors can be created in several ways:
int carColor = Color.RED;
 int carColor = Color.argb(255, 255, 0, 0);
int hiliteColor = Color.argb(255, 253, 179, 7); Remark: In an Android application, it is recommended that you define all colors used in an XML resource file. Having them in one place allows them to be easily changed later, if needed. Use the Colors can be referenced by name in other XML files (e.g., the GUI files). In the Java code they can be accessed using the getResources()method (of the Activity class) as follows: int someColor = getResources().getColor(R.color.carColor); The getResources() method returns the ResourceManager class for the current activity, and getColor() asks the manager to look up a color given its resource ID. 2. Drawing To draw something you need 3 basic components: a Canvas to draw on, a Paint to describe the color and style for drawing, and drawing primitives, such as, rectangles (Rect), text or geometric contours (Path). The Paint class holds the style, color, and other information needed to draw any graphics, including text, geometric shapes and bitmaps. A Paint object with default settings can be created using the default constructor of the Paint class. These settings can be then changed using public methods, such as, setColor(), setStyle() and setTextSize(). Paint myPreference = new Paint(); myPreference.setColor(Color.BLUE); Paint yourPreference = new Paint(); yourPreference.setColor(Color.YELLOW); yourPreference.setTextSize(12.5); The Canvas class represents a surface on which you draw. In Android, the Canvas is hosted by a View (which in turn is hosted by an Activity). Thus, in order to draw on a canvas you need to create a View to host that canvas and then override its onDraw() method. This method takes only one parameter representing the canvas on which you can draw. public class SomeApplication extends Activity { public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(new MyFirstView(this)); } static public class MyFirstView extends View { public MyFirstView(Context context) { super(context); } protected void onDraw(Canvas canvas) { //put here drawing commands to draw whatever you want } } } Remark: Recall that in order to assign a View to an Activity, you need to call the setContentView() method from the onCreate() method of your Activity. Methods in the Canvas class let you draw lines, rectangles, circle, or other arbitrary graphics. For example:
public class SomeApplication extends Activity { public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(new MyFirstView(this)); } static public class MyFirstView extends View { public MyFirstView(Context context) { super(context); } protected void onDraw(Canvas canvas) { Paint myPaintbrush = new Paint(); myPaintbrush.setColor(Color.BLUE); Paint yourPaintbrush = new Paint(); yourPaintbrush.setColor(Color.YELLOW); yourPaintbrush.setTextSize(12.5); canvas.drawLine(10,10,20,40,myPaintbrush); canvas.drawText("Hello!",10,10,yourPaintbrush); } } } 3. Drawing the Sudoko puzzle First let’s define a few colors in an XML resource file, which we will use for drawing. res/value/colors.xml "1.0" encoding="utf-8"?> Then let’s create the view on whose canvas we can draw the Sudoku puzzle. We call this view PuzzleView and override its draw() method to draw a background for the puzzle, the grid lines that make up the 9x9=81 tiles and then the starting numbers of the game (the givens). Inside PuzzleView, we also need to implement the onSizeChanged() method inherited from the View class. This method is called after the view is created and Android knows how big everything is. We use onSizeChanged()to calculate the size of each tile on the screen (1/9th of the total view width and height). We store this size in two fields: width and height, as they will be needed when drawing the grid lines separating the tiles. public class PuzzleView extends View { private float width; // width of one tile private float height; // height of one tile public PuzzleView(Context context) { super(context); }
protected void onSizeChanged(int w, int h, int oldw, int oldh) { width = w / 9f; height = h / 9f; //selected tile will be recomputed here super.onSizeChanged(w, h, oldw, oldh); }
protected void onDraw(Canvas canvas) { // Draw the background // Draw the grid lines // Draw the numbers // Draw the selected tile } } The background is drawn, using the puzzle_background color, as a rectangle covering the entire view. Methods getWidth() and getHeight() inherited from the View class are used to obtain the width and height of the view (in pixels). // Draw the background Paint background = new Paint(); background.setColor(getResources().getColor(R.color.puzzle_background)); canvas.drawRect(0, 0, getWidth(), getHeight(), background); Then we add the grid lines for the board using 3 different colors: a light color (puzzle_light) between each tile, a dark color (puzzle_dark) between the 3x3 blocks, and a highlight color (puzzle_hilite) drawn on the edge of each tile to make them look like they have a little depth. The order in which the lines are drawn it’s important, since lines drawn later will be drawn on top of the earlier lines. The width and height of a tile are used here as calculated by the onSizeChanged()method. // Define colors for the grid lines Paint dark = new Paint(); dark.setColor(getResources().getColor(R.color.puzzle_dark));
hilite.setColor(getResources().getColor(R.color.puzzle_hilite)); Paint light = new Paint(); light.setColor(getResources().getColor(R.color.puzzle_light)); // Draw the minor grid lines for (int i = 0; i < 9; i++) { canvas.drawLine(0, i * height, getWidth(), i * height, light); canvas.drawLine(0, i * height+ 1, getWidth(), i * height+ 1, hilite); canvas.drawLine(i * width, 0, i * width, getHeight(), light); canvas.drawLine(i * width + 1, 0, i * width + 1, getHeight(), hilite); }
for (int i = 0; i < 9; i++) { if (i % 3 != 0) continue; canvas.drawLine(0, i * height, getWidth(), i * height, dark); canvas.drawLine(0, i * height + 1, getWidth(), i * height+ 1, hilite); canvas.drawLine(i * width, 0, i * width, getHeight(), dark); canvas.drawLine(i * width + 1, 0, i * width + 1, getHeight(), hilite); }
Next, we add the puzzle’s starting numbers (the givens) inside the grid lines (using the drawText() method of the Canvas class). The tricky part is getting each number positioned and sized so it goes in the exact center of its tile. To calculate the size of the numbers, we set the text height to ¾ the height of the tile (using the method setTextSize() of the Paint class), and then set the text’s aspect ratio to be the same as the tile’s aspect ratio (using the method setTextScaleX() of the Paint class). We don’t use absolute pixel or point sizes because we want the program to work at any resolution. To determine the position of each number, we center it in both the x and y dimensions. The x direction is easy – just divide the tile width by 2 and set the text alignment to "CENTER" (using the method setTextAlign() of the Paint class). But for the y direction, we have to adjust the starting position down a little so that the midpoint of the tile will be the midpoint of the number instead of its baseline. We use the graphics library’s FontMetrics class (specifically, the getFontMetrics() method of the Paint class) to tell how much vertical space the letter will take in total. Then we divide that in half to get the adjustment. The ascent and descent fields of the FontMetrics class store information about the vertical space the text occupies above and below the baseline. The next step is to allow the player to enter their guesses for all the blank spaces, but first let’s see where do we get the numbers to write in each tile. // Define color and style for numbers Paint foreground = new Paint(Paint.ANTI_ALIAS_FLAG); foreground.setColor(getResources().getColor(R.color.puzzle_foreground)); foreground.setStyle(Style.FILL); foreground.setTextSize(height * 0.75f); foreground.setTextScaleX(width/height); foreground.setTextAlign(Paint.Align.CENTER);
// Centering in X: use alignment (and X at midpoint) float x = width / 2; // Centering in Y: measure ascent/descent first FontMetrics fm = foreground.getFontMetrics();
canvas.drawText(/*numbers to write in each tile*/, i * width + x, j * height + y, foreground); } } 
The PuzzleView class defines the Sudoku puzzle. Now, to allow the user to view the puzzle and play the game we need to create an activity that will host the puzzle view. Let’s name that activity Game. Note: Do not forget to add this activity to your AndroidManifest.xml file. public class Game extends Activity { private final String easyPuzzle = "360000000004230800000004200" + "070460003820000014500013020" + "001900000007048300000000045"; private final String mediumPuzzle = "650000070000506000014000005" + "007009000002314700000700800" + "500000630000201000030000097"; private final String hardPuzzle = "009000000080605020501078000" + "000000700706040102004000000" + "000720903090301080000000600"; private int puzzle[] = new int[9 * 9]; private PuzzleView puzzleView; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); int diff = getIntent().getIntExtra(KEY_DIFFICULTY, 2); puzzle = getPuzzle(diff); puzzleView = new PuzzleView(this); setContentView(puzzleView); puzzleView.requestFocus(); } /** Given a difficulty level, select a puzzle */ private int[] getPuzzle(int diff) { String puz; switch (diff) { case 0: puz = hardPuzzle; break; case 1: puz = mediumPuzzle; break; case 2: default: puz = easyPuzzle; break; }
} /** Convert a puzzle string into an array */ static protected int[] fromPuzzleString(String puzzleString) { int[] puz = new int[puzzleString.length()]; for (int i = 0; i < puz.length; i++) { puz[i] = puzzleString.charAt(i) - '0'; }
}
private void setTile(int x, int y, int value) { puzzle[y * 9 + x] = value; } /** Return a string for the tile at the given coordinates */ protected String getTileString(int x, int y) { int v = puzzle[y * 9 + x]; if (v == 0) return ""; else return String.valueOf(v); } } The static fields easyPuzzle, mediumPuzzle and hardPuzzle, in our Game class, store our hard-coded Sudoku puzzles for easy, medium and hard difficulty levels respectively. The field puzzle is a 9x9 array of integers that will store the numbers in the 9x9 Sudoku puzzle. Originally, this array is populated with the given numbers by the method getPuzzle(). This method simply takes a difficulty level, selects the corresponding puzzle string (easyPuzzle, mediumPuzzle or hardPuzzle) and converts it into a 9x9 array of integers by using the helper method fromPuzzleString(). This action is performed in the onCreate() method of the Game activity, after the value of the difficulty level is fetched from the intent invoking this activity. Method setTile() will be used later to keep the puzzle field up-to-date with the numbers entered by the player. Method getTileString() is the opposite of setTile() and will also be used later. It returns a string representation of the number at specified coordinates in the puzzle array. Note that a value of 0 in the puzzle array, represents an empty tile, thus method getTileString() will return an empty string for such value. Once we know the puzzle’s numbers we can create an instance of the PuzzleView class and assign it to the Game activity (using the setContentView() method). But, class PuzzleView needs access to the array puzzle in order to know what to draw in each tile. To allow access to the members of the Game class we add a reference to this class as one of the fields of the PuzzleView class. Then, when drawing the numbers in each tile, we can use the getTileString()method from the Game class. public class PuzzleView extends View { private float width; // width of one tile private float height; // height of one tile private final Game game; public PuzzleView(Context context) { super(context); game = (Game) context; }
... @Override protected void onDraw(Canvas canvas) { ...
// Centering the numbers in X: use alignment (and X at midpoint) float x = width / 2; // Centering the numbers in Y: measure ascent/descent first FontMetrics fm = foreground.getFontMetrics();
canvas.drawText(game.getTileString(i, j), i * width + x, j * height + y, foreground); } } } 4. Handling User Input into the Puzzle Now that the Sudoku puzzle and the given numbers are finally drawn, let’s see how do we allow the player to enter their guesses for all the empty tiles. Remember that Android phones come in many shapes and sizes and have a variety of input methods. They might have a keyboard, a D-pad, a touch screen, a trackball, or some combination of these. A good Android program, therefore, needs to be ready to support whatever input hardware is available, just like it needs to be ready to support any screen resolution. For a touch capable device, once the user touches the screen, the device will enter touch mode. Any time a user hits a directional key, such as a D-pad direction, the view device will exit touch mode. To allow user input in the puzzle view we must set the view as focusable both when in touch mode and when not in touch mode. This is done in the PuzzleView constructor. public class PuzzleView extends View { ...
super(context); game = (Game) context; setFocusable(true); setFocusableInTouchMode(true); }
... }
First, we’re going to implement a little cursor that shows the player which tile is currently selected. The selected tile is the one that will be modified when the player enters a number. As the selected tile needs to change throughout the game, we need to add two new fields to the PuzzleView class, selX and selY, that will hold the coordinates (1..9) of the selected tile. The selected tile will be drawn in the onDraw() method of the PuzzleView class, as a rectangle having the color puzzle_selected. The coordinates of this rectangle are computed by the helper method getRect() based on the values of selX, selY, width and height. Thus, this rectangle is first computed in the onSizeChanged() method of the PuzzleView class (after the width and the height of each tile are calculated) and will be updated according to user input. Although the coordinates of the selection can be computed whenever needed, the data field selRect of type Rect is used to store them to reduce computation. public class PuzzleView extends View { private float width; // width of one tile private float height; // height of one tile private int selX; // X index of selection private int selY; // Y index of selection private final Rect selRect = new Rect(); ... @Override protected void onSizeChanged(int w, int h, int oldw, int oldh) { width = w / 9f; height = h / 9f;
ocusable(true) in the PuzzleView constructor. the ly those areas that change.w() again for you. The dirty rectangles become super.onSizeChanged(w, h, oldw, oldh); } @Override protected void onDraw(Canvas canvas) { // Draw the background ... // Draw the grid lines ... // Draw the numbers ... // Draw the selected tile Paint selected = new Paint(); selected.setColor(getResources().getColor(R.color.puzzle_selected)); canvas.drawRect(selRect, selected); } private void getRect(int x, int y, Rect rect) { rect.set((int) (x * width), (int) (y * height), (int) (x * width + width), (int) (y * height + height)); } } Next we provide a way to move the selection by overriding the onKeyDown() method (in the PuzzleView class). If the user has a directional pad (D-pad) and presses the up, down, left or right button, we call helper method select() to modify selX and selY according the selected direction. Inside the select() method, we calculate the new x and y coordinate of the selection and then call getRect() again to calculate the new selection rectangle. Notice the two calls to invalidate(). The first one tells Android that the area covered by the old selection rectangle needs to be redrawn (to basically erase the selection). The second one says that the new selection area needs to be redrawn too. Note that we don’t actually draw anything in method select(). This is an important point: never call any drawing functions except in the onDraw() method. Instead, you use the invalidate() method to mark rectangles as dirty. The window manager will combine all the dirty rectangles at some point in the future and call onDraw() again for you. Thus, screen updates are optimized to only those areas that change. public class PuzzleView extends View { private float width; // width of one tile private float height; // height of one tile private int selX; // X index of selection private int selY; // Y index of selection private final Rect selRect = new Rect(); ...
@Override public boolean onKeyDown(int keyCode, KeyEvent event) { switch (keyCode) { case KeyEvent.KEYCODE_DPAD_UP: select(selX, selY - 1); break; case KeyEvent.KEYCODE_DPAD_DOWN: select(selX, selY + 1); break; case KeyEvent.KEYCODE_DPAD_LEFT: select(selX - 1, selY); break; case KeyEvent.KEYCODE_DPAD_RIGHT: select(selX + 1, selY); break; the color classanvas classesg invalid iialogbe computed whenever needed, the default: return super.onKeyDown(keyCode, event); } return true; } private void select(int x, int y) { invalidate(selRect); selX = Math.min(Math.max(x, 0), 8); selY = Math.min(Math.max(y, 0), 8); getRect(selX, selY, selRect); invalidate(selRect); } }
4.2.1. To handle keyboard input, we just add a few more cases on the onKeyDown() method, for the numbers 0 through 9 (0 or space means erase the number from the selected tile). public class PuzzleView extends View { ...
@Override public boolean onKeyDown(int keyCode, KeyEvent event) { switch (keyCode) { case KeyEvent.KEYCODE_DPAD_UP: … case KeyEvent.KEYCODE_DPAD_DOWN: … case KeyEvent.KEYCODE_DPAD_LEFT: … case KeyEvent.KEYCODE_DPAD_RIGHT: … case KeyEvent.KEYCODE_0: case KeyEvent.KEYCODE_SPACE: setSelectedTile(0); break; case KeyEvent.KEYCODE_1: setSelectedTile(1); break; case KeyEvent.KEYCODE_2: setSelectedTile(2); break; case KeyEvent.KEYCODE_3: setSelectedTile(3); break; case KeyEvent.KEYCODE_4: setSelectedTile(4); break; case KeyEvent.KEYCODE_5: setSelectedTile(5); break; case KeyEvent.KEYCODE_6: setSelectedTile(6); break; case KeyEvent.KEYCODE_7: setSelectedTile(7); break; case KeyEvent.KEYCODE_8: setSelectedTile(8); break; case KeyEvent.KEYCODE_9: setSelectedTile(9); break; default: return super.onKeyDown(keyCode, event); }
}
}
4.2.2. To support the D-pad, we check for Enter or center D-pad button in onKeyDown() and have it pop up a keypad that lets the user select which number to place. The keypad is handy for phones that don’t have keyboards. public class PuzzleView extends View { private int selX; // X index of selection private int selY; // Y index of selection private final Game game; ...
@Override public boolean onKeyDown(int keyCode, KeyEvent event) { switch (keyCode) { case KeyEvent.KEYCODE_DPAD_UP: … case KeyEvent.KEYCODE_DPAD_DOWN:… case KeyEvent.KEYCODE_DPAD_LEFT:… case KeyEvent.KEYCODE_DPAD_RIGHT:… case KeyEvent.KEYCODE_0: case KeyEvent.KEYCODE_SPACE: setSelectedTile(0); break; case KeyEvent.KEYCODE_1: setSelectedTile(1); break; case KeyEvent.KEYCODE_2: setSelectedTile(2); break; case KeyEvent.KEYCODE_3: setSelectedTile(3); break; case KeyEvent.KEYCODE_4: setSelectedTile(4); break; case KeyEvent.KEYCODE_5: setSelectedTile(5); break; case KeyEvent.KEYCODE_6: setSelectedTile(6); break; case KeyEvent.KEYCODE_7: setSelectedTile(7); break; case KeyEvent.KEYCODE_8: setSelectedTile(8); break; case KeyEvent.KEYCODE_9: setSelectedTile(9); break; case KeyEvent.KEYCODE_ENTER: case KeyEvent.KEYCODE_DPAD_CENTER: game.showKeypad(selX, selY); break; default: return super.onKeyDown(keyCode, event); }
} }
public class PuzzleView extends View { private float width; // width of one tile private float height; // height of one tile private int selX; // X index of selection private int selY; // Y index of selection ...
@Override public boolean onTouchEvent(MotionEvent event) { if (event.getAction() != MotionEvent.ACTION_DOWN) return super.onTouchEvent(event); select((int) (event.getX() / width), (int) (event.getY() / height)); game.showKeypad(selX, selY); return true; } }
public class Game extends Activity { …
Dialog v = new Keypad(this, puzzleView); v.show(); } }
res/layout/keypad.xml xmlns:android="http://schemas.android.com/apk/res/android" android:id="@+id/keypad" android:orientation="vertical" android:layout_width="wrap_content" android:layout_height="wrap_content" android:stretchColumns="*">
et to modify the showKeypad method to pass the used umbers as the third argument when creating the kepad dialog.o the Keypandroid:text="9"> public class Keypad extends Dialog { private final View keys[] = new View[9]; private View keypad; private final PuzzleView puzzleView; public Keypad(Context context, PuzzleView puzzleView) { super(context); this.puzzleView = puzzleView; }
protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setTitle(R.string.keypad_title); setContentView(R.layout.keypad); findViews(); setListeners(); }
keypad = findViewById(R.id.keypad); keys[0] = findViewById(R.id.keypad_1); keys[1] = findViewById(R.id.keypad_2); keys[2] = findViewById(R.id.keypad_3); keys[3] = findViewById(R.id.keypad_4); keys[4] = findViewById(R.id.keypad_5); keys[5] = findViewById(R.id.keypad_6); keys[6] = findViewById(R.id.keypad_7); keys[7] = findViewById(R.id.keypad_8); keys[8] = findViewById(R.id.keypad_9); }
keys[i].setOnClickListener(new View.OnClickListener(){ public void onClick(View v) { puzzleView.setSelectedTile(t); dismiss(); }});
} keypad.setOnClickListener(new View.OnClickListener(){ public void onClick(View v) { puzzleView.setSelectedTile(0); dismiss(); }});
} }
Then method setListeners() loops through all the keypad keys and sets a listener for each one. Thus, when the player selects/clicks one of them, the number on that key is returned to the calling activity and written in the selected tile using method setSelectedTile() (from the PuzzleView class). The dismiss call terminates the Keypad dialog box. To allow a player to erase a tile, we also set a listener for the main keypad window. Thus, when the player clicks on it (but not on a key), then method setSelectedTile() is called with argument zero, indicating the tile should be erased. 5. Game Extensions 5.1. Check for invalid user input and reject it Now, let’s help the player by allowing him/her to select a number for a certain tile only if it does not violate the game conditions (i.e., a number should not appear more than once in a row, column, or 3x3 group). In order to do that, we can either:
Let’s choose option (2) and add the field used in the Game class to keep track of used (invalid) numbers for each tile. public class Game extends Activity { ...
private final int used[][][] = new int[9][9][]; private PuzzleView puzzleView; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); int diff = getIntent().getIntExtra(KEY_DIFFICULTY, 2); puzzle = getPuzzle(diff); calculateUsedTiles(); puzzleView = new PuzzleView(this); setContentView(puzzleView); puzzleView.requestFocus(); }
for (int x = 0; x < 9; x++) { for (int y = 0; y < 9; y++) { used[x][y] = calculateUsedTiles(x, y); } } } protected int[] getUsedTiles(int x, int y) { return used[x][y]; } }
The algorithm for calculating the used numbers for a given tile (x,y) is provided below: private int[] calculateUsedTiles(int x, int y) { int c[] = new int[9]; // horizontal for (int i = 0; i < 9; i++) { if (i == y) continue; int t = puzzle[i * 9 + x]; if (t != 0) c[t - 1] = t; } // vertical for (int i = 0; i < 9; i++) { if (i == x) continue; int t = puzzle[y * 9 + i]; if (t != 0) c[t - 1] = t; } // same cell block int startx = (x / 3) * 3; int starty = (y / 3) * 3; for (int i = startx; i < startx + 3; i++) { for (int j = starty; j < starty + 3; j++) { if (i == x && j == y) continue; int t = puzzle[j * 9 + i]; if (t != 0) c[t - 1] = t; } }
int nused = 0; for (int t : c) { if (t != 0) nused++;
} int c1[] = new int[nused]; nused = 0; for (int t : c) { if (t != 0) c1[nused++] = t; }
}
public void setSelectedTile(int tile) { game.setTileIfValid(selX, selY, tile)); invalidate(selRect); }
public class Game extends Activity { …
int tiles[] = getUsedTiles(x, y); if (value != 0) { for (int tile : tiles) { if (tile == value) return false; } } setTile(x, y, value); calculateUsedTiles(); return true; } } Note that the field used must be updated every time the value of a tile changes. Therefore, we need to call the calculateUsedTiles() method after the setTile() method. 5.2. Shake the screen for invalid user input Let’s also notify the user that a number is invalid by making the screen wiggle back and forth when they enter one. To do that we rewrite the method setSelectedTile() as follows: public void setSelectedTile(int tile) { if (game.setTileIfValid(selX, selY, tile)) { invalidate(selRect); } else { // Number is not valid for this tile startAnimation(AnimationUtils.loadAnimation(game,R.anim.shake)); } } Method startAnimation() will load and run a resource called R.anim.shake, defined in res/anim/shake.xml, that shakes the screen for 1 second by 10 pixels from side to side. res/anim/shake.xml ?xml version="1.0" encoding="utf-8"?> android:fromXDelta="0" android:toXDelta="10" android:duration="1000" android:interpolator="@anim/cycle_7" /> The number of times to run the animation and the velocity and acceleration of the animation are controlled by an animation interpolator defined in XML. res/anim/cycle_7.xml "1.0" encoding="utf-8"?> android:cycles="7" />
}
protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setTitle(R.string.keypad_title); setContentView(R.layout.keypad); findViews();
setListeners(); } …
Don’t forget to modify the showKeypad() method to pass the used umbers as the third argument when creating the keypad dialog. public class Game extends Activity { …
Dialog v = new Keypad(this, puzzleView, getUsedTiles(x, y)); v.show(); } } Directory: wp-content -> uploads -> 2010 2010 -> Hr 116 Application for Employment with Hills and Dales 2010 -> Polimaster ltd V. Rae systems inc polimaster ltd.; Na&se trading co., Limited, Plaintiffs-Appellants 2010 -> The game a morality play in one act by Louise Bryant 2010 -> Seamheads at sabr 40 2010 -> Curriculum vitae 2010 -> Mid atlantic coaching clinic 2010 -> The Case for Integrating Crisis Response with Social Media Chapter One: Introduction 2010 -> Press pack shamrock Bowl XXIV american football – Tallaght Stadium 2010 -> Andy Northedge1 2010 -> Partnership Brokers Training Download 257.75 Kb. Share with your friends:
|
