思路:

1。布局,整个控件的布局,事实上就是用代码取带xml来实现当前布局

2,能够滑动的(即滚轮)。事实上是一个ScrollView

3。推断滑动状态的,有protected void onScrollChanged(int x, int y, int oldx, int oldy) 方法,能够为我们获得当前y值(一開始y=0;随着滑动。y開始增大)

那么我们首先来完毕第一个,为了思考方便,我先用xml搭建出了控件的样子,然后我们再用代码去实现,事实证明,这种思路行云流水

以下,我们来看这个test.xml

  1. <?xml version="1.0" encoding="utf-8"?>
  2. <!-- 这个布局文件仅仅是为了思考方便的。实际上并不须要用到,真正在布局的,是在main.xml里面添加自己定义控件 -->
  3. <RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
  4. xmlns:tools="http://schemas.android.com/tools"
  5. android:layout_width="match_parent"
  6. android:layout_height="match_parent"
  7. android:paddingBottom="@dimen/activity_vertical_margin"
  8. android:paddingLeft="@dimen/activity_horizontal_margin"
  9. android:paddingRight="@dimen/activity_horizontal_margin"
  10. android:paddingTop="@dimen/activity_vertical_margin" >
  11.  
  12. <RelativeLayout
  13. android:id="@+id/relativeLayout1"
  14. android:layout_width="wrap_content"
  15. android:layout_height="wrap_content"
  16. android:background="@drawable/act_menu_bg_hover" >
  17.  
  18. <ImageView
  19. android:layout_width="match_parent"
  20. android:layout_height="100dp"
  21. android:layout_marginTop="100dp"
  22. android:background="@drawable/shoukuan_border4" />
  23.  
  24. <LinearLayout
  25. android:layout_width="fill_parent"
  26. android:layout_height="300dp"
  27. android:orientation="horizontal" >
  28.  
  29. <RelativeLayout
  30. android:layout_width="0dp"
  31. android:layout_height="wrap_content"
  32. android:layout_weight="4" >
  33.  
  34. <RelativeLayout
  35. android:layout_width="wrap_content"
  36. android:layout_height="fill_parent"
  37. android:gravity="center" >
  38.  
  39. <TextView
  40. android:id="@+id/aa"
  41. android:layout_width="wrap_content"
  42. android:layout_height="fill_parent"
  43. android:layout_alignParentRight="true"
  44. android:gravity="center_vertical"
  45. android:text="单位" />
  46.  
  47. <ScrollView
  48. android:layout_width="fill_parent"
  49. android:layout_height="300dp"
  50. android:layout_centerHorizontal="true"
  51. android:layout_toLeftOf="@id/aa"
  52. android:overScrollMode="never"
  53. android:scrollbars="none" >
  54.  
  55. <LinearLayout
  56. android:layout_width="wrap_content"
  57. android:layout_height="300dp"
  58. android:layout_gravity="center_horizontal"
  59. android:orientation="vertical" >
  60.  
  61. <!--
  62. <TextView
  63. android:layout_height="100dp"
  64. android:layout_width="wrap_content"
  65. android:textAlignment="center"
  66. android:text=""/>
  67. <TextView
  68. android:layout_height="100dp"
  69. android:layout_width="wrap_content"
  70. android:textAlignment="center"
  71. android:gravity="center_vertical"
  72. android:text="1999"/>
  73.  
  74. <TextView
  75. android:layout_width="wrap_content"
  76. android:layout_height="100dp"
  77. android:text="2000"
  78. android:gravity="center_vertical"
  79. android:textAlignment="center" />
  80.  
  81. <TextView
  82. android:layout_height="100dp"
  83. android:gravity="center_vertical"
  84. android:layout_width="wrap_content"
  85. android:text="2001"/>
  86. <TextView
  87. android:layout_height="100dp"
  88. android:gravity="center_vertical"
  89. android:layout_width="wrap_content"
  90. android:text="2002"/>
  91. <TextView
  92. android:layout_height="100dp"
  93. android:gravity="center_vertical"
  94. android:layout_width="wrap_content"
  95. android:text="2003"/>
  96. <TextView
  97. android:layout_height="100dp"
  98. android:gravity="center_vertical"
  99. android:layout_width="wrap_content"
  100. android:text="2004"/>
  101. <TextView
  102. android:layout_height="100dp"
  103. android:gravity="center_vertical"
  104. android:layout_width="wrap_content"
  105. android:text="2005"/>
  106. <TextView
  107. android:layout_height="100dp"
  108. android:gravity="center_vertical"
  109. android:layout_width="wrap_content"
  110. android:text="2006"/>
  111. <TextView
  112. android:layout_height="100dp"
  113. android:gravity="center_vertical"
  114. android:layout_width="wrap_content"
  115. android:textAlignment="center"
  116. android:text=""/>
  117. -->
  118. </LinearLayout>
  119. </ScrollView>
  120. </RelativeLayout>
  121. </RelativeLayout>
  122.  
  123. <Button
  124. android:layout_width="wrap_content"
  125. android:layout_height="wrap_content"
  126. android:layout_gravity="center_vertical"
  127. android:layout_weight="3"
  128. android:background="@drawable/btton_avtie"
  129. android:text="确定"
  130. android:textSize="30dp" />
  131. </LinearLayout>
  132. </RelativeLayout>
  133.  
  134. </RelativeLayout>

