自定义tab bar控件 学习资料

http://blog.csdn.net/zoeice/article/details/8068671

1. import java.util.Vector;
2. import android.content.Context;
3. import android.graphics.Bitmap;
4. import android.graphics.BitmapFactory;
5. import android.graphics.Canvas;
6. import android.graphics.NinePatch;
7. import android.graphics.Paint;
8. import android.graphics.Rect;
9. import android.util.DisplayMetrics;
10. import android.view.GestureDetector;
11. import android.view.GestureDetector.OnGestureListener;
12. import android.view.MotionEvent;
13. import android.view.View;
14. import android.view.View.OnTouchListener;
15. import android.widget.PopupWindow;
16. import com.example.zoeicetabgroup.R;
17. /**
18. * custom tab bar
19. * @author zoeice
20. *
21. */
22. public class LPTabGroupWithGesture extends View implements OnGestureListener, OnTouchListener{
23. private int tabNum = 0;
24. private int curSelect = 0;
25. private int curX = 0;
26. private int savedClickIndex = -1;
27. private int savedX = 0;
28. private boolean isDraging = false;
29. private int dragCurrentX = 0;
30. private int dragSavedX = 0;
31. private int dragSelectIndex = -1;
32. private final int TEXT_SIZE = 30;
33. private final int TAB_MARGIN = 30;
34. private int tabWidth = 200;
35. private int tabHeight = 0;
36. private int tabGap = 30;// IF
37. private int tabAddWidth = 90;// IF
38. private Bitmap bitCur;
39. private NinePatch npCur;
40. private Bitmap bitNor;
41. private NinePatch npNor;
42. private Bitmap bitAdd;
43. private int screenWidth;
44. private int screenHeight;
45. private float screenDensity;
46. private PopupWindow popMenu;
47. private OnTabItemClickListener clickListener;
48. private GestureDetector mGestureDetector;
49. private Vector<TabItem> tabLists = new Vector<TabItem>();
50. public LPTabGroupWithGesture(Context context, Vector<TabItem> vec) {
51. this(context);
52. tabLists = vec;
53. tabNum = vec.size();
54. }
55. public LPTabGroupWithGesture(Context context) {
56. super(context);
57. if(tabNum == 0){
58. tabNum = 1;
59. tabLists.add(new TabItem());
60. }
61. initParams(context);
62. }
63. /**
64. * init view's params
65. */
66. private void initParams(Context context){
67. this.setLongClickable(true);
68. this.setOnTouchListener(this);
69. mGestureDetector = new GestureDetector(context, this);
70. mGestureDetector.setIsLongpressEnabled(true);
71. DisplayMetrics displayMetrics = getResources().getDisplayMetrics();
72. screenWidth = displayMetrics.widthPixels;
73. screenHeight = displayMetrics.heightPixels;
74. screenDensity = displayMetrics.density;
75. bitCur = BitmapFactory.decodeResource(getResources(),
76. R.drawable.tab);
77. npCur = new NinePatch(bitCur, bitCur.getNinePatchChunk(), null);
78. tabHeight = bitCur.getHeight();
79. bitNor = BitmapFactory.decodeResource(getResources(),
80. R.drawable.tab);
81. npNor = new NinePatch(bitNor, bitNor.getNinePatchChunk(), null);
82. bitAdd = BitmapFactory.decodeResource(getResources(),
83. R.drawable.tab_add);
84. tabAddWidth = bitAdd.getWidth();
85. }
86. /**设置当前选中选项的位置*/
87. public void setCurrentSelect(int index) {
88. curSelect = index;
89. invalidate();
90. }
91. /**
92. * @see android.view.View#measure(int, int)
93. */
94. @Override
95. protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
96. setMeasuredDimension(screenWidth, tabHeight);
97. }
98. @Override
99. protected void onDraw(Canvas canvas) {
100. super.onDraw(canvas);
101. Paint paint = new Paint();
102. paint.setColor(0xff707070);
103. paint.setTextSize(TEXT_SIZE);
104. /*draw bg*/
105. canvas.drawARGB(0xff, 0xa1, 0x9c, 0xff);
106. if(isDraging){
107. int dX = dragCurrentX +  (tabWidth - tabGap) * curSelect;
108. /*draw normal tab*/
109. for (int i = tabNum - 1; i >= 0; i--) {
110. if (i != curSelect) {
111. int nX = curX + (tabWidth - tabGap) * i ;
112. if(i > savedClickIndex && savedClickIndex > -1){
113. nX -= tabWidth - tabGap;
114. }
115. if(i > dragSelectIndex && dragSelectIndex > -1){
116. nX += tabWidth - tabGap;
117. }
118. Rect nR = new Rect(nX, 0, nX + tabWidth, tabHeight);
119. npNor.draw(canvas, nR);
120. //draw text
121. canvas.save();
122. canvas.clipRect(new Rect(nX + TAB_MARGIN, 0, nX + tabWidth - TAB_MARGIN, tabHeight));
123. canvas.drawText(tabLists.get(i).name, nX + TAB_MARGIN, (tabHeight + TEXT_SIZE) >> 1, paint);
124. canvas.restore();
125. }
126. }
127. /*draw shape for above normal tab*/
128. canvas.drawARGB(0x50, 0x00, 0x00, 0x00);
129. /*draw buttom line*/
130. Paint paintShape = new Paint();
131. paintShape.setColor(0x50000000);
132. canvas.drawRect(0, tabHeight - 2, screenWidth, tabHeight, paintShape);
133. /*draw current selected tab*/
134. Rect dR = new Rect(dX, 0, dX + tabWidth, tabHeight);
135. npCur.draw(canvas, dR);
136. //draw current text
137. paint.setColor(0xff456789);
138. canvas.drawText(tabLists.get(curSelect).name, dX + tabGap, (tabHeight + TEXT_SIZE) >> 1, paint);
139. /*draw add button*/
140. int aX =  curX + (tabWidth - tabGap) * tabNum;
141. if(dX + tabWidth > aX)
142. canvas.drawBitmap(bitAdd, dX + tabWidth - tabGap, 0, paint);
143. else
144. canvas.drawBitmap(bitAdd, aX, 0, paint);
145. }else{
146. /*draw normal tab*/
147. for (int i = tabNum - 1; i >= 0; i--) {
148. if (i != curSelect) {
149. int nX = curX + (tabWidth - tabGap) * i ;
150. Rect nR = new Rect(nX, 0, nX + tabWidth, tabHeight);
151. npNor.draw(canvas, nR);
152. //draw text
153. canvas.save();
154. canvas.clipRect(new Rect(nX + TAB_MARGIN, 0, nX + tabWidth - TAB_MARGIN, tabHeight));
155. canvas.drawText(tabLists.get(i).name, nX + TAB_MARGIN, (tabHeight + TEXT_SIZE) >> 1, paint);
156. canvas.restore();
157. }
158. }
159. /*draw shape for above normal tab*/
160. canvas.drawARGB(0x50, 0x00, 0x00, 0x00);
161. /*draw buttom line*/
162. Paint paintShape = new Paint();
163. paintShape.setColor(0x50000000);
164. canvas.drawRect(0, tabHeight - 2, screenWidth, tabHeight, paintShape);
165. /*draw current selected tab*/
166. int cX = curX +  (tabWidth - tabGap) * curSelect;
167. Rect cR = new Rect(cX, 0, cX + tabWidth, tabHeight);
168. npCur.draw(canvas, cR);
169. //draw current text
170. paint.setColor(0xff456789);
171. canvas.drawText(tabLists.get(curSelect).name, cX + tabGap, (tabHeight + TEXT_SIZE) >> 1, paint);
172. /*draw add button*/
173. canvas.drawBitmap(bitAdd, curX + (tabWidth - tabGap) * tabNum, 0, paint);
174. }
175. }
176. @Override
177. public boolean onTouch(View v, MotionEvent event) {
178. if (mGestureDetector.onTouchEvent(event)) {
179. return true;
180. }
181. if(event.getAction() == MotionEvent.ACTION_UP) {
182. if(isDraging ) {
183. if(dragSelectIndex != curSelect){
184. if(dragSelectIndex >= tabNum){
185. dragSelectIndex = tabNum - 1;
186. }
187. TabItem tempItem = tabLists.elementAt(curSelect);
188. tabLists.removeElementAt(curSelect);
189. tabLists.add(dragSelectIndex, tempItem);
190. }
191. float x = event.getX();
192. curSelect = (int) ((x - curX) / (tabWidth - tabGap));
193. if(curSelect >= tabNum){
194. curSelect = tabNum - 1;
195. }
196. isDraging  = false;
197. dragSelectIndex = -1;
198. dragCurrentX = 0;
199. dragSavedX = 0;
200. invalidate();
201. }
202. }
203. return false;
204. }
205. /**选项点击事件设置*/
206. public void setOnTabItemClickListener(OnTabItemClickListener click) {
207. this.clickListener = click;
208. }
209. /**选项点击事件接口*/
210. public interface OnTabItemClickListener {
211. public void onclickListenr(int index);
212. }
213. @Override
214. public boolean onDown(MotionEvent event) {
215. float x = event.getX();
216. savedClickIndex = (int) ((x - curX) / (tabWidth - tabGap));
217. if(savedClickIndex == curSelect){
218. isDraging = true;
219. dragSavedX = savedX;
220. clickListener.onclickListenr(savedClickIndex);
221. }
222. return false;
223. }
224. @Override
225. public boolean onFling(MotionEvent e1, MotionEvent e2, float velocityX,
226. float velocityY) {
227. if(isDraging ) {
228. if(dragSelectIndex != curSelect){
229. if(dragSelectIndex >= tabNum){
230. dragSelectIndex = tabNum - 1;
231. }
232. TabItem tempItem = tabLists.elementAt(curSelect);
233. tabLists.removeElementAt(curSelect);
234. tabLists.add(dragSelectIndex, tempItem);
235. }
236. float x = e2.getX();
237. curSelect = (int) ((x - curX) / (tabWidth - tabGap));
238. if(curSelect >= tabNum){
239. curSelect = tabNum - 1;
240. }
241. isDraging  = false;
242. dragSelectIndex = -1;
243. dragCurrentX = 0;
244. dragSavedX = 0;
245. invalidate();
246. }
247. return true;
248. }
249. @Override
250. public void onLongPress(MotionEvent event) {
251. }
252. @Override
253. public boolean onScroll(MotionEvent e1, MotionEvent e2,
254. float distanceX, float distanceY) {
255. int tempWidth = (tabWidth - tabGap) * tabNum + tabAddWidth;
256. if(isDraging){
257. //drag
258. int nextX = (int) (dragSavedX + e2.getX() - e1.getX());
259. dragSelectIndex = (int) ((e2.getX() - curX) / (tabWidth - tabGap));
260. dragCurrentX = nextX;
261. invalidate();
262. }else{
263. //move
264. int nextX = (int) (savedX - distanceX);
265. if(tempWidth > screenWidth && (nextX <=0  && nextX + tempWidth >= screenWidth)){
266. curX = nextX;
267. savedX = curX;
268. invalidate();
269. }
270. }
271. return false;
272. }
273. @Override
274. public void onShowPress(MotionEvent event) {
275. }
276. @Override
277. public boolean onSingleTapUp(MotionEvent event) {
278. float x = event.getX();
279. int curClickIndex = (int) ((x - curX) / (tabWidth - tabGap));
280. if(savedClickIndex == curClickIndex){
281. if(curClickIndex < tabNum){
282. setCurrentSelect(curClickIndex);
283. clickListener.onclickListenr(curClickIndex);
284. }else if(curClickIndex == tabNum){
285. tabLists.add(new TabItem());
286. tabNum++;
287. curX = screenWidth - tabAddWidth - (tabWidth - tabGap) * tabNum;
288. setCurrentSelect(tabNum - 1);
289. clickListener.onclickListenr(curClickIndex);
290. invalidate();
291. }
292. }
293. savedClickIndex = -1;
294. savedX = curX;
295. return false;
296. }
297. }

tabItem类：

1. public class TabItem{
2. public int index;
3. public String name = "New T