Android自己定义控件：进度条的四种实现方式

前三种实现方式代码出自：

http://stormzhang.com/openandroid/2013/11/15/android-custom-loading/

（源代码下载）http://download.csdn.net/detail/chaoyu168/9616035

近期一直在学习自己定义控件，搜了很多大牛们Blog里分享的小教程。也上GitHub找了一些类似的控件进行学习。发现读起来都不太好懂，就想写这么一篇东西作为学习笔记吧。

一、控件介绍：

进度条在App中非经常见，比例如以下载进度、载入图片、打开文章、打开网页等等……都须要这么一个效果让用户知道我们的App正在读取。以构造良好的交互。假设没有这样一个效果的话。用户没法知道东西有没有下载好、图片载入了没有、文章打开了没……会让用户非常不爽。基于这种情景我们的UI设计师们创造了这样一个控件。

二、这篇文章会涉及的知识点：

跟我一样刚入门的Android菜鸟们。我推荐大家先了解一下这些知识点再往下看。

这些知识点我也会推荐一些博客给大家看看。更推荐大家看文档里的解释，当然大牛们能够直接无视……

1、ClipDrawable类：可以对一个drawable类进行剪切操作（即仅仅显示某一部分的区域，还有一部分隐藏），显示多大的区域由level控制（level取值是0～10000）

【博客：http://blog.csdn.net/lonelyroamer/article/details/8244777】、没文档的能够在这看【http://www.apihome.cn/api/android/ClipDrawable.html】

2、自己定义View：guolin大神的深入学习View四部曲

【Android LayoutInflater原理分析，带你一步步深入了解View——http://blog.csdn.net/guolin_blog/article/details/12921889】

【Android视图绘制流程全然解析。带你一步步深入了解View——http://blog.csdn.net/guolin_blog/article/details/16330267】

【Android视图状态及重绘流程分析，带你一步步深入了解View——http://blog.csdn.net/guolin_blog/article/details/17045157】

【Android自己定义View的实现方法，带你一步步深入了解View——http://blog.csdn.net/guolin_blog/article/details/17357967】

3、没看过我写的：Android自己定义控件——老版优酷三级菜单的话，也许须要看看这个：

【RotateAnimation具体解释——http://blog.csdn.net/u012403246/article/details/41415799】

三、Android上的实现方式：

（前三种方法比較简单，第四种方法是GitHub项目的解析，对前三种没兴趣能够直接跳到后边……）

1、效果图：

将进度条的变换过程分解为一帧一帧的图片，将这些一帧一帧的图片连起来构成一个动画。

经常使用于：手机阅读网页、逛社区时，载入图片、文章等不须要清楚知道载入进度，可是须要知道是否进行载入的情景。

这样的方法实现能够通过创建一个animation-list的XML文件，然后给系统API提供的ProgressBar的indeterminateDrawable属性就能够了。（这个属性应该是类似于设置一个动画吧……）

XML：

[html] view plain copy

 

1. <?

   xml version="1.0" encoding="utf-8"?>    