相信大家看布局文件还是看得懂的,第二个relativeLayout就是控件,我们的任务就是把这些xml写成代码(有些个别设置与xml的不同,注意属性的区别)

我决定分三个类。第一个是WheelView,来表示这个控件,也就是说它便是第二个relativeLayout

第二个类是CheckNumView,它表示第三个relativeLayout

第三个类是WheelScrollView。它表示ScrollView

显然。这个三个类的关系非常清楚,就是后一个嵌套在前一个里面

至于其它控件。比如确定button,大家看布局文件就应该能够加上

以下我从MainActivity開始说起。为了表示轮子,我建立了一个JAVABEAN,也就是Wheel类,这个类存储每一个轮子里面的数据。

  1. package com.xp.demo;
  2.  
  3. /**
  4. * 实体类 这个类存储每一个轮子里面的数据
  5. *
  6. * @author sooner
  7. *
  8. */
  9. public class Wheel {
  10. /**
  11. * 内容
  12. */
  13. private String[] texts;
  14.  
  15. /**
  16. * 焦点文字
  17. */
  18. private String focusText;
  19.  
  20. public Wheel(String[] texts) {
  21. this.texts = texts;
  22. }
  23.  
  24. public String[] getTexts() {
  25. return texts;
  26. }
  27.  
  28. public int getFocusTextPosition() {
  29. int position = 0;
  30. int count = texts.length;
  31. if (count > 0) {
  32. for (int i = 0; i < texts.length; i++) {
  33. if (texts[i].equals(focusText)) {
  34. position = i;
  35. }
  36. }
  37. if (position == 0) {
  38. position = -1;
  39. }
  40. } else {
  41. position = -1;
  42. }
  43.  
  44. return position;
  45. }
  46. }

