1. 下面看看我们如何使用它，达到我们想要的效果
  2. public class MainActivity extends Activity {
  3. /**
  4. * 双向滑动菜单布局
  5. */
  6. private SliderMenu SliderMenu;
  7. /**
  8. * 在内容布局上显示的ListView
  9. */
  10. private ListView contentList;
  11. /**
  12. * ListView的适配器
  13. */
  14. private ArrayAdapter<String> contentListAdapter;
  15. /**
  16. * 用于填充contentListAdapter的数据源。
  17. */
  18. private String[] contentItems = { "Content Item 1", "Content Item 2", "Content Item 3",
  19. "Content Item 4", "Content Item 5", "Content Item 6", "Content Item 7",
  20. "Content Item 8", "Content Item 9", "Content Item 10", "Content Item 11",
  21. "Content Item 12", "Content Item 13", "Content Item 14", "Content Item 15",
  22. "Content Item 16" };
  23. @Override
  24. protected void onCreate(Bundle savedInstanceState) {
  25. super.onCreate(savedInstanceState);
  26. setContentView(R.layout.main);
  27. SliderMenu = (SliderMenu) findViewById(R.id.bidir_sliding_layout);
  28. contentList = (ListView) findViewById(R.id.contentList);
  29. contentListAdapter = new ArrayAdapter<String>(this, android.R.layout.simple_list_item_1,
  30. contentItems);
  31. contentList.setAdapter(contentListAdapter);
  32. SliderMenu.setScrollEvent(contentList);
  33. }
  34. }
  1. 这个类就是实现双向滑动菜单功能的核心类
  2. public class SliderMenu extends RelativeLayout implements OnTouchListener {
  3. /**
  4. * 滚动显示和隐藏左侧布局时，手指滑动需要达到的速度。
  5. */
  6. public static final int SNAP_VELOCITY = 200;
  7. /**
  8. * 滑动状态的一种，表示未进行任何滑动。
  9. */
  10. public static final int DO_NOTHING = 0;
  11. /**
  12. * 滑动状态的一种，表示正在滑出左侧菜单。
  13. */
  14. public static final int SHOW_LEFT_MENU = 1;
  15. /**
  16. * 滑动状态的一种，表示正在滑出右侧菜单。
  17. */
  18. public static final int SHOW_RIGHT_MENU = 2;
  19. /**
  20. * 滑动状态的一种，表示正在隐藏左侧菜单。
  21. */
  22. public static final int HIDE_LEFT_MENU = 3;
  23. /**
  24. * 滑动状态的一种，表示正在隐藏右侧菜单。
  25. */
  26. public static final int HIDE_RIGHT_MENU = 4;
  27. /**
  28. * 记录当前的滑动状态
  29. */
  30. private int slideState;
  31. /**
  32. * 屏幕宽度值。
  33. */
  34. private int screenWidth;
  35. /**
  36. * 在被判定为滚动之前用户手指可以移动的最大值。
  37. */
  38. private int touchSlop;
  39. /**
  40. * 记录手指按下时的横坐标。
  41. */
  42. private float xDown;
  43. /**
  44. * 记录手指按下时的纵坐标。
  45. */
  46. private float yDown;
  47. /**
  48. * 记录手指移动时的横坐标。
  49. */
  50. private float xMove;
  51. /**
  52. * 记录手指移动时的纵坐标。
  53. */
  54. private float yMove;
  55. /**
  56. * 记录手机抬起时的横坐标。
  57. */
  58. private float xUp;
  59. /**
  60. * 左侧菜单当前是显示还是隐藏。只有完全显示或隐藏时才会更改此值，滑动过程中此值无效。
  61. */
  62. private boolean isLeftMenuVisible;
  63. /**
  64. * 右侧菜单当前是显示还是隐藏。只有完全显示或隐藏时才会更改此值，滑动过程中此值无效。
  65. */
  66. private boolean isRightMenuVisible;
  67. /**
  68. * 是否正在滑动。
  69. */
  70. private boolean isSliding;
  71. /**
  72. * 左侧菜单布局对象。
  73. */
  74. private View leftMenuLayout;
  75. /**
  76. * 右侧菜单布局对象。
  77. */
  78. private View rightMenuLayout;
  79. /**
  80. * 内容布局对象。
  81. */
  82. private View contentLayout;
  83. /**
  84. * 用于监听滑动事件的View。
  85. */
  86. private View mBindView;
  87. /**
  88. * 左侧菜单布局的参数。
  89. */
  90. private MarginLayoutParams leftMenuLayoutParams;
  91. /**
  92. * 右侧菜单布局的参数。
  93. */
  94. private MarginLayoutParams rightMenuLayoutParams;
  95. /**
  96. * 内容布局的参数。
  97. */
  98. private RelativeLayout.LayoutParams contentLayoutParams;
  99. /**
  100. * 用于计算手指滑动的速度。
  101. */
  102. private VelocityTracker mVelocityTracker;
  103. /**
  104. * 重写BidirSlidingLayout的构造函数，其中获取了屏幕的宽度和touchSlop的值。
  105. *
  106. * @param context
  107. * @param attrs
  108. */
  109. public SliderMenu(Context context, AttributeSet attrs) {
  110. super(context, attrs);
  111. WindowManager wm = (WindowManager) context.getSystemService(Context.WINDOW_SERVICE);
  112. screenWidth = wm.getDefaultDisplay().getWidth();
  113. touchSlop = ViewConfiguration.get(context).getScaledTouchSlop();
  114. }
  115. /**
  116. * 绑定监听滑动事件的View。
  117. *
  118. * @param bindView
  119. *            需要绑定的View对象。
  120. */
  121. public void setScrollEvent(View bindView) {
  122. mBindView = bindView;
  123. mBindView.setOnTouchListener(this);
  124. }
  125. /**
  126. * 将界面滚动到左侧菜单界面，滚动速度设定为-30.
  127. */
  128. public void scrollToLeftMenu() {
  129. new LeftMenuScrollTask().execute(-50);
  130. }
  131. /**
  132. * 将界面滚动到右侧菜单界面，滚动速度设定为-30.
  133. */
  134. public void scrollToRightMenu() {
  135. new RightMenuScrollTask().execute(-50);
  136. }
  137. /**
  138. * 将界面从左侧菜单滚动到内容界面，滚动速度设定为30.
  139. */
  140. public void scrollToContentFromLeftMenu() {
  141. new LeftMenuScrollTask().execute(50);
  142. }
  143. /**
  144. * 将界面从右侧菜单滚动到内容界面，滚动速度设定为30.
  145. */
  146. public void scrollToContentFromRightMenu() {
  147. new RightMenuScrollTask().execute(50);
  148. }
  149. /**
  150. * 左侧菜单是否完全显示出来，滑动过程中此值无效。
  151. *
  152. * @return 左侧菜单完全显示返回true，否则返回false。
  153. */
  154. public boolean isLeftLayoutVisible() {
  155. return isLeftMenuVisible;
  156. }
  157. /**
  158. * 右侧菜单是否完全显示出来，滑动过程中此值无效。
  159. *
  160. * @return 右侧菜单完全显示返回true，否则返回false。
  161. */
  162. public boolean isRightLayoutVisible() {
  163. return isRightMenuVisible;
  164. }
  165. /**
  166. * 在onLayout中重新设定左侧菜单、右侧菜单、以及内容布局的参数。
  167. */
  168. @Override
  169. protected void onLayout(boolean changed, int l, int t, int r, int b) {
  170. super.onLayout(changed, l, t, r, b);
  171. if (changed) {
  172. // 获取左侧菜单布局对象
  173. leftMenuLayout = getChildAt(0);
  174. leftMenuLayoutParams = (MarginLayoutParams) leftMenuLayout.getLayoutParams();
  175. // 获取右侧菜单布局对象
  176. rightMenuLayout = getChildAt(1);
  177. rightMenuLayoutParams = (MarginLayoutParams) rightMenuLayout.getLayoutParams();
  178. // 获取内容布局对象
  179. contentLayout = getChildAt(2);
  180. contentLayoutParams = (RelativeLayout.LayoutParams) contentLayout.getLayoutParams();
  181. contentLayoutParams.width = screenWidth;
  182. contentLayout.setLayoutParams(contentLayoutParams);
  183. }
  184. }
  185. @Override
  186. public boolean onTouch(View v, MotionEvent event) {
  187. createVelocityTracker(event);
  188. switch (event.getAction()) {
  189. case MotionEvent.ACTION_DOWN:
  190. // 手指按下时，记录按下时的坐标
  191. xDown = event.getRawX();
  192. yDown = event.getRawY();
  193. // 将滑动状态初始化为DO_NOTHING
  194. slideState = DO_NOTHING;
  195. break;
  196. case MotionEvent.ACTION_MOVE:
  197. xMove = event.getRawX();
  198. yMove = event.getRawY();
  199. // 手指移动时，对比按下时的坐标，计算出移动的距离。
  200. int moveDistanceX = (int) (xMove - xDown);
  201. int moveDistanceY = (int) (yMove - yDown);
  202. // 检查当前的滑动状态
  203. checkSlideState(moveDistanceX, moveDistanceY);
  204. // 根据当前滑动状态决定如何偏移内容布局
  205. switch (slideState) {
  206. case SHOW_LEFT_MENU:
  207. contentLayoutParams.rightMargin = -moveDistanceX;
  208. checkLeftMenuBorder();
  209. contentLayout.setLayoutParams(contentLayoutParams);
  210. break;
  211. case HIDE_LEFT_MENU:
  212. contentLayoutParams.rightMargin = -leftMenuLayoutParams.width - moveDistanceX;
  213. checkLeftMenuBorder();
  214. contentLayout.setLayoutParams(contentLayoutParams);
  215. case SHOW_RIGHT_MENU:
  216. contentLayoutParams.leftMargin = moveDistanceX;
  217. checkRightMenuBorder();
  218. contentLayout.setLayoutParams(contentLayoutParams);
  219. break;
  220. case HIDE_RIGHT_MENU:
  221. contentLayoutParams.leftMargin = -rightMenuLayoutParams.width + moveDistanceX;
  222. checkRightMenuBorder();
  223. contentLayout.setLayoutParams(contentLayoutParams);
  224. default:
  225. break;
  226. }
  227. break;
  228. case MotionEvent.ACTION_UP:
  229. xUp = event.getRawX();
  230. int upDistanceX = (int) (xUp - xDown);
  231. if (isSliding) {
  232. // 手指抬起时，进行判断当前手势的意图
  233. switch (slideState) {
  234. case SHOW_LEFT_MENU:
  235. if (shouldScrollToLeftMenu()) {
  236. scrollToLeftMenu();
  237. } else {
  238. scrollToContentFromLeftMenu();
  239. }
  240. break;
  241. case HIDE_LEFT_MENU:
  242. if (shouldScrollToContentFromLeftMenu()) {
  243. scrollToContentFromLeftMenu();
  244. } else {
  245. scrollToLeftMenu();
  246. }
  247. break;
  248. case SHOW_RIGHT_MENU:
  249. if (shouldScrollToRightMenu()) {
  250. scrollToRightMenu();
  251. } else {
  252. scrollToContentFromRightMenu();
  253. }
  254. break;
  255. case HIDE_RIGHT_MENU:
  256. if (shouldScrollToContentFromRightMenu()) {
  257. scrollToContentFromRightMenu();
  258. } else {
  259. scrollToRightMenu();
  260. }
  261. break;
  262. default:
  263. break;
  264. }
  265. } else if (upDistanceX < touchSlop && isLeftMenuVisible) {
  266. // 当左侧菜单显示时，如果用户点击一下内容部分，则直接滚动到内容界面
  267. scrollToContentFromLeftMenu();
  268. } else if (upDistanceX < touchSlop && isRightMenuVisible) {
  269. // 当右侧菜单显示时，如果用户点击一下内容部分，则直接滚动到内容界面
  270. scrollToContentFromRightMenu();
  271. }
  272. recycleVelocityTracker();
  273. break;
  274. }
  275. if (v.isEnabled()) {
  276. if (isSliding) {
  277. // 正在滑动时让控件得不到焦点
  278. unFocusBindView();
  279. return true;
  280. }
  281. if (isLeftMenuVisible || isRightMenuVisible) {
  282. // 当左侧或右侧布局显示时，将绑定控件的事件屏蔽掉
  283. return true;
  284. }
  285. return false;
  286. }
  287. return true;
  288. }
  289. /**
  290. * 根据手指移动的距离，判断当前用户的滑动意图，然后给slideState赋值成相应的滑动状态值。
  291. *
  292. * @param moveDistanceX
  293. *            横向移动的距离
  294. * @param moveDistanceY
  295. *            纵向移动的距离
  296. */
  297. private void checkSlideState(int moveDistanceX, int moveDistanceY) {
  298. if (isLeftMenuVisible) {
  299. if (!isSliding && Math.abs(moveDistanceX) >= touchSlop && moveDistanceX < 0) {
  300. isSliding = true;
  301. slideState = HIDE_LEFT_MENU;
  302. }
  303. } else if (isRightMenuVisible) {
  304. if (!isSliding && Math.abs(moveDistanceX) >= touchSlop && moveDistanceX > 0) {
  305. isSliding = true;
  306. slideState = HIDE_RIGHT_MENU;
  307. }
  308. } else {
  309. if (!isSliding && Math.abs(moveDistanceX) >= touchSlop && moveDistanceX > 0
  310. && Math.abs(moveDistanceY) < touchSlop) {
  311. isSliding = true;
  312. slideState = SHOW_LEFT_MENU;
  313. contentLayoutParams.addRule(RelativeLayout.ALIGN_PARENT_LEFT, 0);
  314. contentLayoutParams.addRule(RelativeLayout.ALIGN_PARENT_RIGHT);
  315. contentLayout.setLayoutParams(contentLayoutParams);
  316. // 如果用户想要滑动左侧菜单，将左侧菜单显示，右侧菜单隐藏
  317. leftMenuLayout.setVisibility(View.VISIBLE);
  318. rightMenuLayout.setVisibility(View.GONE);
  319. } else if (!isSliding && Math.abs(moveDistanceX) >= touchSlop && moveDistanceX < 0
  320. && Math.abs(moveDistanceY) < touchSlop) {
  321. isSliding = true;
  322. slideState = SHOW_RIGHT_MENU;
  323. contentLayoutParams.addRule(RelativeLayout.ALIGN_PARENT_RIGHT, 0);
  324. contentLayoutParams.addRule(RelativeLayout.ALIGN_PARENT_LEFT);
  325. contentLayout.setLayoutParams(contentLayoutParams);
  326. // 如果用户想要滑动右侧菜单，将右侧菜单显示，左侧菜单隐藏
  327. rightMenuLayout.setVisibility(View.VISIBLE);
  328. leftMenuLayout.setVisibility(View.GONE);
  329. }
  330. }
  331. }
  332. /**
  333. * 在滑动过程中检查左侧菜单的边界值，防止绑定布局滑出屏幕。
  334. */
  335. private void checkLeftMenuBorder() {
  336. if (contentLayoutParams.rightMargin > 0) {
  337. contentLayoutParams.rightMargin = 0;
  338. } else if (contentLayoutParams.rightMargin < -leftMenuLayoutParams.width) {
  339. contentLayoutParams.rightMargin = -leftMenuLayoutParams.width;
  340. }
  341. }
  342. /**
  343. * 在滑动过程中检查右侧菜单的边界值，防止绑定布局滑出屏幕。
  344. */
  345. private void checkRightMenuBorder() {
  346. if (contentLayoutParams.leftMargin > 0) {
  347. contentLayoutParams.leftMargin = 0;
  348. } else if (contentLayoutParams.leftMargin < -rightMenuLayoutParams.width) {
  349. contentLayoutParams.leftMargin = -rightMenuLayoutParams.width;
  350. }
  351. }
  352. /**
  353. * 判断是否应该滚动将左侧菜单展示出来。如果手指移动距离大于左侧菜单宽度的1/2，或者手指移动速度大于SNAP_VELOCITY，
  354. * 就认为应该滚动将左侧菜单展示出来。
  355. *
  356. * @return 如果应该将左侧菜单展示出来返回true，否则返回false。
  357. */
  358. private boolean shouldScrollToLeftMenu() {
  359. return xUp - xDown > leftMenuLayoutParams.width / 2 || getScrollVelocity() > SNAP_VELOCITY;
  360. }
  361. /**
  362. * 判断是否应该滚动将右侧菜单展示出来。如果手指移动距离大于右侧菜单宽度的1/2，或者手指移动速度大于SNAP_VELOCITY，
  363. * 就认为应该滚动将右侧菜单展示出来。
  364. *
  365. * @return 如果应该将右侧菜单展示出来返回true，否则返回false。
  366. */
  367. private boolean shouldScrollToRightMenu() {
  368. return xDown - xUp > rightMenuLayoutParams.width / 2 || getScrollVelocity() > SNAP_VELOCITY;
  369. }
  370. /**
  371. * 判断是否应该从左侧菜单滚动到内容布局，如果手指移动距离大于左侧菜单宽度的1/2，或者手指移动速度大于SNAP_VELOCITY，
  372. * 就认为应该从左侧菜单滚动到内容布局。
  373. *
  374. * @return 如果应该从左侧菜单滚动到内容布局返回true，否则返回false。
  375. */
  376. private boolean shouldScrollToContentFromLeftMenu() {
  377. return xDown - xUp > leftMenuLayoutParams.width / 2 || getScrollVelocity() > SNAP_VELOCITY;
  378. }
  379. /**
  380. * 判断是否应该从右侧菜单滚动到内容布局，如果手指移动距离大于右侧菜单宽度的1/2，或者手指移动速度大于SNAP_VELOCITY，
  381. * 就认为应该从右侧菜单滚动到内容布局。
  382. *
  383. * @return 如果应该从右侧菜单滚动到内容布局返回true，否则返回false。
  384. */
  385. private boolean shouldScrollToContentFromRightMenu() {
  386. return xUp - xDown > rightMenuLayoutParams.width / 2 || getScrollVelocity() > SNAP_VELOCITY;
  387. }
  388. /**
  389. * 创建VelocityTracker对象，并将触摸事件加入到VelocityTracker当中。
  390. *
  391. * @param event
  392. *            右侧布局监听控件的滑动事件
  393. */
  394. private void createVelocityTracker(MotionEvent event) {
  395. if (mVelocityTracker == null) {
  396. mVelocityTracker = VelocityTracker.obtain();
  397. }
  398. mVelocityTracker.addMovement(event);
  399. }
  400. /**
  401. * 获取手指在绑定布局上的滑动速度。
  402. *
  403. * @return 滑动速度，以每秒钟移动了多少像素值为单位。
  404. */
  405. private int getScrollVelocity() {
  406. mVelocityTracker.computeCurrentVelocity(1000);
  407. int velocity = (int) mVelocityTracker.getXVelocity();
  408. return Math.abs(velocity);
  409. }
  410. /**
  411. * 回收VelocityTracker对象。
  412. */
  413. private void recycleVelocityTracker() {
  414. mVelocityTracker.recycle();
  415. mVelocityTracker = null;
  416. }
  417. /**
  418. * 使用可以获得焦点的控件在滑动的时候失去焦点。
  419. */
  420. private void unFocusBindView() {
  421. if (mBindView != null) {
  422. mBindView.setPressed(false);
  423. mBindView.setFocusable(false);
  424. mBindView.setFocusableInTouchMode(false);
  425. }
  426. }
  427. class LeftMenuScrollTask extends AsyncTask<Integer, Integer, Integer> {
  428. @Override
  429. protected Integer doInBackground(Integer... speed) {
  430. int rightMargin = contentLayoutParams.rightMargin;
  431. // 根据传入的速度来滚动界面，当滚动到达边界值时，跳出循环。
  432. while (true) {
  433. rightMargin = rightMargin + speed[0];
  434. if (rightMargin < -leftMenuLayoutParams.width) {
  435. rightMargin = -leftMenuLayoutParams.width;
  436. break;
  437. }
  438. if (rightMargin > 0) {
  439. rightMargin = 0;
  440. break;
  441. }
  442. publishProgress(rightMargin);
  443. // 为了要有滚动效果产生，每次循环使线程睡眠一段时间，这样肉眼才能够看到滚动动画。
  444. sleep(15);
  445. }
  446. if (speed[0] > 0) {
  447. isLeftMenuVisible = false;
  448. } else {
  449. isLeftMenuVisible = true;
  450. }
  451. isSliding = false;
  452. return rightMargin;
  453. }
  454. @Override
  455. protected void onProgressUpdate(Integer... rightMargin) {
  456. contentLayoutParams.rightMargin = rightMargin[0];
  457. contentLayout.setLayoutParams(contentLayoutParams);
  458. unFocusBindView();
  459. }
  460. @Override
  461. protected void onPostExecute(Integer rightMargin) {
  462. contentLayoutParams.rightMargin = rightMargin;
  463. contentLayout.setLayoutParams(contentLayoutParams);
  464. }
  465. }
  466. class RightMenuScrollTask extends AsyncTask<Integer, Integer, Integer> {
  467. @Override
  468. protected Integer doInBackground(Integer... speed) {
  469. int leftMargin = contentLayoutParams.leftMargin;
  470. // 根据传入的速度来滚动界面，当滚动到达边界值时，跳出循环。
  471. while (true) {
  472. leftMargin = leftMargin + speed[0];
  473. if (leftMargin < -rightMenuLayoutParams.width) {
  474. leftMargin = -rightMenuLayoutParams.width;
  475. break;
  476. }
  477. if (leftMargin > 0) {
  478. leftMargin = 0;
  479. break;
  480. }
  481. publishProgress(leftMargin);
  482. // 为了要有滚动效果产生，每次循环使线程睡眠一段时间，这样肉眼才能够看到滚动动画。
  483. sleep(15);
  484. }
  485. if (speed[0] > 0) {
  486. isRightMenuVisible = false;
  487. } else {
  488. isRightMenuVisible = true;
  489. }
  490. isSliding = false;
  491. return leftMargin;
  492. }
  493. @Override
  494. protected void onProgressUpdate(Integer... leftMargin) {
  495. contentLayoutParams.leftMargin = leftMargin[0];
  496. contentLayout.setLayoutParams(contentLayoutParams);
  497. unFocusBindView();
  498. }
  499. @Override
  500. protected void onPostExecute(Integer leftMargin) {
  501. contentLayoutParams.leftMargin = leftMargin;
  502. contentLayout.setLayoutParams(contentLayoutParams);
  503. }
  504. }
  505. /**
  506. * 使当前线程睡眠指定的毫秒数。
  507. *
  508. * @param millis
  509. *            指定当前线程睡眠多久，以毫秒为单位
  510. */
  511. private void sleep(long millis) {
  512. try {
  513. Thread.sleep(millis);
  514. } catch (InterruptedException e) {
  515. e.printStackTrace();
  516. }
  517. }
  518. }
  519. 复制代码
  520. 1
  521. 2
  522. 3
  523. 4
  524. 5
  525. 6
  526. 7
  527. 8
  528. 9
  529. 10
  530. 11
  531. 12
  532. 13
  533. 14
  534. 15
  535. 16
  536. 17
  537. 18
  538. 19
  539. 20
  540. 21
  541. 22
  542. 23
  543. 24
  544. 25
  545. 26
  546. 27
  547. 28
  548. 29
  549. 30
  550. 31
  551. 32
  552. 33
  553. 34
  554. 35
  555. 36
  556. 37
  557. 38
  558. 39
  559. 40
  560. 41
  561. 42
  562. 43
  563. 44
  564. 45
  565. 46
  566. 47
  567. 48
  568. 49
  569. 50
  570. 51
  571. 52
  572. 53
  573. 54
  574. 55
  575. 56
  576. 57
  577. <com.example.slidermenu.SliderMenu
  578. xmlns:android="http://schemas.android.com/apk/res/android"
  579. xmlns:tools="http://schemas.android.com/tools"
  580. android:id="@+id/bidir_sliding_layout"
  581. android:layout_width="fill_parent"
  582. android:layout_height="fill_parent" >
  583. <RelativeLayout
  584. android:id="@+id/left_menu"
  585. android:layout_width="270dip"
  586. android:layout_height="fill_parent"
  587. android:layout_alignParentLeft="true"
  588. android:background="#00ccff"
  589. android:visibility="invisible" >
  590. <TextView
  591. android:layout_width="wrap_content"
  592. android:layout_height="wrap_content"
  593. android:layout_centerInParent="true"
  594. android:text="This is left menu"
  595. android:textColor="#000000"
  596. android:textSize="28sp" />
  597. </RelativeLayout>
  598. <RelativeLayout
  599. android:id="@+id/right_menu"
  600. android:layout_width="270dip"
  601. android:layout_height="fill_parent"
  602. android:layout_alignParentRight="true"
  603. android:background="#00ffcc"
  604. android:visibility="invisible" >
  605. <TextView
  606. android:layout_width="wrap_content"
  607. android:layout_height="wrap_content"
  608. android:layout_centerInParent="true"
  609. android:text="This is right menu"
  610. android:textColor="#000000"
  611. android:textSize="28sp" />
  612. </RelativeLayout>
  613. <LinearLayout
  614. android:id="@+id/content"
  615. android:layout_width="320dip"
  616. android:layout_height="fill_parent"
  617. android:background="#e9e9e9" >
  618. <ListView
  619. android:id="@+id/contentList"
  620. android:layout_width="fill_parent"
  621. android:layout_height="fill_parent"
  622. android:scrollbars="none"
  623. android:cacheColorHint="#00000000" >
  624. </ListView>
  625. </LinearLayout>
  626. </com.example.slidermenu.SliderMenu>