2. <animation-list xmlns:android="http://schemas.android.com/apk/res/android"    
3.     android:oneshot="false" >    
4.     <item android:duration="150" >    
5.         <clip     
6.             android:clipOrientation="horizontal"    
7.             android:drawable="@drawable/loading_01"    
8.             android:gravity="left"/>    
9.     </item>    
10.     <item android:duration="150" >    
11.         <clip     
12.             android:clipOrientation="horizontal"    
13.             android:drawable="@drawable/loading_02"    
14.             android:gravity="left"/>    
15.     </item>    
16.     <item android:duration="150" >    
17.         <clip     
18.             android:clipOrientation="horizontal"    
19.             android:drawable="@drawable/loading_03"    
20.             android:gravity="left"/>    
21.     </item>    
22.     <item android:duration="150" >    
23.         <clip     
24.             android:clipOrientation="horizontal"    
25.             android:drawable="@drawable/loading_04"    
26.             android:gravity="left"/>    
27.     </item>    
28.     <item android:duration="150" >    
29.         <clip     
30.             android:clipOrientation="horizontal"    
31.             android:drawable="@drawable/loading_05"    
32.             android:gravity="left"/>    
33.     </item>    
34.     <item android:duration="150" >    
35.         <clip     
36.             android:clipOrientation="horizontal"    
37.             android:drawable="@drawable/loading_06"    
38.             android:gravity="left"/>    
39.     </item>    
40.     <item android:duration="150" >    
41.         <clip     
42.             android:clipOrientation="horizontal"    
43.             android:drawable="@drawable/loading_07"    
44.             android:gravity="left"/>    
45.     </item>    
46.     <item android:duration="150" >    
47.         <clip     
48.             android:clipOrientation="horizontal"    
49.             android:drawable="@drawable/loading_08"    
50.             android:gravity="left"/>    
51.     </item>    
52.     <item android:duration="150" >    
53.         <clip     
54.             android:clipOrientation="horizontal"    
55.             android:drawable="@drawable/loading_09"    
56.             android:gravity="left"/>    
57.     </item>    
58.     <item android:duration="150" >    
59.         <clip     
60.             android:clipOrientation="horizontal"    
61.             android:drawable="@drawable/loading_10"    
62.             android:gravity="left"/>    
63.     </item>    
64.     <item android:duration="150" >    
65.         <clip     
66.             android:clipOrientation="horizontal"    
67.             android:drawable="@drawable/loading_11"    
68.             android:gravity="left"/>    
69.     </item>    
70.     <item android:duration="150" >    
71.         <clip     
72.             android:clipOrientation="horizontal"    
73.             android:drawable="@drawable/loading_12"    
74.             android:gravity="left"/>    
75.     </item>    
76.     
77. </animation-list>  

[html] view plain copy

 

1. <ProgressBar     
2.     android:layout_width="wrap_content"    
3.     android:layout_height="wrap_content"    
4.     android:indeterminateDrawable="@drawable/progressbar1"    
5.     />  

在上一篇有关自己定义控件的博客里我们使用了一个RotateAnimation类来实现旋转效果 （http://blog.csdn.net/u012403246/article/details/41309161），事实上。我们在这里也能够把一张图片，通过旋转。达到我们要的效果。本质上和上一种方法没多大差别。

我们仅仅须要创建一个rotate的XML。对其属性进行一些简单的设置。然后增加我们要用的图片就能够了。

XML：

[html] view plain copy

 

1. <?xml version="1.0" encoding="utf-8"?>    
2. <rotate xmlns:android="http://schemas.android.com/apk/res/android"    
3.     android:pivotX="50%"    
4.     android:pivotY="50%"    
5.     android:fromDegrees="0"    
6.     android:toDegrees="360"    
7.     android:interpolator="@android:anim/accelerate_decelerate_interpolator" >    
8.     <bitmap     
9.         android:antialias="true"    
10.         android:filter="true"    
11.         android:src="@drawable/loading_360"/>    
12.     
13. </rotate>  

[html] view plain copy

 

1. <ProgressBar     
2.     android:layout_width="wrap_content"    
3.     android:layout_height="wrap_content"    
4.     android:indeterminateDrawable="@drawable/progressbar2"/>  

我们能够弄两张照片。第一张是纯黑色的，然后把这张照片中心挖一个圆出来，圆区域弄成白色，挖出来的圆弄成第二张照片。我们最好还是叠加显示两张照片，刚開始把第二张全然“遮住”。随着载入进度的添加，我们降低遮住的区域把第二张照片慢慢的显示出来。

Android上刚好就有这么一个ClipDrawable类，可以实现剪裁的过程。

我们来看看怎么通过这种方式自己定义一个进度条控件。

代码：

[java] view plain copy

 

