Home | History | Annotate | Download | only in hwui
      1 /*
      2  * Copyright (C) 2010 The Android Open Source Project
      3  *
      4  * Licensed under the Apache License, Version 2.0 (the "License");
      5  * you may not use this file except in compliance with the License.
      6  * You may obtain a copy of the License at
      7  *
      8  *      http://www.apache.org/licenses/LICENSE-2.0
      9  *
     10  * Unless required by applicable law or agreed to in writing, software
     11  * distributed under the License is distributed on an "AS IS" BASIS,
     12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     13  * See the License for the specific language governing permissions and
     14  * limitations under the License.
     15  */
     16 
     17 package com.android.test.hwui;
     18 
     19 import android.app.Activity;
     20 import android.content.Context;
     21 import android.graphics.Bitmap;
     22 import android.graphics.BitmapFactory;
     23 import android.graphics.BitmapShader;
     24 import android.graphics.Canvas;
     25 import android.graphics.LinearGradient;
     26 import android.graphics.RadialGradient;
     27 import android.graphics.Matrix;
     28 import android.graphics.Paint;
     29 import android.graphics.Shader;
     30 import android.graphics.SweepGradient;
     31 import android.os.Bundle;
     32 import android.view.Gravity;
     33 import android.view.View;
     34 import android.widget.FrameLayout;
     35 import android.widget.SeekBar;
     36 
     37 @SuppressWarnings({"UnusedDeclaration"})
     38 public class GradientsActivity extends Activity {
     39     @Override
     40     protected void onCreate(Bundle savedInstanceState) {
     41         super.onCreate(savedInstanceState);
     42 
     43         final FrameLayout layout = new FrameLayout(this);
     44 
     45         final ShadersView shadersView = new ShadersView(this);
     46         final GradientView gradientView = new GradientView(this);
     47         final RadialGradientView radialGradientView = new RadialGradientView(this);
     48         final SweepGradientView sweepGradientView = new SweepGradientView(this);
     49         final BitmapView bitmapView = new BitmapView(this);
     50 
     51         final SeekBar rotateView = new SeekBar(this);
     52         rotateView.setMax(360);
     53         rotateView.setOnSeekBarChangeListener(new SeekBar.OnSeekBarChangeListener() {
     54             public void onStopTrackingTouch(SeekBar seekBar) {
     55             }
     56 
     57             public void onStartTrackingTouch(SeekBar seekBar) {
     58             }
     59 
     60             public void onProgressChanged(SeekBar seekBar, int progress, boolean fromUser) {
     61                 gradientView.setRotationY((float) progress);
     62                 radialGradientView.setRotationX((float) progress);
     63                 sweepGradientView.setRotationY((float) progress);
     64                 bitmapView.setRotationX((float) progress);
     65             }
     66         });
     67 
     68         layout.addView(shadersView);
     69         layout.addView(gradientView, new FrameLayout.LayoutParams(
     70                 200, 200, Gravity.CENTER));
     71 
     72         FrameLayout.LayoutParams lp = new FrameLayout.LayoutParams(200, 200, Gravity.CENTER);
     73         lp.setMargins(220, 0, 0, 0);
     74         layout.addView(radialGradientView, lp);
     75 
     76         lp = new FrameLayout.LayoutParams(200, 200, Gravity.CENTER);
     77         lp.setMargins(440, 0, 0, 0);
     78         layout.addView(sweepGradientView, lp);
     79 
     80         lp = new FrameLayout.LayoutParams(200, 200, Gravity.CENTER);
     81         lp.setMargins(220, -220, 0, 0);
     82         layout.addView(bitmapView, lp);
     83 
     84         layout.addView(rotateView, new FrameLayout.LayoutParams(
     85                 300, FrameLayout.LayoutParams.WRAP_CONTENT,
     86                 Gravity.CENTER_HORIZONTAL | Gravity.BOTTOM));
     87 
     88         setContentView(layout);
     89     }
     90 
     91     static class BitmapView extends View {
     92         private final Paint mPaint;
     93 
     94         BitmapView(Context c) {
     95             super(c);
     96 
     97             Bitmap texture = BitmapFactory.decodeResource(c.getResources(), R.drawable.sunset1);
     98             BitmapShader shader = new BitmapShader(texture, Shader.TileMode.REPEAT,
     99                     Shader.TileMode.REPEAT);
    100             mPaint = new Paint();
    101             mPaint.setShader(shader);
    102         }
    103 
    104         @Override
    105         protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
    106             super.onMeasure(widthMeasureSpec, heightMeasureSpec);
    107             setMeasuredDimension(200, 200);
    108         }
    109 
    110         @Override
    111         protected void onDraw(Canvas canvas) {
    112             super.onDraw(canvas);
    113             canvas.drawRect(0.0f, 0.0f, getWidth(), getHeight(), mPaint);
    114         }
    115     }
    116 
    117     static class GradientView extends View {
    118         private final Paint mPaint;
    119 
    120         GradientView(Context c) {
    121             super(c);
    122 
    123             LinearGradient gradient = new LinearGradient(0, 0, 200, 0, 0xFF000000, 0,
    124                     Shader.TileMode.CLAMP);
    125             mPaint = new Paint();
    126             mPaint.setShader(gradient);
    127         }
    128 
    129         @Override
    130         protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
    131             super.onMeasure(widthMeasureSpec, heightMeasureSpec);
    132             setMeasuredDimension(200, 200);
    133         }
    134 
    135         @Override
    136         protected void onDraw(Canvas canvas) {
    137             super.onDraw(canvas);
    138             canvas.drawRect(0.0f, 0.0f, getWidth(), getHeight(), mPaint);
    139         }
    140     }
    141 
    142     static class RadialGradientView extends View {
    143         private final Paint mPaint;
    144 
    145         RadialGradientView(Context c) {
    146             super(c);
    147 
    148             RadialGradient gradient = new RadialGradient(0.0f, 0.0f, 100.0f, 0xff000000, 0xffffffff,
    149                     Shader.TileMode.MIRROR);
    150             mPaint = new Paint();
    151             mPaint.setShader(gradient);
    152         }
    153 
    154         @Override
    155         protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
    156             super.onMeasure(widthMeasureSpec, heightMeasureSpec);
    157             setMeasuredDimension(200, 200);
    158         }
    159 
    160         @Override
    161         protected void onDraw(Canvas canvas) {
    162             super.onDraw(canvas);
    163             canvas.drawRect(0.0f, 0.0f, getWidth(), getHeight(), mPaint);
    164         }
    165     }
    166 
    167     static class SweepGradientView extends View {
    168         private final Paint mPaint;
    169 
    170         SweepGradientView(Context c) {
    171             super(c);
    172 
    173             SweepGradient gradient = new SweepGradient(100.0f, 100.0f, 0xff000000, 0xffffffff);
    174             mPaint = new Paint();
    175             mPaint.setShader(gradient);
    176         }
    177 
    178         @Override
    179         protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
    180             super.onMeasure(widthMeasureSpec, heightMeasureSpec);
    181             setMeasuredDimension(200, 200);
    182         }
    183 
    184         @Override
    185         protected void onDraw(Canvas canvas) {
    186             super.onDraw(canvas);
    187             canvas.drawRect(0.0f, 0.0f, getWidth(), getHeight(), mPaint);
    188         }
    189     }
    190 
    191     static class ShadersView extends View {
    192         private final Paint mPaint;
    193         private final float mDrawWidth;
    194         private final float mDrawHeight;
    195         private final LinearGradient mGradient;
    196         private final LinearGradient mGradientStops;
    197         private final Matrix mMatrix;
    198 
    199         ShadersView(Context c) {
    200             super(c);
    201 
    202             mDrawWidth = 200;
    203             mDrawHeight = 200;
    204 
    205             mGradient = new LinearGradient(0, 0, 0, 1, 0xFF000000, 0, Shader.TileMode.CLAMP);
    206             mGradientStops = new LinearGradient(0, 0, 0, 1,
    207                     new int[] { 0xFFFF0000, 0xFF00FF00, 0xFF0000FF }, null, Shader.TileMode.CLAMP);
    208 
    209             mMatrix = new Matrix();
    210 
    211             mPaint = new Paint();
    212         }
    213 
    214         @Override
    215         protected void onDraw(Canvas canvas) {
    216             super.onDraw(canvas);
    217             canvas.drawRGB(255, 255, 255);
    218 
    219             // Gradients
    220             canvas.save();
    221             float top = 40.0f;
    222             float right = 40.0f + mDrawWidth;
    223             float left = 40.0f;
    224             float bottom = 40.0f + mDrawHeight;
    225 
    226             mPaint.setShader(mGradient);
    227 
    228             mMatrix.setScale(1, mDrawWidth);
    229             mMatrix.postRotate(90);
    230             mMatrix.postTranslate(right, top);
    231             mGradient.setLocalMatrix(mMatrix);
    232             canvas.drawRect(right - mDrawWidth, top, right, top + mDrawHeight, mPaint);
    233 
    234             top += 40.0f + mDrawHeight;
    235             bottom += 40.0f + mDrawHeight;
    236 
    237             mMatrix.setScale(1, mDrawHeight);
    238             mMatrix.postTranslate(left, top);
    239             mGradient.setLocalMatrix(mMatrix);
    240             canvas.drawRect(left, top, right, top + mDrawHeight, mPaint);
    241 
    242             left += 40.0f + mDrawWidth;
    243             right += 40.0f + mDrawWidth;
    244             top -= 40.0f + mDrawHeight;
    245             bottom -= 40.0f + mDrawHeight;
    246 
    247             mMatrix.setScale(1, mDrawHeight);
    248             mMatrix.postRotate(180);
    249             mMatrix.postTranslate(left, bottom);
    250             mGradient.setLocalMatrix(mMatrix);
    251             canvas.drawRect(left, bottom - mDrawHeight, right, bottom, mPaint);
    252 
    253             top += 40.0f + mDrawHeight;
    254             bottom += 40.0f + mDrawHeight;
    255 
    256             mMatrix.setScale(1, mDrawWidth);
    257             mMatrix.postRotate(-90);
    258             mMatrix.postTranslate(left, top);
    259             mGradient.setLocalMatrix(mMatrix);
    260             canvas.drawRect(left, top, left + mDrawWidth, bottom, mPaint);
    261 
    262             right = left + mDrawWidth;
    263             left = 40.0f;
    264             top = bottom + 20.0f;
    265             bottom = top + 50.0f;
    266 
    267             mPaint.setShader(mGradientStops);
    268 
    269             mMatrix.setScale(1, mDrawWidth);
    270             mMatrix.postRotate(90);
    271             mMatrix.postTranslate(right, top);
    272             mGradientStops.setLocalMatrix(mMatrix);
    273             canvas.drawRect(left, top, right, bottom, mPaint);
    274 
    275             canvas.restore();
    276         }
    277     }
    278 }
    279