然后是MainActivity

  1. package com.xp.demo;
  2.  
  3. import android.app.Activity;
  4. import android.os.Bundle;
  5.  
  6. public class MainActivity extends Activity {
  7. /**
  8. * 思路: 1,布局,整个控件的布局。事实上就是用代码取带xml来实现当前布局 2。能够滑动的(即滚轮)。事实上是一个ScrollView
  9. * 3,推断滑动状态的,使用: protected void onScrollChanged(int x, int y, int oldx, int
  10. * oldy) 方法
  11. */
  12. WheelView wheelView;
  13.  
  14. @Override
  15. protected void onCreate(Bundle savedInstanceState) {
  16. super.onCreate(savedInstanceState);
  17. setContentView(R.layout.main);
  18.  
  19. wheelView = (WheelView) findViewById(R.id.wheelview);
  20. String[] years = { "00", "01", "02", "03", "04", "05", "06", "07",
  21. "08", "09", "10", "11", "12", "13", "14", "15", "16", "17",
  22. "18", "19", "20", "21", "22", "23" };
  23. String[] mons = { "00", "01", "02", "03", "04", "05", "06", "07", "08",
  24. "09", "10", "11", "12", "13", "14", "15", "16", "17", "18",
  25. "19", "20", "21", "22", "23", "24", "25", "26", "27", "28",
  26. "29", "30", "31", "32", "33", "34", "35", "36", "37", "38",
  27. "39", "40", "41", "42", "43", "44", "45", "46", "47", "48",
  28. "49", "50", "51", "52", "53", "54", "55", "56", "57", "58",
  29. "59" };
  30. // 每创建一个轮子Wheel,将它添加数组,就能够动态添加轮子
  31. Wheel w1 = new Wheel(years);
  32. Wheel w2 = new Wheel(mons);
  33. Wheel[] ws = { w1, w2 };
  34. wheelView.setWheels(ws);
  35.  
  36. }
  37. }

从上面的代码看出。我的初衷就是,每创建一个轮子Wheel,将它添加数组,就能够动态添加轮子

再看main.xml

  1. <?
  2.  
  3. xml version="1.0" encoding="utf-8"?>
  4. <RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
  5. xmlns:tools="http://schemas.android.com/tools"
  6. android:layout_width="match_parent"
  7. android:layout_height="match_parent"
  8. android:paddingBottom="@dimen/activity_vertical_margin"
  9. android:paddingLeft="@dimen/activity_horizontal_margin"
  10. android:paddingRight="@dimen/activity_horizontal_margin"
  11. android:paddingTop="@dimen/activity_vertical_margin" >
  12.  
  13. <com.xp.demo.WheelView
  14. android:id="@+id/wheelview"
  15. android:layout_width="wrap_content"
  16. android:layout_height="wrap_content"
  17. android:background="@drawable/act_menu_bg_hover" />
  18.  
  19. </RelativeLayout>

注意。我们刚才的test.xml仅仅是为了我思考方便的,实际上并不须要用到。真正在布局的,是在爱activity_main.xml里面添加自己定义控件