1. public class MyProgressBar extends FrameLayout{    
2.     private boolean running;    
3.     private int progress = 0;    
4.     private static final int MAX_PROGRESS = 10000;    
5.         
6.     private ClipDrawable clip;    
7.         
8.     private Handler handler = new Handler(){    
9.         @Override    
10.         public void handleMessage(android.os.Message msg) {    
11.             if(msg.what == 0x123)    
12.                 clip.setLevel(progress);    
13.         }    
14.     };    
15.         
16.     public MyProgressBar(Context context){    
17.         this(context,null,0);    
18.     }    
19.     
20.     public MyProgressBar(Context context,AttributeSet attrs){    
21.         this(context,null,0);    
22.     }    
23.         
24.     public MyProgressBar(Context context, AttributeSet attrs, int defStyle) {    
25.         super(context, attrs, defStyle);    
26.         Init(context);    
27.     }    
28.         
29.     public void Init(Context context){    
30.         View view = LayoutInflater.from(context).inflate(R.layout.view, null);    
31.             
32.         ImageView iv = (ImageView)view.findViewById(R.id.progress_img);    
33.             
34.         addView(view);    
35.         clip = (ClipDrawable)iv.getDrawable();    
36.             
37.         Thread thread = new Thread(new Runnable() {    
38.                 
39.             @Override    
40.             public void run() {    
41.                 running = true;    
42.                 while(running){    
43.                     handler.sendEmptyMessage(0x123);    
44.                     if(progress == MAX_PROGRESS)    
45.                         progress = 0;    
46.                     progress += 100;    
47.                     try {    
48.                         Thread.sleep(18);    
49.                     } catch (InterruptedException e) {    
50.                         e.printStackTrace();    
51.                     }    
52.                 }    
53.             }    
54.         });    
55.         thread.start();    
56.     }    
57.     
58.     public void stop(){    
59.         progress = 0;    
60.         running = false;    
61.     }    
62. }   

通过代码我们能够看到。逻辑很easy。关键就在于ClipDrawable的setLevel()方法，这个是设置剪裁效果的。

4、效果图：

实现一个View的子类——Progress Wheel类，实现进度条效果。

详细的内容我都写在了凝视上，假设不了解自己定义控件的知识。能够去阅读guolin博客里自己定义View四部曲的解说，讲的挺好的。

代码：

[java] view plain copy

 