可以看到，我们使用了自定义的SliderMenu作为根布局，然后依次加入了三个子布局分别作为左侧菜单、右侧菜单和内容的布局。左侧菜单和右侧菜单中都只是简单地放入了一个TextView用于显示一段文字，内容布局中放入了一个ListView。注意要让左侧菜单和父布局左边缘对齐，右侧菜单和父布局右边缘对齐。

超酷的Android 侧滑(双向滑动菜单)效果的更多相关文章

  1. Android 侧滑(双向滑动菜单)效果

    下面看看我们如何使用它,达到我们想要的效果 public class MainActivity extends Activity { /** * 双向滑动菜单布局 */ private SliderM ...

  2. Android双向滑动菜单完全解析，教你如何一分钟实现双向滑动特效

    转载请注明出处:http://blog.csdn.net/guolin_blog/article/details/9671609 记得在很早之前,我写了一篇关于Android滑动菜单的文章,其中有一个 ...

  3. 【转】Android双向滑动菜单完全解析，教你如何一分钟实现双向滑动特效

    转载请注明出处:http://blog.csdn.net/guolin_blog/article/details/9671609 记得在很早之前,我写了一篇关于Android滑动菜单的文章,其中有一个 ...

  4. 【超酷超实用】CSS3可滑动跳转的分页插件制作教程

    原文:[超酷超实用]CSS3可滑动跳转的分页插件制作教程 今天我要向大家分享一款很特别的CSS3分页插件,这款分页插件不仅可以点击分页按钮来实现分页,而且可以滑动滑杆来实现任意页面的跳转,看看都非常酷 ...

  5. Android实现左右滑动指引效果

    本文介绍Android中实现左右滑动的指引效果. 关于左右滑动效果,我在以前的一篇博文中提到过,有兴趣的朋友可以查看:http://www.cnblogs.com/hanyonglu/archive/ ...

  6. Android之 左右滑动菜单

    近来学习了极客学院有关于界面左右滑动的视频,就在这里写个博客,巩固一下知识点,以免忘了. 这里主要介绍界面是如何左右滑动的: 1.首先我们应该设置好将要滑动的三个界面,即leftMenu.middle ...

  7. android实现左右滑动菜单

    直接看效果图:       主要实现代码: package com.way.view; import android.content.Context; import android.media.Den ...

  8. 12种超酷HTML5 SVG和CSS3浮动标签效果

    这是一组效果很炫酷的SVG和CSS3表单浮动标签特效.这组浮动标签特效共12种效果,这些浮动标签效果部分在元素的伪元素上使用CSS transitions和CSS animations完毕,一部分则使 ...

  9. ViewPager+Fragment 滑动菜单效果 实现步骤

    1.xml中引用ViewPager     <android.support.v4.view.ViewPager             android:id="@+id/viewPa ...

随机推荐

  1. HBase性能优化方法总结（转）

    原文链接:HBase性能优化方法总结(一):表的设计 本文主要是从HBase应用程序设计与开发的角度,总结几种常用的性能优化方法.有关HBase系统配置级别的优化,可参考:淘宝Ken Wu同学的博客. ...

  2. @JVM新一代的垃圾回收算法

    垃圾回收的瓶颈 传统分代垃圾回收方式,已经在一定程度上把垃圾回收给应用带来的负担降到了最小,把应用的吞吐量推到了一个极限.但是他无法解决的一个问题,就是Full GC所带来的应用暂停.在一些对实时性要 ...

  3. Objective-C:随机的读取文件中的内容

    可以通过改变当前文件的偏移量来实现文件的读取 -offsetInFile获取文件当前的位移量 -seekToFileOffset:(NSUInteger)length设置文件当前的位移量 -readD ...

  4. 使用ADB管理Andorid系统软件

    # Usageadb shell pm list packages -fadb shell pm list packages -eadb shell pm list packages -dadb sh ...

  5. hdu 4107 Gangster（线段树，时间卡得很严）

    这道题目的数据卡得好厉害. 题目明显是考察线段树延迟标记的,但是因为要考虑到p的值,这种延迟是有条件的:在该节点下所有的数据对于p都应该位于p的同一侧.要么都比p大,要么都比p小. 开始的时候我用一个 ...

  6. evaluate-division

    https://leetcode.com/problems/evaluate-division/ public class Solution { private Map mp; private cla ...

  7. jquery 返回顶端组件

    自己写了一个基于jquery的返回页面顶端的组件. (function($) { var g; $.backtop = function(options) { extend($.backtop.con ...

  8. Android GUI之View事件处理（二）

    在上篇文章中,我们分析了View的事件处理过程,当然这里的View是指基本的View.当View接收到Touch事件时,首先会调用dispacheTouchEvent方法,在这个方法中会调用OnTou ...

  9. Back Track 5 之 网络踩点

    DNS记录探测 dnsenum 针对NDS信息收集的工具 格式: ./dnsenum.pl dbsserver (域名) 请原谅我拿freestu.net这个学校团委的域名做的测试,求不黑!! dns ...

  10. [Algorithm] Write your own Math.pow function in Javascript, using Recursive approach

    /**@abstract * Write your own Math.pow(a int, b int) function * */ function pow (a, b) { let result ...