然后是WheelView

  1. package com.xp.demo;
  2.  
  3. import java.util.Arrays;
  4.  
  5. import android.annotation.SuppressLint;
  6. import android.content.Context;
  7. import android.util.AttributeSet;
  8. import android.view.Gravity;
  9. import android.view.View;
  10. import android.widget.Button;
  11. import android.widget.ImageView;
  12. import android.widget.LinearLayout;
  13. import android.widget.RelativeLayout;
  14. import android.widget.Toast;
  15.  
  16. public class WheelView extends RelativeLayout {
  17. static int rowHeight = 100;
  18. Context context;
  19. private CheckNumView[] numberViews;
  20.  
  21. public WheelView(Context context, AttributeSet attrs) {
  22. super(context, attrs);
  23. this.context = context;
  24. }
  25.  
  26. /**
  27. * 获得结果
  28. *
  29. * @return
  30. */
  31. public String[] getResult() {
  32. String[] nums = new String[numberViews.length];
  33. for (int i = 0; i < numberViews.length; i++) {
  34. nums[i] = numberViews[i].getNumber();
  35. }
  36. return nums;
  37. }
  38.  
  39. @SuppressLint("NewApi")
  40. public void setWheels(Wheel[] wheels) {
  41. // 轮子数组
  42. numberViews = new CheckNumView[wheels.length];
  43.  
  44. // 中间蓝色的遮蔽层
  45. ImageView imageView = new ImageView(context);
  46. imageView.setBackgroundResource(R.drawable.shoukuan_border4);
  47. RelativeLayout.LayoutParams lp1 = new RelativeLayout.LayoutParams(
  48. LayoutParams.MATCH_PARENT, LayoutParams.WRAP_CONTENT);
  49. lp1.height = rowHeight;
  50. lp1.setMargins(0, rowHeight, 0, 0);
  51. imageView.setLayoutParams(lp1);
  52. addView(imageView);
  53.  
  54. // 以下就是包裹滚轮的LinearLayout
  55. LinearLayout llayout = new LinearLayout(context);
  56. LinearLayout.LayoutParams lp2 = new LinearLayout.LayoutParams(
  57. LayoutParams.MATCH_PARENT, LayoutParams.WRAP_CONTENT);
  58. lp2.height = rowHeight * 3;
  59. llayout.setOrientation(LinearLayout.HORIZONTAL);
  60. llayout.setLayoutParams(lp2);
  61.  
  62. // 将滚轮加入到LinearLayout里面
  63. int i = 0;
  64. for (Wheel wheel : wheels) {
  65. RelativeLayout rlayout = new RelativeLayout(context);
  66. LinearLayout.LayoutParams lp3 = new LinearLayout.LayoutParams(
  67. LayoutParams.WRAP_CONTENT, LayoutParams.WRAP_CONTENT);
  68. lp3.width = 0;
  69. lp3.weight = 4;
  70. numberViews[i] = new CheckNumView(context, wheel);
  71. llayout.addView(numberViews[i], lp3);
  72. i++;
  73. }
  74.  
  75. // 右边的确定button
  76. Button btn = new Button(context);
  77. btn.setText("确定");
  78. btn.setTextSize(30);
  79. btn.setBackgroundResource(R.drawable.btton_avtie);
  80. LinearLayout.LayoutParams lp4 = new LinearLayout.LayoutParams(
  81. LayoutParams.WRAP_CONTENT, LayoutParams.WRAP_CONTENT);
  82. lp4.gravity = Gravity.CENTER;
  83. lp4.weight = 3;
  84. // 点击button。弹出选中数据
  85. btn.setOnClickListener(new View.OnClickListener() {
  86.  
  87. @Override
  88. public void onClick(View v) {
  89. Toast.makeText(context, Arrays.toString(getResult()),
  90. Toast.LENGTH_SHORT).show();
  91. ;
  92. }
  93. });
  94.  
  95. llayout.addView(btn, lp4);
  96.  
  97. addView(llayout);
  98. }
  99.  
  100. }

然后是CheckNumView