1. public class ProgressWheel extends View {    
2.     
3.     //绘制View用到的各种长、宽带大小    
4.     private int layout_height = 0;    
5.     private int layout_width = 0;    
6.     private int fullRadius = 100;    
7.     private int circleRadius = 80;    
8.     private int barLength = 60;    
9.     private int barWidth = 20;    
10.     private int rimWidth = 20;    
11.     private int textSize = 20;    
12.     private float contourSize = 0;    
13.     
14.     //与页边的间距    
15.     private int paddingTop = 5;    
16.     private int paddingBottom = 5;    
17.     private int paddingLeft = 5;    
18.     private int paddingRight = 5;    
19.     
20.     //View要绘制的颜色    
21.     private int barColor = 0xAA000000;    
22.     private int contourColor = 0xAA000000;    
23.     private int circleColor = 0x00000000;    
24.     private int rimColor = 0xAADDDDDD;    
25.     private int textColor = 0xFF000000;    
26.     
27.     //绘制要用的画笔    
28.     private Paint barPaint = new Paint();    
29.     private Paint circlePaint = new Paint();    
30.     private Paint rimPaint = new Paint();    
31.     private Paint textPaint = new Paint();    
32.     private Paint contourPaint = new Paint();    
33.     
34.     //绘制要用的矩形    
35.     @SuppressWarnings("unused")    
36.     private RectF rectBounds = new RectF();    
37.     private RectF circleBounds = new RectF();    
38.     private RectF circleOuterContour = new RectF();    
39.     private RectF circleInnerContour = new RectF();    
40.     
41.     //动画    
42.     //每次绘制要移动的像素数目    
43.     private int spinSpeed = 2;    
44.     //绘制过程的时间间隔    
45.     private int delayMillis = 0;    
46.     int progress = 0;    
47.     boolean isSpinning = false;    
48.     
49.     //其它    
50.     private String text = "";    
51.     private String[] splitText = {};    
52.     
53.     /**  
54.      * ProgressWheel的构造方法  
55.      *  
56.      * @param context  
57.      * @param attrs  
58.      */    
59.     public ProgressWheel(Context context, AttributeSet attrs) {    
60.         super(context, attrs);    
61.     
62.         parseAttributes(context.obtainStyledAttributes(attrs,    
63.                 R.styleable.ProgressWheel));    
64.     }    
65.     
66.     //----------------------------------    
67.     //初始化一些元素    
68.     //----------------------------------    
69.     
70.     /*  
71.      * 调用这种方法时，使View绘制为方形  
72.      * From: http://www.jayway.com/2012/12/12/creating-custom-android-views-part-4-measuring-and-how-to-force-a-view-to-be-square/  
73.      *   
74.      */    
75.     @Override    
76.     protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {    
77.         // 首先我们要调用超类的onMeasure借口     
78.         // 原因是我们自己去实现一个方法获得长度、宽度太麻烦了    
79.         // 使用超类的的方法很方便并且让复杂的细节可控    
80.         super.onMeasure(widthMeasureSpec, heightMeasureSpec);    
81.     
82.         // 在这里我们不能使用getWidth()和getHeight()。

         

83.         // 由于这两个方法仅仅能在View的布局完毕后才干使用。而一个View的绘制过程是先绘制元素，再绘制Layout    
84.         // 所以我们必须使用getMeasuredWidth()和getMeasuredHeight()    
85.         int size = 0;    
86.         int width = getMeasuredWidth();    
87.         int height = getMeasuredHeight();    
88.         int widthWithoutPadding = width - getPaddingLeft() - getPaddingRight();    
89.         int heigthWithoutPadding = height - getPaddingTop() - getPaddingBottom();    
90.             
91.         // 最后我们用一些简单的逻辑去计算View的大小并调用setMeasuredDimension()去设置View的大小    
92.         // 在比較View的长宽前我们不考虑间距，但当我们设置View所须要绘制的面积时。我们要考虑它    
93.         // 不考虑间距的View（View内的实际画面）此时就应该是方形的，可是因为间距的存在，终于View所占的面积可能不是方形的     
94.         if (widthWithoutPadding > heigthWithoutPadding) {    
95.             size = heigthWithoutPadding;    
96.         } else {    
97.             size = widthWithoutPadding;    
98.         }    
99.             
100.         // 假设你重写了onMeasure()方法。你必须调用setMeasuredDimension()方法     
101.         // 这是你设置View大小的唯一途径      
102.         // 假设你不调用setMeasuredDimension()方法，父控件会抛出异常。而且程序会崩溃    
103.         // 假设我们使用了超类的onMeasure()方法，我们就不是那么须要setMeasuredDimension()方法    
104.         // 然而，重写onMeasure()方法是为了改变既有的绘制流程。所以我们必须调用setMeasuredDimension()方法以达到我们的目的    
105.         setMeasuredDimension(size + getPaddingLeft() + getPaddingRight(), size + getPaddingTop() + getPaddingBottom());    
106.     }    
107.     
108.     /**  
109.      * 使用onSizeChanged方法取代onAttachedToWindow获得View的面积  
110.      * 由于这种方法会在測量了MATCH_PARENT和WRAP_CONTENT后立即被调用  
111.      * 使用获得的面积设置View  
112.      */    
113.     @Override    
114.     protected void onSizeChanged(int w, int h, int oldw, int oldh) {    
115.         super.onSizeChanged(w, h, oldw, oldh);    
116.     
117.         // Share the dimensions    
118.         layout_width = w;    
119.         layout_height = h;    
120.     
121.         setupBounds();    
122.         setupPaints();    
123.         invalidate();    
124.     }    
125.     
126.     /**  
127.      * 设置我们想要绘制的progress wheel的颜色  
128.      */    
129.     private void setupPaints() {    
130.         barPaint.setColor(barColor);    
131.         barPaint.setAntiAlias(true);    
132.         barPaint.setStyle(Style.STROKE);    
133.         barPaint.setStrokeWidth(barWidth);    
134.     
135.         rimPaint.setColor(rimColor);    
136.         rimPaint.setAntiAlias(true);    
137.         rimPaint.setStyle(Style.STROKE);    
138.         rimPaint.setStrokeWidth(rimWidth);    
139.     
140.         circlePaint.setColor(circleColor);    
141.         circlePaint.setAntiAlias(true);    
142.         circlePaint.setStyle(Style.FILL);    
143.     
144.         textPaint.setColor(textColor);    
145.         textPaint.setStyle(Style.FILL);    
146.         textPaint.setAntiAlias(true);    
147.         textPaint.setTextSize(textSize);    
148.     
149.         contourPaint.setColor(contourColor);    
150.         contourPaint.setAntiAlias(true);    
151.         contourPaint.setStyle(Style.STROKE);    
152.         contourPaint.setStrokeWidth(contourSize);    
153.     }    
154.     
155.     /**  
156.      * 设置元素的边界  
157.      */    
158.     private void setupBounds() {    
159.         // 为了保持宽度和长度的一致。我们要获得layout_width和layout_height中较小的一个，从而绘制一个圆    
160.         int minValue = Math.min(layout_width, layout_height);    
161.     
162.         // 计算在绘制过程中在x,y方向的偏移量    
163.         int xOffset = layout_width - minValue;    
164.         int yOffset = layout_height - minValue;    
165.     
166.         // 间距加上偏移量    
167.         paddingTop = this.getPaddingTop() + (yOffset / 2);    
168.         paddingBottom = this.getPaddingBottom() + (yOffset / 2);    
169.         paddingLeft = this.getPaddingLeft() + (xOffset / 2);    
170.         paddingRight = this.getPaddingRight() + (xOffset / 2);    
171.     
172.         int width = getWidth(); //this.getLayoutParams().width;    
173.         int height = getHeight(); //this.getLayoutParams().height;    
174.     
175.         rectBounds = new RectF(paddingLeft,    
176.                 paddingTop,    
177.                 width - paddingRight,    
178.                 height - paddingBottom);    
179.     
180.         circleBounds = new RectF(paddingLeft + barWidth,    
181.                 paddingTop + barWidth,    
182.                 width - paddingRight - barWidth,    
183.                 height - paddingBottom - barWidth);    
184.         circleInnerContour = new RectF(circleBounds.left + (rimWidth / 2.0f) + (contourSize / 2.0f), circleBounds.top + (rimWidth / 2.0f) + (contourSize / 2.0f), circleBounds.right - (rimWidth / 2.0f) - (contourSize / 2.0f), circleBounds.bottom - (rimWidth / 2.0f) - (contourSize / 2.0f));    
185.         circleOuterContour = new RectF(circleBounds.left - (rimWidth / 2.0f) - (contourSize / 2.0f), circleBounds.top - (rimWidth / 2.0f) - (contourSize / 2.0f), circleBounds.right + (rimWidth / 2.0f) + (contourSize / 2.0f), circleBounds.bottom + (rimWidth / 2.0f) + (contourSize / 2.0f));    
186.     
187.         fullRadius = (width - paddingRight - barWidth) / 2;    
188.         circleRadius = (fullRadius - barWidth) + 1;    
189.     }    
190.     
191.     /**  
192.      * 从XML中解析控件的属性  
193.      *  
194.      * @param a the attributes to parse  
195.      */    
196.     private void parseAttributes(TypedArray a) {    
197.         barWidth = (int) a.getDimension(R.styleable.ProgressWheel_barWidth,    
198.                 barWidth);    
199.     
200.         rimWidth = (int) a.getDimension(R.styleable.ProgressWheel_rimWidth,    
201.                 rimWidth);    
202.     
203.         spinSpeed = (int) a.getDimension(R.styleable.ProgressWheel_spinSpeed,    
204.                 spinSpeed);    
205.     
206.         delayMillis = a.getInteger(R.styleable.ProgressWheel_delayMillis,    
207.                 delayMillis);    
208.         if (delayMillis < 0) {    
209.             delayMillis = 0;    
210.         }    
211.     
212.         barColor = a.getColor(R.styleable.ProgressWheel_barColor, barColor);    
213.     
214.         barLength = (int) a.getDimension(R.styleable.ProgressWheel_barLength,    
215.                 barLength);    
216.     
217.         textSize = (int) a.getDimension(R.styleable.ProgressWheel_textSize,    
218.                 textSize);    
219.     
220.         textColor = (int) a.getColor(R.styleable.ProgressWheel_textColor,    
221.                 textColor);    
222.     
223.         //假设text是空的，就无视它    
224.         if (a.hasValue(R.styleable.ProgressWheel_text)) {    
225.             setText(a.getString(R.styleable.ProgressWheel_text));    
226.         }    
227.     
228.         rimColor = (int) a.getColor(R.styleable.ProgressWheel_rimColor,    
229.                 rimColor);    
230.     
231.         circleColor = (int) a.getColor(R.styleable.ProgressWheel_circleColor,    
232.                 circleColor);    
233.     
234.         contourColor = a.getColor(R.styleable.ProgressWheel_contourColor, contourColor);    
235.         contourSize = a.getDimension(R.styleable.ProgressWheel_contourSize, contourSize);    
236.     
237.     
238.         // 使用TypedArray获得控件属性时必需要注意：使用结束后必须回收TypedArray的对象    
239.         a.recycle();    
240.     }    
241.     
242.     //----------------------------------    
243.     //动画    
244.     //----------------------------------    
245.     
246.     protected void onDraw(Canvas canvas) {    
247.         super.onDraw(canvas);    
248.         //绘制内圆    
249.         canvas.drawArc(circleBounds, 360, 360, false, circlePaint);    
250.         //绘制边界    
251.         canvas.drawArc(circleBounds, 360, 360, false, rimPaint);    
252.         canvas.drawArc(circleOuterContour, 360, 360, false, contourPaint);    
253.         canvas.drawArc(circleInnerContour, 360, 360, false, contourPaint);    
254.         //绘制条纹    
255.         if (isSpinning) {    
256.             canvas.drawArc(circleBounds, progress - 90, barLength, false,    
257.                     barPaint);    
258.         } else {    
259.             canvas.drawArc(circleBounds, -90, progress, false, barPaint);    
260.         }    
261.         //绘制我们想要设置的文字 (并让它显示在圆水平和垂直方向的中心处)    
262.         float textHeight = textPaint.descent() - textPaint.ascent();    
263.         float verticalTextOffset = (textHeight / 2) - textPaint.descent();    
264.     
265.         for (String s : splitText) {    
266.             float horizontalTextOffset = textPaint.measureText(s) / 2;    
267.             canvas.drawText(s, this.getWidth() / 2 - horizontalTextOffset,    
268.                     this.getHeight() / 2 + verticalTextOffset, textPaint);    
269.         }    
270.         if (isSpinning) {    
271.             scheduleRedraw();    
272.         }    
273.     }    
274.     
275.     private void scheduleRedraw() {    
276.         progress += spinSpeed;    
277.         if (progress > 360) {    
278.             progress = 0;    
279.         }    
280.         postInvalidateDelayed(delayMillis);    
281.     }    
282.     
283.     /**  
284.     *   推断wheel是否在旋转  
285.     */    
286.         
287.     public boolean isSpinning() {    
288.         if(isSpinning){    
289.             return true;    
290.         } else {    
291.             return false;    
292.         }    
293.     }    
294.         
295.     /**  
296.      * 重设进度条的值  
297.      */    
298.     public void resetCount() {    
299.         progress = 0;    
300.         setText("0%");    
301.         invalidate();    
302.     }    
303.     
304.     /**  
305.      * 停止进度条的旋转  
306.      */    
307.     public void stopSpinning() {    
308.         isSpinning = false;    
309.         progress = 0;    
310.         postInvalidate();    
311.     }    
312.     
313.     
314.     /**  
315.      * 让进度条开启旋转模式  
316.      */    
317.     public void spin() {    
318.         isSpinning = true;    
319.         postInvalidate();    
320.     }    
321.     
322.     /**  
323.      * 让进度条每次添加1（最大值为360）  
324.      */    
325.     public void incrementProgress() {    
326.         isSpinning = false;    
327.         progress++;    
328.         if (progress > 360)    
329.             progress = 0;    
330.         setText(Math.round(((float) progress / 360) * 100) + "%");    
331.        postInvalidate();    
332.     }    
333.     
334.     
335.     /**  
336.      * 设置进度条为一个确切的数值  
337.      */    
338.     public void setProgress(int i) {    
339.         isSpinning = false;    
340.         progress = i;    
341.         postInvalidate();    
342.     }    
343.     
344.     //----------------------------------    
345.     //get和set方法    
346.     //----------------------------------    
347.     
348.     /**  
349.      * 设置progress bar的文字并不须要刷新View  
350.      *  
351.      * @param text the text to show (‘\n‘ constitutes a new line)  
352.      */    
353.     public void setText(String text) {    
354.         this.text = text;    
355.         splitText = this.text.split("\n");    
356.     }    
357.     
358.     public int getCircleRadius() {    
359.         return circleRadius;    
360.     }    
361.     
362.     public void setCircleRadius(int circleRadius) {    
363.         this.circleRadius = circleRadius;    
364.     }    
365.     
366.     public int getBarLength() {    
367.         return barLength;    
368.     }    
369.     
370.     public void setBarLength(int barLength) {    
371.         this.barLength = barLength;    
372.     }    
373.     
374.     public int getBarWidth() {    
375.         return barWidth;    
376.     }    
377.     
378.     public void setBarWidth(int barWidth) {    
379.         this.barWidth = barWidth;    
380.             
381.         if ( this.barPaint != null ) {    
382.             this.barPaint.setStrokeWidth( this.barWidth );    
383.         }    
384.     }    
385.     
386.     public int getTextSize() {    
387.         return textSize;    
388.     }    
389.     
390.     public void setTextSize(int textSize) {    
391.         this.textSize = textSize;    
392.             
393.         if ( this.textPaint != null ) {    
394.             this.textPaint.setTextSize( this.textSize );    
395.         }    
396.     }    
397.     
398.     public int getPaddingTop() {    
399.         return paddingTop;    
400.     }    
401.     
402.     public void setPaddingTop(int paddingTop) {    
403.         this.paddingTop = paddingTop;    
404.     }    
405.     
406.     public int getPaddingBottom() {    
407.         return paddingBottom;    
408.     }    
409.     
410.     public void setPaddingBottom(int paddingBottom) {    
411.         this.paddingBottom = paddingBottom;    
412.     }    
413.     
414.     public int getPaddingLeft() {    
415.         return paddingLeft;    
416.     }    
417.     
418.     public void setPaddingLeft(int paddingLeft) {    
419.         this.paddingLeft = paddingLeft;    
420.     }    
421.     
422.     public int getPaddingRight() {    
423.         return paddingRight;    
424.     }    
425.     
426.     public void setPaddingRight(int paddingRight) {    
427.         this.paddingRight = paddingRight;    
428.     }    
429.     
430.     public int getBarColor() {    
431.         return barColor;    
432.     }    
433.     
434.     public void setBarColor(int barColor) {    
435.         this.barColor = barColor;    
436.             
437.         if ( this.barPaint != null ) {    
438.             this.barPaint.setColor( this.barColor );    
439.         }    
440.     }    
441.     
442.     public int getCircleColor() {    
443.         return circleColor;    
444.     }    
445.     
446.     public void setCircleColor(int circleColor) {    
447.         this.circleColor = circleColor;    
448.             
449.         if ( this.circlePaint != null ) {    
450.             this.circlePaint.setColor( this.circleColor);    
451.         }    
452.     }    
453.     
454.     public int getRimColor() {    
455.         return rimColor;    
456.     }    
457.     
458.     public void setRimColor(int rimColor) {    
459.         this.rimColor = rimColor;    
460.             
461.         if ( this.rimPaint != null ) {    
462.             this.rimPaint.setColor( this.rimColor );    
463.         }    
464.     }    
465.     
466.     
467.     public Shader getRimShader() {    
468.         return rimPaint.getShader();    
469.     }    
470.     
471.     public void setRimShader(Shader shader) {    
472.         this.rimPaint.setShader(shader);    
473.     }    
474.     
475.     public int getTextColor() {    
476.         return textColor;    
477.     }    
478.     
479.     public void setTextColor(int textColor) {    
480.         this.textColor = textColor;    
481.             
482.         if ( this.textPaint != null ) {    
483.             this.textPaint.setColor( this.textColor );    
484.         }    
485.     }    
486.     
487.     public int getSpinSpeed() {    
488.         return spinSpeed;    
489.     }    
490.     
491.     public void setSpinSpeed(int spinSpeed) {    
492.         this.spinSpeed = spinSpeed;    
493.     }    
494.     
495.     public int getRimWidth() {    
496.         return rimWidth;    
497.     }    
498.     
499.     public void setRimWidth(int rimWidth) {    
500.         this.rimWidth = rimWidth;    
501.             
502.         if ( this.rimPaint != null ) {    
503.             this.rimPaint.setStrokeWidth( this.rimWidth );    
504.         }    
505.     }    
506.     
507.     public int getDelayMillis() {    
508.         return delayMillis;    
509.     }    
510.     
511.     public void setDelayMillis(int delayMillis) {    
512.         this.delayMillis = delayMillis;    
513.     }    
514.         
515.     public int getContourColor() {    
516.         return contourColor;    
517.     }    
518.         
519.     public void setContourColor(int contourColor) {    
520.         this.contourColor = contourColor;    
521.             
522.         if ( contourPaint != null ) {    
523.             this.contourPaint.setColor( this.contourColor );    
524.         }    
525.     }    
526.         
527.     public float getContourSize() {    
528.         return this.contourSize;    
529.     }    
530.         
531.     public void setContourSize(float contourSize) {    
532.         this.contourSize = contourSize;    
533.             
534.         if ( contourPaint != null ) {    
535.             this.contourPaint.setStrokeWidth( this.contourSize );    
536.         }    
537.     }    
538. }