gametel 0.1

data/ApiDemos/src/com/example/android/apis/graphics/Arcs.java

@@ -0,0 +1,118 @@
+/*
+ * Copyright (C) 2007 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.example.android.apis.graphics;
+
+// Need the following import to get access to the app resources, since this
+// class is in a sub-package.
+//import com.example.android.apis.R;
+
+import android.content.Context;
+import android.graphics.*;
+import android.os.Bundle;
+import android.view.View;
+
+public class Arcs extends GraphicsActivity {
+
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        setContentView(new SampleView(this));
+    }
+
+    private static class SampleView extends View {
+        private Paint[] mPaints;
+        private Paint mFramePaint;
+        private boolean[] mUseCenters;
+        private RectF[] mOvals;
+        private RectF mBigOval;
+        private float mStart;
+        private float mSweep;
+        private int mBigIndex;
+
+        private static final float SWEEP_INC = 2;
+        private static final float START_INC = 15;
+
+        public SampleView(Context context) {
+            super(context);
+
+            mPaints = new Paint[4];
+            mUseCenters = new boolean[4];
+            mOvals = new RectF[4];
+
+            mPaints[0] = new Paint();
+            mPaints[0].setAntiAlias(true);
+            mPaints[0].setStyle(Paint.Style.FILL);
+            mPaints[0].setColor(0x88FF0000);
+            mUseCenters[0] = false;
+
+            mPaints[1] = new Paint(mPaints[0]);
+            mPaints[1].setColor(0x8800FF00);
+            mUseCenters[1] = true;
+
+            mPaints[2] = new Paint(mPaints[0]);
+            mPaints[2].setStyle(Paint.Style.STROKE);
+            mPaints[2].setStrokeWidth(4);
+            mPaints[2].setColor(0x880000FF);
+            mUseCenters[2] = false;
+
+            mPaints[3] = new Paint(mPaints[2]);
+            mPaints[3].setColor(0x88888888);
+            mUseCenters[3] = true;
+
+            mBigOval = new RectF(40, 10, 280, 250);
+
+            mOvals[0] = new RectF( 10, 270,  70, 330);
+            mOvals[1] = new RectF( 90, 270, 150, 330);
+            mOvals[2] = new RectF(170, 270, 230, 330);
+            mOvals[3] = new RectF(250, 270, 310, 330);
+
+            mFramePaint = new Paint();
+            mFramePaint.setAntiAlias(true);
+            mFramePaint.setStyle(Paint.Style.STROKE);
+            mFramePaint.setStrokeWidth(0);
+        }
+
+        private void drawArcs(Canvas canvas, RectF oval, boolean useCenter,
+                              Paint paint) {
+            canvas.drawRect(oval, mFramePaint);
+            canvas.drawArc(oval, mStart, mSweep, useCenter, paint);
+        }
+
+        @Override protected void onDraw(Canvas canvas) {
+            canvas.drawColor(Color.WHITE);
+
+            drawArcs(canvas, mBigOval, mUseCenters[mBigIndex],
+                     mPaints[mBigIndex]);
+
+            for (int i = 0; i < 4; i++) {
+                drawArcs(canvas, mOvals[i], mUseCenters[i], mPaints[i]);
+            }
+
+            mSweep += SWEEP_INC;
+            if (mSweep > 360) {
+                mSweep -= 360;
+                mStart += START_INC;
+                if (mStart >= 360) {
+                    mStart -= 360;
+                }
+                mBigIndex = (mBigIndex + 1) % mOvals.length;
+            }
+            invalidate();
+        }
+    }
+}
+

data/ApiDemos/src/com/example/android/apis/graphics/BitmapDecode.java

@@ -0,0 +1,144 @@
+/*
+ * Copyright (C) 2007 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.example.android.apis.graphics;
+
+import com.example.android.apis.R;
+
+import android.content.Context;
+import android.graphics.*;
+import android.graphics.drawable.*;
+import android.os.Bundle;
+import android.view.*;
+
+import java.io.InputStream;
+import java.io.ByteArrayOutputStream;
+
+public class BitmapDecode extends GraphicsActivity {
+
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        setContentView(new SampleView(this));
+    }
+
+    private static class SampleView extends View {
+        private Bitmap mBitmap;
+        private Bitmap mBitmap2;
+        private Bitmap mBitmap3;
+        private Bitmap mBitmap4;
+        private Drawable mDrawable;
+
+        private Movie mMovie;
+        private long mMovieStart;
+
+        //Set to false to use decodeByteArray
+        private static final boolean DECODE_STREAM = true;
+
+        private static byte[] streamToBytes(InputStream is) {
+            ByteArrayOutputStream os = new ByteArrayOutputStream(1024);
+            byte[] buffer = new byte[1024];
+            int len;
+            try {
+                while ((len = is.read(buffer)) >= 0) {
+                    os.write(buffer, 0, len);
+                }
+            } catch (java.io.IOException e) {
+            }
+            return os.toByteArray();
+        }
+
+        public SampleView(Context context) {
+            super(context);
+            setFocusable(true);
+
+            java.io.InputStream is;
+            is = context.getResources().openRawResource(R.drawable.beach);
+
+            BitmapFactory.Options opts = new BitmapFactory.Options();
+            Bitmap bm;
+
+            opts.inJustDecodeBounds = true;
+            bm = BitmapFactory.decodeStream(is, null, opts);
+
+            // now opts.outWidth and opts.outHeight are the dimension of the
+            // bitmap, even though bm is null
+
+            opts.inJustDecodeBounds = false;    // this will request the bm
+            opts.inSampleSize = 4;             // scaled down by 4
+            bm = BitmapFactory.decodeStream(is, null, opts);
+
+            mBitmap = bm;
+
+            // decode an image with transparency
+            is = context.getResources().openRawResource(R.drawable.frog);
+            mBitmap2 = BitmapFactory.decodeStream(is);
+
+            // create a deep copy of it using getPixels() into different configs
+            int w = mBitmap2.getWidth();
+            int h = mBitmap2.getHeight();
+            int[] pixels = new int[w*h];
+            mBitmap2.getPixels(pixels, 0, w, 0, 0, w, h);
+            mBitmap3 = Bitmap.createBitmap(pixels, 0, w, w, h,
+                                           Bitmap.Config.ARGB_8888);
+            mBitmap4 = Bitmap.createBitmap(pixels, 0, w, w, h,
+                                           Bitmap.Config.ARGB_4444);
+
+            mDrawable = context.getResources().getDrawable(R.drawable.button);
+            mDrawable.setBounds(150, 20, 300, 100);
+
+            is = context.getResources().openRawResource(R.drawable.animated_gif);
+
+            if (DECODE_STREAM) {
+                mMovie = Movie.decodeStream(is);
+            } else {
+                byte[] array = streamToBytes(is);
+                mMovie = Movie.decodeByteArray(array, 0, array.length);
+            }
+        }
+
+        @Override
+        protected void onDraw(Canvas canvas) {
+            canvas.drawColor(0xFFCCCCCC);
+
+            Paint p = new Paint();
+            p.setAntiAlias(true);
+
+            canvas.drawBitmap(mBitmap, 10, 10, null);
+            canvas.drawBitmap(mBitmap2, 10, 170, null);
+            canvas.drawBitmap(mBitmap3, 110, 170, null);
+            canvas.drawBitmap(mBitmap4, 210, 170, null);
+
+            mDrawable.draw(canvas);
+
+            long now = android.os.SystemClock.uptimeMillis();
+            if (mMovieStart == 0) {   // first time
+                mMovieStart = now;
+            }
+            if (mMovie != null) {
+                int dur = mMovie.duration();
+                if (dur == 0) {
+                    dur = 1000;
+                }
+                int relTime = (int)((now - mMovieStart) % dur);
+                mMovie.setTime(relTime);
+                mMovie.draw(canvas, getWidth() - mMovie.width(),
+                            getHeight() - mMovie.height());
+                invalidate();
+            }
+        }
+    }
+}

data/ApiDemos/src/com/example/android/apis/graphics/BitmapMesh.java

@@ -0,0 +1,130 @@
+/*
+ * Copyright (C) 2008 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.example.android.apis.graphics;
+
+import com.example.android.apis.R;
+
+import android.content.Context;
+import android.graphics.*;
+import android.os.Bundle;
+import android.view.*;
+import android.util.FloatMath;
+
+public class BitmapMesh extends GraphicsActivity {
+
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        setContentView(new SampleView(this));
+    }
+
+    private static class SampleView extends View {
+        private static final int WIDTH = 20;
+        private static final int HEIGHT = 20;
+        private static final int COUNT = (WIDTH + 1) * (HEIGHT + 1);
+
+        private final Bitmap mBitmap;
+        private final float[] mVerts = new float[COUNT*2];
+        private final float[] mOrig = new float[COUNT*2];
+
+        private final Matrix mMatrix = new Matrix();
+        private final Matrix mInverse = new Matrix();
+
+        private static void setXY(float[] array, int index, float x, float y) {
+            array[index*2 + 0] = x;
+            array[index*2 + 1] = y;
+        }
+
+        public SampleView(Context context) {
+            super(context);
+            setFocusable(true);
+
+            mBitmap = BitmapFactory.decodeResource(getResources(),
+                                                     R.drawable.beach);
+
+            float w = mBitmap.getWidth();
+            float h = mBitmap.getHeight();
+            // construct our mesh
+            int index = 0;
+            for (int y = 0; y <= HEIGHT; y++) {
+                float fy = h * y / HEIGHT;
+                for (int x = 0; x <= WIDTH; x++) {
+                    float fx = w * x / WIDTH;
+                    setXY(mVerts, index, fx, fy);
+                    setXY(mOrig, index, fx, fy);
+                    index += 1;
+                }
+            }
+
+            mMatrix.setTranslate(10, 10);
+            mMatrix.invert(mInverse);
+        }
+
+        @Override protected void onDraw(Canvas canvas) {
+            canvas.drawColor(0xFFCCCCCC);
+
+            canvas.concat(mMatrix);
+            canvas.drawBitmapMesh(mBitmap, WIDTH, HEIGHT, mVerts, 0,
+                                  null, 0, null);
+        }
+
+        private void warp(float cx, float cy) {
+            final float K = 10000;
+            float[] src = mOrig;
+            float[] dst = mVerts;
+            for (int i = 0; i < COUNT*2; i += 2) {
+                float x = src[i+0];
+                float y = src[i+1];
+                float dx = cx - x;
+                float dy = cy - y;
+                float dd = dx*dx + dy*dy;
+                float d = FloatMath.sqrt(dd);
+                float pull = K / (dd + 0.000001f);
+
+                pull /= (d + 0.000001f);
+             //   android.util.Log.d("skia", "index " + i + " dist=" + d + " pull=" + pull);
+
+                if (pull >= 1) {
+                    dst[i+0] = cx;
+                    dst[i+1] = cy;
+                } else {
+                    dst[i+0] = x + dx * pull;
+                    dst[i+1] = y + dy * pull;
+                }
+            }
+        }
+
+        private int mLastWarpX = -9999; // don't match a touch coordinate
+        private int mLastWarpY;
+
+        @Override public boolean onTouchEvent(MotionEvent event) {
+            float[] pt = { event.getX(), event.getY() };
+            mInverse.mapPoints(pt);
+
+            int x = (int)pt[0];
+            int y = (int)pt[1];
+            if (mLastWarpX != x || mLastWarpY != y) {
+                mLastWarpX = x;
+                mLastWarpY = y;
+                warp(pt[0], pt[1]);
+                invalidate();
+            }
+            return true;
+        }
+    }
+}
+

data/ApiDemos/src/com/example/android/apis/graphics/BitmapPixels.java

@@ -0,0 +1,161 @@
+/*
+ * Copyright (C) 2007 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.example.android.apis.graphics;
+
+import android.content.Context;
+import android.graphics.*;
+import android.os.Bundle;
+import android.view.*;
+
+import java.nio.IntBuffer;
+import java.nio.ShortBuffer;
+
+public class BitmapPixels extends GraphicsActivity {
+
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        setContentView(new SampleView(this));
+    }
+
+    private static class SampleView extends View {
+        private Bitmap mBitmap1;
+        private Bitmap mBitmap2;
+        private Bitmap mBitmap3;
+
+        // access the red component from a premultiplied color
+        private static int getR32(int c) { return (c >>  0) & 0xFF; }
+        // access the red component from a premultiplied color
+        private static int getG32(int c) { return (c >>  8) & 0xFF; }
+        // access the red component from a premultiplied color
+        private static int getB32(int c) { return (c >> 16) & 0xFF; }
+        // access the red component from a premultiplied color
+        private static int getA32(int c) { return (c >> 24) & 0xFF; }
+
+        /**
+         * This takes components that are already in premultiplied form, and
+         * packs them into an int in the correct device order.
+         */
+        private static int pack8888(int r, int g, int b, int a) {
+            return (r << 0) | ( g << 8) | (b << 16) | (a << 24);
+        }
+
+        private static short pack565(int r, int g, int b) {
+            return (short)((r << 11) | ( g << 5) | (b << 0));
+        }
+
+        private static short pack4444(int r, int g, int b, int a) {
+            return (short)((a << 0) | ( b << 4) | (g << 8) | (r << 12));
+        }
+
+        private static int mul255(int c, int a) {
+            int prod = c * a + 128;
+            return (prod + (prod >> 8)) >> 8;
+        }
+
+        /**
+         * Turn a color int into a premultiplied device color
+         */
+        private static int premultiplyColor(int c) {
+            int r = Color.red(c);
+            int g = Color.green(c);
+            int b = Color.blue(c);
+            int a = Color.alpha(c);
+            // now apply the alpha to r, g, b
+            r = mul255(r, a);
+            g = mul255(g, a);
+            b = mul255(b, a);
+            // now pack it in the correct order
+            return pack8888(r, g, b, a);
+        }
+
+        private static void makeRamp(int from, int to, int n,
+                                     int[] ramp8888, short[] ramp565,
+                                     short[] ramp4444) {
+            int r = getR32(from) << 23;
+            int g = getG32(from) << 23;
+            int b = getB32(from) << 23;
+            int a = getA32(from) << 23;
+            // now compute our step amounts per componenet (biased by 23 bits)
+            int dr = ((getR32(to) << 23) - r) / (n - 1);
+            int dg = ((getG32(to) << 23) - g) / (n - 1);
+            int db = ((getB32(to) << 23) - b) / (n - 1);
+            int da = ((getA32(to) << 23) - a) / (n - 1);
+
+            for (int i = 0; i < n; i++) {
+                ramp8888[i] = pack8888(r >> 23, g >> 23, b >> 23, a >> 23);
+                ramp565[i] = pack565(r >> (23+3), g >> (23+2), b >> (23+3));
+                ramp4444[i] = pack4444(r >> (23+4), g >> (23+4), b >> (23+4),
+                                       a >> (23+4));
+                r += dr;
+                g += dg;
+                b += db;
+                a += da;
+            }
+        }
+
+        private static IntBuffer makeBuffer(int[] src, int n) {
+            IntBuffer dst = IntBuffer.allocate(n*n);
+            for (int i = 0; i < n; i++) {
+                dst.put(src);
+            }
+            dst.rewind();
+            return dst;
+        }
+
+        private static ShortBuffer makeBuffer(short[] src, int n) {
+            ShortBuffer dst = ShortBuffer.allocate(n*n);
+            for (int i = 0; i < n; i++) {
+                dst.put(src);
+            }
+            dst.rewind();
+            return dst;
+        }
+
+        public SampleView(Context context) {
+            super(context);
+            setFocusable(true);
+
+            final int N = 100;
+            int[] data8888 = new int[N];
+            short[] data565 = new short[N];
+            short[] data4444 = new short[N];
+
+            makeRamp(premultiplyColor(Color.RED), premultiplyColor(Color.GREEN),
+                     N, data8888, data565, data4444);
+
+            mBitmap1 = Bitmap.createBitmap(N, N, Bitmap.Config.ARGB_8888);
+            mBitmap2 = Bitmap.createBitmap(N, N, Bitmap.Config.RGB_565);
+            mBitmap3 = Bitmap.createBitmap(N, N, Bitmap.Config.ARGB_4444);
+
+            mBitmap1.copyPixelsFromBuffer(makeBuffer(data8888, N));
+            mBitmap2.copyPixelsFromBuffer(makeBuffer(data565, N));
+            mBitmap3.copyPixelsFromBuffer(makeBuffer(data4444, N));
+        }
+
+        @Override protected void onDraw(Canvas canvas) {
+            canvas.drawColor(0xFFCCCCCC);
+
+            int y = 10;
+            canvas.drawBitmap(mBitmap1, 10, y, null);
+            y += mBitmap1.getHeight() + 10;
+            canvas.drawBitmap(mBitmap2, 10, y, null);
+            y += mBitmap2.getHeight() + 10;
+            canvas.drawBitmap(mBitmap3, 10, y, null);
+        }
+    }
+}