事实上每一个CheckNumView就是单独一个滚轮。然而它仍然是继承RelativeLayout,而不是ScroolView,是为了更方便的调整滚轮的位置,况且,滚轮旁边另一个标志单位的TextView,显然它个滚轮(ScroolView)应该是一个总体。所以我们把ScroolView和单位TextView先包装成一个总体

  1. package com.xp.demo;
  2. import android.annotation.SuppressLint;
  3. import android.content.Context;
  4. import android.graphics.Color;
  5. import android.view.Gravity;
  6. import android.widget.RelativeLayout;
  7. import android.widget.TextView;
  8.  
  9. import com.xp.demo.WheelScrollView.OnScrollStopListener;
  10. /**
  11. * 每一个CheckNumView就是单独一个滚轮,
  12. * 然而它仍然是继承RelativeLayout,而不是ScroolView,
  13. * 是为了更方便的调整滚轮的位置,况且。滚轮旁边另一个标志单位的TextView,
  14. * 显然它个滚轮(ScroolView)应该是一个总体,
  15. * 所以我们把ScroolView和单位TextView先包装成一个总体
  16. * @author sooner
  17. *
  18. */
  19. public class CheckNumView extends RelativeLayout{
  20. WheelScrollView sc;
  21. String[] texts;
  22. private int currentY = -1000;
  23. private int position = 1;
  24. public CheckNumView(Context context) {
  25. super(context);
  26. }
  27.  
  28. @SuppressLint("NewApi")
  29. public CheckNumView(Context context, Wheel wheel) {
  30. super(context);
  31. //获取数据字符串数组
  32. texts = wheel.getTexts();
  33.  
  34. //这个RelativeLayout用于包裹滚轮
  35. RelativeLayout rlayout = new RelativeLayout(context);
  36. RelativeLayout.LayoutParams lp = new RelativeLayout.LayoutParams(
  37. LayoutParams.WRAP_CONTENT, LayoutParams.MATCH_PARENT);
  38. rlayout.setGravity(Gravity.CENTER);
  39.  
  40. //单位TextView
  41. TextView unit = new TextView(context);
  42. unit.setText("单位");
  43. unit.setId(1111);
  44. unit.setGravity(Gravity.CENTER);
  45. RelativeLayout.LayoutParams lp2 = new RelativeLayout.LayoutParams(
  46. LayoutParams.WRAP_CONTENT, LayoutParams.MATCH_PARENT);
  47. lp2.addRule(RelativeLayout.CENTER_VERTICAL,RelativeLayout.TRUE );
  48. lp2.addRule(RelativeLayout.ALIGN_PARENT_RIGHT, RelativeLayout.TRUE);
  49. rlayout.addView(unit,lp2);
  50.  
  51. //滚轮
  52. sc = new WheelScrollView(context,texts);
  53. sc.setVerticalScrollBarEnabled(false);
  54. sc.setHorizontalScrollBarEnabled(false);
  55. sc.setOverScrollMode(OVER_SCROLL_NEVER);
  56. RelativeLayout.LayoutParams lp3= new RelativeLayout.LayoutParams(
  57. LayoutParams.WRAP_CONTENT, LayoutParams.MATCH_PARENT);
  58. lp3.height = WheelView.rowHeight * 3;
  59. lp3.addRule(RelativeLayout.CENTER_HORIZONTAL,RelativeLayout.TRUE );
  60. lp3.addRule(RelativeLayout.LEFT_OF, 1111);
  61.  
  62. //这种方法,是指滚轮初始化以后的第一个位置
  63. sc.post(new Runnable() {
  64.  
  65. @Override
  66. public void run() {
  67. sc.scrollTo(0, 0*WheelView.rowHeight);
  68. }
  69. });
  70. //这种方法。设置选中位置字符串的颜色
  71. setFocusText(1);
  72.  
  73. /*
  74. * 这个是回调监听器。一旦滚轮停止滚动,就是触发
  75. * 有必要说下的是,currentY必须不断更新
  76. */
  77. sc.setOnScrollStopListener(new OnScrollStopListener(){
  78.  
  79. @Override
  80. public void onStop(int y) {
  81. if(y != currentY) {
  82. // 推断滚动误差,不到行高的一半就抹掉,超过行高的一半而不到一个行高就填满
  83. if (y % WheelView.rowHeight >= (WheelView.rowHeight / 2)) {
  84. y = y + WheelView.rowHeight - y % WheelView.rowHeight;
  85. sc.scrollTo(0, y);
  86. } else {
  87. y = y - y % WheelView.rowHeight;
  88. sc.scrollTo(0, y);
  89. }
  90. setFocusText(y / WheelView.rowHeight+1);
  91. }
  92. currentY = y;
  93. }
  94.  
  95. });
  96.  
  97. rlayout.addView(sc,lp3);
  98.  
  99. addView(rlayout,lp);
  100. }
  101. /**
  102. * 设置焦点文字风格
  103. *
  104. * @param position
  105. */
  106. private void setFocusText(int position) {
  107. if(this.position >= 0) {
  108. sc.textViews[this.position].setTextColor(Color.BLACK);
  109. }
  110. sc.textViews[position].setTextColor(Color.RED);
  111. this.position = position;
  112. }
  113.  
  114. public String getNumber() {
  115. return texts[position-1];
  116. }
  117. }

看到这里,假设有人被弄糊涂了。那么请记住我上面给出的第一个任务。实现布局。

