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

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

tabItem类：

自定义tab bar控件 学习资料