至于这里的setOnScrollStopListener方法,我们能够临时无论它,由于它与布局的实现无关

  1. package com.xp.demo;
  2.  
  3. import android.content.Context;
  4. import android.os.Handler;
  5. import android.os.Message;
  6. import android.view.Gravity;
  7. import android.view.MotionEvent;
  8. import android.widget.LinearLayout;
  9. import android.widget.RelativeLayout;
  10. import android.widget.ScrollView;
  11. import android.widget.TextView;
  12.  
  13. public class WheelScrollView extends ScrollView implements Runnable {
  14. private String[] texts;
  15. public boolean isStop = false;
  16. private Thread t;
  17. private int y;
  18. private int curY = 0;
  19. public TextView[] textViews;
  20. /*
  21. * 使用handler是为了改动主线程ui,也就是CheckNumView里面的setFocusText()方法
  22. * 假设不须要改变ui,我大可不必使用handler。直接用一个子线程来通知listener就能够了
  23. */
  24. private Handler handler = new Handler() {
  25.  
  26. @Override
  27. public void handleMessage(Message msg) {
  28. if (isStop) {
  29. listener.onStop(curY);
  30. isStop = false;
  31. }
  32. y = -100;
  33. curY = 0;
  34. }
  35.  
  36. };
  37.  
  38. // 监听器
  39. private OnScrollStopListener listener;
  40.  
  41. public WheelScrollView(Context context, String[] texts) {
  42. super(context);
  43. this.texts = texts;
  44. // scrollview里面的textViews
  45. textViews = new TextView[texts.length + 2];
  46.  
  47. // scrollview里面LinearLayout
  48. LinearLayout llayout = new LinearLayout(context);
  49. RelativeLayout.LayoutParams lp4 = new RelativeLayout.LayoutParams(
  50. LayoutParams.WRAP_CONTENT, LayoutParams.MATCH_PARENT);
  51. lp4.height = WheelView.rowHeight * 3;
  52. lp4.addRule(RelativeLayout.CENTER_HORIZONTAL, RelativeLayout.TRUE);
  53. llayout.setOrientation(LinearLayout.VERTICAL);
  54.  
  55. /*
  56. * 以下将textViews逐一加到LinearLayout里面
  57. * 而且设置头一个空白的textViews。跟尾一个空白的textViews,这种目的是由于我们选中的项是在中间
  58. */
  59. RelativeLayout.LayoutParams lp5 = new RelativeLayout.LayoutParams(
  60. LayoutParams.WRAP_CONTENT, LayoutParams.MATCH_PARENT);
  61. lp5.height = WheelView.rowHeight;
  62. textViews[0] = new TextView(context);
  63. textViews[0].setGravity(Gravity.CENTER_VERTICAL);
  64. textViews[0].setText("");
  65. llayout.addView(textViews[0], lp5);
  66. int i = 1;
  67. for (String text : texts) {
  68. textViews[i] = new TextView(context);
  69. textViews[i].setGravity(Gravity.CENTER_VERTICAL);
  70. textViews[i].setText(text);
  71. llayout.addView(textViews[i], lp5);
  72. i++;
  73. }
  74. textViews[i] = new TextView(context);
  75. textViews[i].setGravity(Gravity.CENTER_VERTICAL);
  76. textViews[i].setText("");
  77. llayout.addView(textViews[i], lp5);
  78.  
  79. // 将LinearLayout增加ScrollView
  80. addView(llayout, lp4);
  81. }
  82.  
  83. // 滚动时自己主动调用该函数,获取y值
  84. @Override
  85. protected void onScrollChanged(int x, int y, int oldx, int oldy) {
  86. super.onScrollChanged(x, y, oldx, oldy);
  87. this.y = y < 0 ? 0 : y;
  88. }
  89.  
  90. // 回调接口
  91. public static interface OnScrollStopListener {
  92. public void onStop(int y);
  93. }
  94.  
  95. public void setOnScrollStopListener(OnScrollStopListener listener) {
  96. this.listener = listener;
  97. }
  98.  
  99. // 降低滚动的速度
  100. @Override
  101. public void fling(int velocityY) {
  102. super.fling(velocityY / 3);
  103. }
  104.  
  105. // 这里是推断滚动触发開始,与滚动触发停止的
  106. @Override
  107. public boolean onTouchEvent(MotionEvent ev) {
  108. if (ev.getAction() == MotionEvent.ACTION_UP) {
  109. isStop = true;
  110. if (t == null) {
  111. t = new Thread(this);
  112. t.start();
  113. } else if (!t.isAlive()) {
  114. t = new Thread(this);
  115. t.start();
  116. }
  117. } else if (ev.getAction() == MotionEvent.ACTION_DOWN) {
  118. isStop = false;
  119. }
  120. return super.onTouchEvent(ev);
  121. }
  122.  
  123. // 假设通知滚动。新线程将使用handler请求改动ui。而且调用回调函数,式选项在正确的位置上
  124. @Override
  125. public void run() {
  126. while (isStop) {
  127. try {
  128. if (curY == y) {
  129. handler.sendEmptyMessage(0);
  130. } else {
  131. curY = y;
  132. }
  133. Thread.sleep(60);
  134. } catch (InterruptedException e) {
  135. e.printStackTrace();
  136. }
  137. }
  138. }
  139. }

相同,假设这都代码看不懂,你能够先忽略一些与布局无关的东西(除了构造函数,基本其它函数都与布局无关)。

忽略这些代码以后。我相信已经能够画出这个控件,而且能够拖动了

以下的问题就是我们希望拖到两个选项中间,脱手时,会自己主动对准某一个近期的选项

这是我们就须要用到其它的代码了。

思路是使用onTouchEvent(MotionEvent ev)来推断滑动開始与结束

一点滑动结束,我们就要拿到当前的y值。然后通过一个线程,调用handler去通知CheckNumView里面的OnScrollStopListener,最后我们在onstop()函数里面。处理这个y值

一个疑问是为什么获得y值以后,要通过线程调用handler。理由是防止再次TouchEvent影响前一次TouchEvent的结果

第二个疑问是,为什么要记录curY,由于仅仅有curY==y,我们才干确定滑动停止了

OK,几个由于攻克了,相信大家看着我的代码。应该豁然开朗了。

參考博客:http://blog.csdn.net/crazy__chen/article/details/41958677

參考源代码:http://download.csdn.net/detail/u010963246/8922921

源代码下载:http://download.csdn.net/detail/u010963246/8922911

Android滚轮选择器实现的更多相关文章

  1. Android文件选择器的实例分享

    本文给大家讲解下Android文件选择器的使用.实际上就是获取用户在SD卡中选择的文件或文件夹的路径,这很像C#中的OpenFileDialog控件. 此实例的实现过程很简单,这样可以让大家快速的熟悉 ...

  2. vue 2 仿IOS 滚轮选择器 从入门到精通 (一)

    大家好,由于最近从事的是微信公众号和APP内嵌 H5开发,避免不了开发一些和native相同的操作功能,就如接下来说的 仿IOS滚轮选择器. 先来个截图: 接下来具体介绍如何实现的.能力有限避免不了错 ...

  3. 【原创】Android selector选择器无效或无法正常显示的一点研究

    想将LinearLayout作为一个按钮,加上一个动态背景,按下的时候,背景变色,这个理所当然应该使用selector背景选择器来做: <LinearLayout android:id=&quo ...

  4. android背景选择器selector用法汇总

    一.创建xml文件,位置:drawable/xxx.xml,同目录下记得要放相关图片 <?xml version="1.0" encoding="utf-8&quo ...

  5. Android selector选择器的使用

    通常按钮在点击前和后有两种状态,比如点击前为蓝色,点击后为灰色,且不再响应点击事件. 如果不使用selector选择器,点击后,就需要在程序中进行以下的类似操作 button1.setBackgrou ...

  6. Android图片选择器--仿QQ

    当做一款APP,需要选择本地图片时,首先考虑的无疑是系统相册,但是Android手机五花八门,再者手机像素的提升,大图无法返回等异常因数,导致适配机型比较困难,微信.QQ都相继的在自己的APP里集成了 ...

  7. 自定义实现简单的Android颜色选择器(附带源码)

    在写Android App过程中需要一个简单的颜色选择器,Android自带的ColorPicker和网上的一些ColorPicker都太高端了,都实现了颜色渐变功能,我要的不需要那么复杂,只想提供几 ...

  8. Android 图片选择器

    图片选择器,遍历系统所有图片并显示,点击查看大图,长按选中,并将结果返回 字体颜色res/color建立text_selecor.xml <selector xmlns:android=&quo ...

  9. android select选择器 checkbox改外观,button按下状态

    android 可以用选择器.来加载视图.选择器里的选项也很多针对实际使用中用的几个进行描述. 1.button 的按下弹起改外观.选择器属性用 android:state_pressed   2.C ...

随机推荐

  1. Weka中数据挖掘与机器学习系列之Weka3.7和3.9不同版本共存(七)

    不多说,直接上干货! 为什么,我要写此博客,原因是(以下,我是weka3.7.8) 以下是,weka3.7.8的安装版本. Weka中数据挖掘与机器学习系列之Weka系统安装(四) 基于此,我安装最新 ...

  2. Codefroces432 div2 A,B,C

    A. Arpa and a research in Mexican wave Arpa is researching the Mexican wave. There are n spectators ...

  3. Swift学习笔记(14)--方法

    1.分类 方法分为实例方法和类型方法 实例方法(Instance Methods):与java中的类似,略 类型方法(Type Methods):与java.oc中的类方法类似.声明类的类型方法,在方 ...

  4. 【Uva 1629】 Cake slicing

    [Link]: [Description] 给你一个n*m的格子; 然后里面零零散散地放着葡萄 让你把它切成若干个小矩形方格 使得每个小矩形方格都恰好包含有一个葡萄. 要求切的长度最短; 问最短的切割 ...

  5. jmind-redis一个redis的nio客户端

    Redis是一个基于key/value的系统.Redis目前最新版本是2.2.4,用着很不错,不过java版本的客户端比较的不给力,目前redis 客户端jedis 是基于io 的socket . 而 ...

  6. Cocos2D实现RPG队伍菜单随意调整角色顺序的效果

    大熊猫猪·侯佩原创或翻译作品.欢迎转载,转载请注明出处. 假设认为写的不好请多提意见,假设认为不错请多多支持点赞.谢谢! hopy ;) 前一篇我们实现了队伍实现拖尾效果,可是在实际游戏中我们往往须要 ...

  7. ORA-00922: 选项缺失或无效

    1.错误描写叙述 SQL> create table info_stu from select t.stu_id,t.stu_name,t.stu_age from info t; create ...

  8. QT就是别人好心帮你做一些枯燥,并且很重复的代码编写工作,让你更好的把精力投入到你界面的逻辑和功能的实现的功能库(否则写了上万行代码了,才写出个BUG一大堆的毛坯)

    好了,现在开始记录我学习QT的学习历程 . 本人也不是计算机专业出来的,自学了一点,但还是不好找工作,于是参加了培训,虽然感觉没多学到什么 编程的学习生涯就是不断的看别人的源码,然后自己参考着写写自己 ...

  9. java 链接server上的 mongodb 出现 connect time out 问题

    异常信息 十二月 22, 2014 5:27:58 下午 com.mongodb.DBTCPConnector initDirectConnection 警告: Exception executing ...

  10. PopupMenu-使用实例跟监听事件

    今天需要给一个控件添加弹出菜单功能.就顺便学习了下popupMenu的使用,记录下来. 它的使用其实也非常的简单,看如下代码 popupMenu = new PopupMenu(MainActivit ...