0);
|
|
872
|
+ Arrays.fill(mInitialMotionY, 0);
|
|
|
873
|
+ Arrays.fill(mLastMotionX, 0);
|
|
|
874
|
+ Arrays.fill(mLastMotionY, 0);
|
|
|
875
|
+ Arrays.fill(mInitialEdgeTouched, 0);
|
|
|
876
|
+ Arrays.fill(mEdgeDragsInProgress, 0);
|
|
|
877
|
+ Arrays.fill(mEdgeDragsLocked, 0);
|
|
|
878
|
+ mPointersDown = 0;
|
|
|
879
|
+ }
|
|
|
880
|
+
|
|
|
881
|
+ private void clearMotionHistory(int pointerId) {
|
|
|
882
|
+ if (mInitialMotionX == null) {
|
|
|
883
|
+ return;
|
|
|
884
|
+ }
|
|
|
885
|
+ mInitialMotionX[pointerId] = 0;
|
|
|
886
|
+ mInitialMotionY[pointerId] = 0;
|
|
|
887
|
+ mLastMotionX[pointerId] = 0;
|
|
|
888
|
+ mLastMotionY[pointerId] = 0;
|
|
|
889
|
+ mInitialEdgeTouched[pointerId] = 0;
|
|
|
890
|
+ mEdgeDragsInProgress[pointerId] = 0;
|
|
|
891
|
+ mEdgeDragsLocked[pointerId] = 0;
|
|
|
892
|
+ mPointersDown &= ~(1 << pointerId);
|
|
|
893
|
+ }
|
|
|
894
|
+
|
|
|
895
|
+ private void ensureMotionHistorySizeForId(int pointerId) {
|
|
|
896
|
+ if (mInitialMotionX == null || mInitialMotionX.length <= pointerId) {
|
|
|
897
|
+ float[] imx = new float[pointerId + 1];
|
|
|
898
|
+ float[] imy = new float[pointerId + 1];
|
|
|
899
|
+ float[] lmx = new float[pointerId + 1];
|
|
|
900
|
+ float[] lmy = new float[pointerId + 1];
|
|
|
901
|
+ int[] iit = new int[pointerId + 1];
|
|
|
902
|
+ int[] edip = new int[pointerId + 1];
|
|
|
903
|
+ int[] edl = new int[pointerId + 1];
|
|
|
904
|
+
|
|
|
905
|
+ if (mInitialMotionX != null) {
|
|
|
906
|
+ System.arraycopy(mInitialMotionX, 0, imx, 0, mInitialMotionX.length);
|
|
|
907
|
+ System.arraycopy(mInitialMotionY, 0, imy, 0, mInitialMotionY.length);
|
|
|
908
|
+ System.arraycopy(mLastMotionX, 0, lmx, 0, mLastMotionX.length);
|
|
|
909
|
+ System.arraycopy(mLastMotionY, 0, lmy, 0, mLastMotionY.length);
|
|
|
910
|
+ System.arraycopy(mInitialEdgeTouched, 0, iit, 0, mInitialEdgeTouched.length);
|
|
|
911
|
+ System.arraycopy(mEdgeDragsInProgress, 0, edip, 0, mEdgeDragsInProgress.length);
|
|
|
912
|
+ System.arraycopy(mEdgeDragsLocked, 0, edl, 0, mEdgeDragsLocked.length);
|
|
|
913
|
+ }
|
|
|
914
|
+
|
|
|
915
|
+ mInitialMotionX = imx;
|
|
|
916
|
+ mInitialMotionY = imy;
|
|
|
917
|
+ mLastMotionX = lmx;
|
|
|
918
|
+ mLastMotionY = lmy;
|
|
|
919
|
+ mInitialEdgeTouched = iit;
|
|
|
920
|
+ mEdgeDragsInProgress = edip;
|
|
|
921
|
+ mEdgeDragsLocked = edl;
|
|
|
922
|
+ }
|
|
|
923
|
+ }
|
|
|
924
|
+
|
|
|
925
|
+ private void saveInitialMotion(float x, float y, int pointerId) {
|
|
|
926
|
+ ensureMotionHistorySizeForId(pointerId);
|
|
|
927
|
+ mInitialMotionX[pointerId] = mLastMotionX[pointerId] = x;
|
|
|
928
|
+ mInitialMotionY[pointerId] = mLastMotionY[pointerId] = y;
|
|
|
929
|
+ mInitialEdgeTouched[pointerId] = getEdgeTouched((int) x, (int) y);
|
|
|
930
|
+ mPointersDown |= 1 << pointerId;
|
|
|
931
|
+ }
|
|
|
932
|
+
|
|
|
933
|
+ private void saveLastMotion(MotionEvent ev) {
|
|
|
934
|
+ final int pointerCount = MotionEventCompat.getPointerCount(ev);
|
|
|
935
|
+ for (int i = 0; i < pointerCount; i++) {
|
|
|
936
|
+ final int pointerId = MotionEventCompat.getPointerId(ev, i);
|
|
|
937
|
+ final float x = MotionEventCompat.getX(ev, i);
|
|
|
938
|
+ final float y = MotionEventCompat.getY(ev, i);
|
|
|
939
|
+ mLastMotionX[pointerId] = x;
|
|
|
940
|
+ mLastMotionY[pointerId] = y;
|
|
|
941
|
+ }
|
|
|
942
|
+ }
|
|
|
943
|
+
|
|
|
944
|
+ /**
|
|
|
945
|
+ * Check if the given pointer ID represents a pointer that is currently down
|
|
|
946
|
+ * (to the best of the ViewDragHelper's knowledge).
|
|
|
947
|
+ * <p>
|
|
|
948
|
+ * The state used to report this information is populated by the methods
|
|
|
949
|
+ * {@link #shouldInterceptTouchEvent(MotionEvent)} or
|
|
|
950
|
+ * {@link #processTouchEvent(MotionEvent)}. If one of these
|
|
|
951
|
+ * methods has not been called for all relevant MotionEvents to track, the
|
|
|
952
|
+ * information reported by this method may be stale or incorrect.
|
|
|
953
|
+ * </p>
|
|
|
954
|
+ *
|
|
|
955
|
+ * @param pointerId pointer ID to check; corresponds to IDs provided by
|
|
|
956
|
+ * MotionEvent
|
|
|
957
|
+ * @return true if the pointer with the given ID is still down
|
|
|
958
|
+ */
|
|
|
959
|
+ public boolean isPointerDown(int pointerId) {
|
|
|
960
|
+ return (mPointersDown & 1 << pointerId) != 0;
|
|
|
961
|
+ }
|
|
|
962
|
+
|
|
|
963
|
+ void setDragState(int state) {
|
|
|
964
|
+ if (mDragState != state) {
|
|
|
965
|
+ mDragState = state;
|
|
|
966
|
+ mCallback.onViewDragStateChanged(state);
|
|
|
967
|
+ if (state == STATE_IDLE) {
|
|
|
968
|
+ mCapturedView = null;
|
|
|
969
|
+ }
|
|
|
970
|
+ }
|
|
|
971
|
+ }
|
|
|
972
|
+
|
|
|
973
|
+ /**
|
|
|
974
|
+ * Attempt to capture the view with the given pointer ID. The callback will
|
|
|
975
|
+ * be involved. This will put us into the "dragging" state. If we've already
|
|
|
976
|
+ * captured this view with this pointer this method will immediately return
|
|
|
977
|
+ * true without consulting the callback.
|
|
|
978
|
+ *
|
|
|
979
|
+ * @param toCapture View to capture
|
|
|
980
|
+ * @param pointerId Pointer to capture with
|
|
|
981
|
+ * @return true if capture was successful
|
|
|
982
|
+ */
|
|
|
983
|
+ boolean tryCaptureViewForDrag(View toCapture, int pointerId) {
|
|
|
984
|
+ if (toCapture == mCapturedView && mActivePointerId == pointerId) {
|
|
|
985
|
+ // Already done!
|
|
|
986
|
+ return true;
|
|
|
987
|
+ }
|
|
|
988
|
+ if (toCapture != null && mCallback.tryCaptureView(toCapture, pointerId)) {
|
|
|
989
|
+ mActivePointerId = pointerId;
|
|
|
990
|
+ captureChildView(toCapture, pointerId);
|
|
|
991
|
+ return true;
|
|
|
992
|
+ }
|
|
|
993
|
+ return false;
|
|
|
994
|
+ }
|
|
|
995
|
+
|
|
|
996
|
+ /**
|
|
|
997
|
+ * Tests scrollability within child views of v given a delta of dx.
|
|
|
998
|
+ *
|
|
|
999
|
+ * @param v View to test for horizontal scrollability
|
|
|
1000
|
+ * @param checkV Whether the view v passed should itself be checked for
|
|
|
1001
|
+ * scrollability (true), or just its children (false).
|
|
|
1002
|
+ * @param dx Delta scrolled in pixels along the X axis
|
|
|
1003
|
+ * @param dy Delta scrolled in pixels along the Y axis
|
|
|
1004
|
+ * @param x X coordinate of the active touch point
|
|
|
1005
|
+ * @param y Y coordinate of the active touch point
|
|
|
1006
|
+ * @return true if child views of v can be scrolled by delta of dx.
|
|
|
1007
|
+ */
|
|
|
1008
|
+ protected boolean canScroll(View v, boolean checkV, int dx, int dy, int x, int y) {
|
|
|
1009
|
+ if (v instanceof ViewGroup) {
|
|
|
1010
|
+ final ViewGroup group = (ViewGroup) v;
|
|
|
1011
|
+ final int scrollX = v.getScrollX();
|
|
|
1012
|
+ final int scrollY = v.getScrollY();
|
|
|
1013
|
+ final int count = group.getChildCount();
|
|
|
1014
|
+ // Count backwards - let topmost views consume scroll distance
|
|
|
1015
|
+ // first.
|
|
|
1016
|
+ for (int i = count - 1; i >= 0; i--) {
|
|
|
1017
|
+ // TODO: Add versioned support here for transformed views.
|
|
|
1018
|
+ // This will not work for transformed views in Honeycomb+
|
|
|
1019
|
+ final View child = group.getChildAt(i);
|
|
|
1020
|
+ if (x + scrollX >= child.getLeft()
|
|
|
1021
|
+ && x + scrollX < child.getRight()
|
|
|
1022
|
+ && y + scrollY >= child.getTop()
|
|
|
1023
|
+ && y + scrollY < child.getBottom()
|
|
|
1024
|
+ && canScroll(child, true, dx, dy, x + scrollX - child.getLeft(), y
|
|
|
1025
|
+ + scrollY - child.getTop())) {
|
|
|
1026
|
+ return true;
|
|
|
1027
|
+ }
|
|
|
1028
|
+ }
|
|
|
1029
|
+ }
|
|
|
1030
|
+
|
|
|
1031
|
+ return checkV
|
|
|
1032
|
+ && (ViewCompat.canScrollHorizontally(v, -dx) || ViewCompat.canScrollVertically(v,
|
|
|
1033
|
+ -dy));
|
|
|
1034
|
+ }
|
|
|
1035
|
+
|
|
|
1036
|
+ /**
|
|
|
1037
|
+ * Check if this event as provided to the parent view's
|
|
|
1038
|
+ * onInterceptTouchEvent should cause the parent to intercept the touch
|
|
|
1039
|
+ * event stream.
|
|
|
1040
|
+ *
|
|
|
1041
|
+ * @param ev MotionEvent provided to onInterceptTouchEvent
|
|
|
1042
|
+ * @return true if the parent view should return true from
|
|
|
1043
|
+ * onInterceptTouchEvent
|
|
|
1044
|
+ */
|
|
|
1045
|
+ public boolean shouldInterceptTouchEvent(MotionEvent ev) {
|
|
|
1046
|
+ final int action = MotionEventCompat.getActionMasked(ev);
|
|
|
1047
|
+ final int actionIndex = MotionEventCompat.getActionIndex(ev);
|
|
|
1048
|
+
|
|
|
1049
|
+ if (action == MotionEvent.ACTION_DOWN) {
|
|
|
1050
|
+ // Reset things for a new event stream, just in case we didn't get
|
|
|
1051
|
+ // the whole previous stream.
|
|
|
1052
|
+ cancel();
|
|
|
1053
|
+ }
|
|
|
1054
|
+
|
|
|
1055
|
+ if (mVelocityTracker == null) {
|
|
|
1056
|
+ mVelocityTracker = VelocityTracker.obtain();
|
|
|
1057
|
+ }
|
|
|
1058
|
+ mVelocityTracker.addMovement(ev);
|
|
|
1059
|
+
|
|
|
1060
|
+ switch (action) {
|
|
|
1061
|
+ case MotionEvent.ACTION_DOWN: {
|
|
|
1062
|
+ final float x = ev.getX();
|
|
|
1063
|
+ final float y = ev.getY();
|
|
|
1064
|
+ final int pointerId = MotionEventCompat.getPointerId(ev, 0);
|
|
|
1065
|
+ saveInitialMotion(x, y, pointerId);
|
|
|
1066
|
+
|
|
|
1067
|
+ final View toCapture = findTopChildUnder((int) x, (int) y);
|
|
|
1068
|
+
|
|
|
1069
|
+ // Catch a settling view if possible.
|
|
|
1070
|
+ if (toCapture == mCapturedView && mDragState == STATE_SETTLING) {
|
|
|
1071
|
+ tryCaptureViewForDrag(toCapture, pointerId);
|
|
|
1072
|
+ }
|
|
|
1073
|
+
|
|
|
1074
|
+ final int edgesTouched = mInitialEdgeTouched[pointerId];
|
|
|
1075
|
+ if ((edgesTouched & mTrackingEdges) != 0) {
|
|
|
1076
|
+ mCallback.onEdgeTouched(edgesTouched & mTrackingEdges, pointerId);
|
|
|
1077
|
+ }
|
|
|
1078
|
+ break;
|
|
|
1079
|
+ }
|
|
|
1080
|
+
|
|
|
1081
|
+ case MotionEventCompat.ACTION_POINTER_DOWN: {
|
|
|
1082
|
+ final int pointerId = MotionEventCompat.getPointerId(ev, actionIndex);
|
|
|
1083
|
+ final float x = MotionEventCompat.getX(ev, actionIndex);
|
|
|
1084
|
+ final float y = MotionEventCompat.getY(ev, actionIndex);
|
|
|
1085
|
+
|
|
|
1086
|
+ saveInitialMotion(x, y, pointerId);
|
|
|
1087
|
+
|
|
|
1088
|
+ // A ViewDragHelper can only manipulate one view at a time.
|
|
|
1089
|
+ if (mDragState == STATE_IDLE) {
|
|
|
1090
|
+ final int edgesTouched = mInitialEdgeTouched[pointerId];
|
|
|
1091
|
+ if ((edgesTouched & mTrackingEdges) != 0) {
|
|
|
1092
|
+ mCallback.onEdgeTouched(edgesTouched & mTrackingEdges, pointerId);
|
|
|
1093
|
+ }
|
|
|
1094
|
+ } else if (mDragState == STATE_SETTLING) {
|
|
|
1095
|
+ // Catch a settling view if possible.
|
|
|
1096
|
+ final View toCapture = findTopChildUnder((int) x, (int) y);
|
|
|
1097
|
+ if (toCapture == mCapturedView) {
|
|
|
1098
|
+ tryCaptureViewForDrag(toCapture, pointerId);
|
|
|
1099
|
+ }
|
|
|
1100
|
+ }
|
|
|
1101
|
+ break;
|
|
|
1102
|
+ }
|
|
|
1103
|
+
|
|
|
1104
|
+ case MotionEvent.ACTION_MOVE: {
|
|
|
1105
|
+ // First to cross a touch slop over a draggable view wins. Also
|
|
|
1106
|
+ // report edge drags.
|
|
|
1107
|
+ final int pointerCount = MotionEventCompat.getPointerCount(ev);
|
|
|
1108
|
+ for (int i = 0; i < pointerCount; i++) {
|
|
|
1109
|
+ final int pointerId = MotionEventCompat.getPointerId(ev, i);
|
|
|
1110
|
+ final float x = MotionEventCompat.getX(ev, i);
|
|
|
1111
|
+ final float y = MotionEventCompat.getY(ev, i);
|
|
|
1112
|
+ final float dx = x - mInitialMotionX[pointerId];
|
|
|
1113
|
+ final float dy = y - mInitialMotionY[pointerId];
|
|
|
1114
|
+
|
|
|
1115
|
+ reportNewEdgeDrags(dx, dy, pointerId);
|
|
|
1116
|
+ if (mDragState == STATE_DRAGGING) {
|
|
|
1117
|
+ // Callback might have started an edge drag
|
|
|
1118
|
+ break;
|
|
|
1119
|
+ }
|
|
|
1120
|
+
|
|
|
1121
|
+ final View toCapture = findTopChildUnder((int) x, (int) y);
|
|
|
1122
|
+ if (toCapture != null && checkTouchSlop(toCapture, dx, dy)
|
|
|
1123
|
+ && tryCaptureViewForDrag(toCapture, pointerId)) {
|
|
|
1124
|
+ break;
|
|
|
1125
|
+ }
|
|
|
1126
|
+ }
|
|
|
1127
|
+ saveLastMotion(ev);
|
|
|
1128
|
+ break;
|
|
|
1129
|
+ }
|
|
|
1130
|
+
|
|
|
1131
|
+ case MotionEventCompat.ACTION_POINTER_UP: {
|
|
|
1132
|
+ final int pointerId = MotionEventCompat.getPointerId(ev, actionIndex);
|
|
|
1133
|
+ clearMotionHistory(pointerId);
|
|
|
1134
|
+ break;
|
|
|
1135
|
+ }
|
|
|
1136
|
+
|
|
|
1137
|
+ case MotionEvent.ACTION_UP:
|
|
|
1138
|
+ case MotionEvent.ACTION_CANCEL: {
|
|
|
1139
|
+ cancel();
|
|
|
1140
|
+ break;
|
|
|
1141
|
+ }
|
|
|
1142
|
+ }
|
|
|
1143
|
+
|
|
|
1144
|
+ return mDragState == STATE_DRAGGING;
|
|
|
1145
|
+ }
|
|
|
1146
|
+
|
|
|
1147
|
+ /**
|
|
|
1148
|
+ * Process a touch event received by the parent view. This method will
|
|
|
1149
|
+ * dispatch callback events as needed before returning. The parent view's
|
|
|
1150
|
+ * onTouchEvent implementation should call this.
|
|
|
1151
|
+ *
|
|
|
1152
|
+ * @param ev The touch event received by the parent view
|
|
|
1153
|
+ */
|
|
|
1154
|
+ public void processTouchEvent(MotionEvent ev) {
|
|
|
1155
|
+ final int action = MotionEventCompat.getActionMasked(ev);
|
|
|
1156
|
+ final int actionIndex = MotionEventCompat.getActionIndex(ev);
|
|
|
1157
|
+
|
|
|
1158
|
+ if (action == MotionEvent.ACTION_DOWN) {
|
|
|
1159
|
+ // Reset things for a new event stream, just in case we didn't get
|
|
|
1160
|
+ // the whole previous stream.
|
|
|
1161
|
+ cancel();
|
|
|
1162
|
+ }
|
|
|
1163
|
+
|
|
|
1164
|
+ if (mVelocityTracker == null) {
|
|
|
1165
|
+ mVelocityTracker = VelocityTracker.obtain();
|
|
|
1166
|
+ }
|
|
|
1167
|
+ mVelocityTracker.addMovement(ev);
|
|
|
1168
|
+
|
|
|
1169
|
+ switch (action) {
|
|
|
1170
|
+ case MotionEvent.ACTION_DOWN: {
|
|
|
1171
|
+ final float x = ev.getX();
|
|
|
1172
|
+ final float y = ev.getY();
|
|
|
1173
|
+ final int pointerId = MotionEventCompat.getPointerId(ev, 0);
|
|
|
1174
|
+ final View toCapture = findTopChildUnder((int) x, (int) y);
|
|
|
1175
|
+
|
|
|
1176
|
+ saveInitialMotion(x, y, pointerId);
|
|
|
1177
|
+
|
|
|
1178
|
+ // Since the parent is already directly processing this touch
|
|
|
1179
|
+ // event,
|
|
|
1180
|
+ // there is no reason to delay for a slop before dragging.
|
|
|
1181
|
+ // Start immediately if possible.
|
|
|
1182
|
+ tryCaptureViewForDrag(toCapture, pointerId);
|
|
|
1183
|
+
|
|
|
1184
|
+ final int edgesTouched = mInitialEdgeTouched[pointerId];
|
|
|
1185
|
+ if ((edgesTouched & mTrackingEdges) != 0) {
|
|
|
1186
|
+ mCallback.onEdgeTouched(edgesTouched & mTrackingEdges, pointerId);
|
|
|
1187
|
+ }
|
|
|
1188
|
+ break;
|
|
|
1189
|
+ }
|
|
|
1190
|
+
|
|
|
1191
|
+ case MotionEventCompat.ACTION_POINTER_DOWN: {
|
|
|
1192
|
+ final int pointerId = MotionEventCompat.getPointerId(ev, actionIndex);
|
|
|
1193
|
+ final float x = MotionEventCompat.getX(ev, actionIndex);
|
|
|
1194
|
+ final float y = MotionEventCompat.getY(ev, actionIndex);
|
|
|
1195
|
+
|
|
|
1196
|
+ saveInitialMotion(x, y, pointerId);
|
|
|
1197
|
+
|
|
|
1198
|
+ // A ViewDragHelper can only manipulate one view at a time.
|
|
|
1199
|
+ if (mDragState == STATE_IDLE) {
|
|
|
1200
|
+ // If we're idle we can do anything! Treat it like a normal
|
|
|
1201
|
+ // down event.
|
|
|
1202
|
+
|
|
|
1203
|
+ final View toCapture = findTopChildUnder((int) x, (int) y);
|
|
|
1204
|
+ tryCaptureViewForDrag(toCapture, pointerId);
|
|
|
1205
|
+
|
|
|
1206
|
+ final int edgesTouched = mInitialEdgeTouched[pointerId];
|
|
|
1207
|
+ if ((edgesTouched & mTrackingEdges) != 0) {
|
|
|
1208
|
+ mCallback.onEdgeTouched(edgesTouched & mTrackingEdges, pointerId);
|
|
|
1209
|
+ }
|
|
|
1210
|
+ } else if (isCapturedViewUnder((int) x, (int) y)) {
|
|
|
1211
|
+ // We're still tracking a captured view. If the same view is
|
|
|
1212
|
+ // under this
|
|
|
1213
|
+ // point, we'll swap to controlling it with this pointer
|
|
|
1214
|
+ // instead.
|
|
|
1215
|
+ // (This will still work if we're "catching" a settling
|
|
|
1216
|
+ // view.)
|
|
|
1217
|
+
|
|
|
1218
|
+ tryCaptureViewForDrag(mCapturedView, pointerId);
|
|
|
1219
|
+ }
|
|
|
1220
|
+ break;
|
|
|
1221
|
+ }
|
|
|
1222
|
+
|
|
|
1223
|
+ case MotionEvent.ACTION_MOVE: {
|
|
|
1224
|
+ if (mDragState == STATE_DRAGGING) {
|
|
|
1225
|
+ final int index = MotionEventCompat.findPointerIndex(ev, mActivePointerId);
|
|
|
1226
|
+ final float x = MotionEventCompat.getX(ev, index);
|
|
|
1227
|
+ final float y = MotionEventCompat.getY(ev, index);
|
|
|
1228
|
+ final int idx = (int) (x - mLastMotionX[mActivePointerId]);
|
|
|
1229
|
+ final int idy = (int) (y - mLastMotionY[mActivePointerId]);
|
|
|
1230
|
+
|
|
|
1231
|
+ dragTo(mCapturedView.getLeft() + idx, mCapturedView.getTop() + idy, idx, idy);
|
|
|
1232
|
+
|
|
|
1233
|
+ saveLastMotion(ev);
|
|
|
1234
|
+ } else {
|
|
|
1235
|
+ // Check to see if any pointer is now over a draggable view.
|
|
|
1236
|
+ final int pointerCount = MotionEventCompat.getPointerCount(ev);
|
|
|
1237
|
+ for (int i = 0; i < pointerCount; i++) {
|
|
|
1238
|
+ final int pointerId = MotionEventCompat.getPointerId(ev, i);
|
|
|
1239
|
+ final float x = MotionEventCompat.getX(ev, i);
|
|
|
1240
|
+ final float y = MotionEventCompat.getY(ev, i);
|
|
|
1241
|
+ final float dx = x - mInitialMotionX[pointerId];
|
|
|
1242
|
+ final float dy = y - mInitialMotionY[pointerId];
|
|
|
1243
|
+
|
|
|
1244
|
+ reportNewEdgeDrags(dx, dy, pointerId);
|
|
|
1245
|
+ if (mDragState == STATE_DRAGGING) {
|
|
|
1246
|
+ // Callback might have started an edge drag.
|
|
|
1247
|
+ break;
|
|
|
1248
|
+ }
|
|
|
1249
|
+
|
|
|
1250
|
+ final View toCapture = findTopChildUnder((int) x, (int) y);
|
|
|
1251
|
+ if (checkTouchSlop(toCapture, dx, dy)
|
|
|
1252
|
+ && tryCaptureViewForDrag(toCapture, pointerId)) {
|
|
|
1253
|
+ break;
|
|
|
1254
|
+ }
|
|
|
1255
|
+ }
|
|
|
1256
|
+ saveLastMotion(ev);
|
|
|
1257
|
+ }
|
|
|
1258
|
+ break;
|
|
|
1259
|
+ }
|
|
|
1260
|
+
|
|
|
1261
|
+ case MotionEventCompat.ACTION_POINTER_UP: {
|
|
|
1262
|
+ final int pointerId = MotionEventCompat.getPointerId(ev, actionIndex);
|
|
|
1263
|
+ if (mDragState == STATE_DRAGGING && pointerId == mActivePointerId) {
|
|
|
1264
|
+ // Try to find another pointer that's still holding on to
|
|
|
1265
|
+ // the captured view.
|
|
|
1266
|
+ int newActivePointer = INVALID_POINTER;
|
|
|
1267
|
+ final int pointerCount = MotionEventCompat.getPointerCount(ev);
|
|
|
1268
|
+ for (int i = 0; i < pointerCount; i++) {
|
|
|
1269
|
+ final int id = MotionEventCompat.getPointerId(ev, i);
|
|
|
1270
|
+ if (id == mActivePointerId) {
|
|
|
1271
|
+ // This one's going away, skip.
|
|
|
1272
|
+ continue;
|
|
|
1273
|
+ }
|
|
|
1274
|
+
|
|
|
1275
|
+ final float x = MotionEventCompat.getX(ev, i);
|
|
|
1276
|
+ final float y = MotionEventCompat.getY(ev, i);
|
|
|
1277
|
+ if (findTopChildUnder((int) x, (int) y) == mCapturedView
|
|
|
1278
|
+ && tryCaptureViewForDrag(mCapturedView, id)) {
|
|
|
1279
|
+ newActivePointer = mActivePointerId;
|
|
|
1280
|
+ break;
|
|
|
1281
|
+ }
|
|
|
1282
|
+ }
|
|
|
1283
|
+
|
|
|
1284
|
+ if (newActivePointer == INVALID_POINTER) {
|
|
|
1285
|
+ // We didn't find another pointer still touching the
|
|
|
1286
|
+ // view, release it.
|
|
|
1287
|
+ releaseViewForPointerUp();
|
|
|
1288
|
+ }
|
|
|
1289
|
+ }
|
|
|
1290
|
+ clearMotionHistory(pointerId);
|
|
|
1291
|
+ break;
|
|
|
1292
|
+ }
|
|
|
1293
|
+
|
|
|
1294
|
+ case MotionEvent.ACTION_UP: {
|
|
|
1295
|
+ if (mDragState == STATE_DRAGGING) {
|
|
|
1296
|
+ releaseViewForPointerUp();
|
|
|
1297
|
+ }
|
|
|
1298
|
+ cancel();
|
|
|
1299
|
+ break;
|
|
|
1300
|
+ }
|
|
|
1301
|
+
|
|
|
1302
|
+ case MotionEvent.ACTION_CANCEL: {
|
|
|
1303
|
+ if (mDragState == STATE_DRAGGING) {
|
|
|
1304
|
+ dispatchViewReleased(0, 0);
|
|
|
1305
|
+ }
|
|
|
1306
|
+ cancel();
|
|
|
1307
|
+ break;
|
|
|
1308
|
+ }
|
|
|
1309
|
+ }
|
|
|
1310
|
+ }
|
|
|
1311
|
+
|
|
|
1312
|
+ private void reportNewEdgeDrags(float dx, float dy, int pointerId) {
|
|
|
1313
|
+ int dragsStarted = 0;
|
|
|
1314
|
+ if (checkNewEdgeDrag(dx, dy, pointerId, EDGE_LEFT)) {
|
|
|
1315
|
+ dragsStarted |= EDGE_LEFT;
|
|
|
1316
|
+ }
|
|
|
1317
|
+ if (checkNewEdgeDrag(dy, dx, pointerId, EDGE_TOP)) {
|
|
|
1318
|
+ dragsStarted |= EDGE_TOP;
|
|
|
1319
|
+ }
|
|
|
1320
|
+ if (checkNewEdgeDrag(dx, dy, pointerId, EDGE_RIGHT)) {
|
|
|
1321
|
+ dragsStarted |= EDGE_RIGHT;
|
|
|
1322
|
+ }
|
|
|
1323
|
+ if (checkNewEdgeDrag(dy, dx, pointerId, EDGE_BOTTOM)) {
|
|
|
1324
|
+ dragsStarted |= EDGE_BOTTOM;
|
|
|
1325
|
+ }
|
|
|
1326
|
+
|
|
|
1327
|
+ if (dragsStarted != 0) {
|
|
|
1328
|
+ mEdgeDragsInProgress[pointerId] |= dragsStarted;
|
|
|
1329
|
+ mCallback.onEdgeDragStarted(dragsStarted, pointerId);
|
|
|
1330
|
+ }
|
|
|
1331
|
+ }
|
|
|
1332
|
+
|
|
|
1333
|
+ private boolean checkNewEdgeDrag(float delta, float odelta, int pointerId, int edge) {
|
|
|
1334
|
+ final float absDelta = Math.abs(delta);
|
|
|
1335
|
+ final float absODelta = Math.abs(odelta);
|
|
|
1336
|
+
|
|
|
1337
|
+ if ((mInitialEdgeTouched[pointerId] & edge) != edge || (mTrackingEdges & edge) == 0
|
|
|
1338
|
+ || (mEdgeDragsLocked[pointerId] & edge) == edge
|
|
|
1339
|
+ || (mEdgeDragsInProgress[pointerId] & edge) == edge
|
|
|
1340
|
+ || (absDelta <= mTouchSlop && absODelta <= mTouchSlop)) {
|
|
|
1341
|
+ return false;
|
|
|
1342
|
+ }
|
|
|
1343
|
+ if (absDelta < absODelta * 0.5f && mCallback.onEdgeLock(edge)) {
|
|
|
1344
|
+ mEdgeDragsLocked[pointerId] |= edge;
|
|
|
1345
|
+ return false;
|
|
|
1346
|
+ }
|
|
|
1347
|
+ return (mEdgeDragsInProgress[pointerId] & edge) == 0 && absDelta > mTouchSlop;
|
|
|
1348
|
+ }
|
|
|
1349
|
+
|
|
|
1350
|
+ /**
|
|
|
1351
|
+ * Check if we've crossed a reasonable touch slop for the given child view.
|
|
|
1352
|
+ * If the child cannot be dragged along the horizontal or vertical axis,
|
|
|
1353
|
+ * motion along that axis will not count toward the slop check.
|
|
|
1354
|
+ *
|
|
|
1355
|
+ * @param child Child to check
|
|
|
1356
|
+ * @param dx Motion since initial position along X axis
|
|
|
1357
|
+ * @param dy Motion since initial position along Y axis
|
|
|
1358
|
+ * @return true if the touch slop has been crossed
|
|
|
1359
|
+ */
|
|
|
1360
|
+ private boolean checkTouchSlop(View child, float dx, float dy) {
|
|
|
1361
|
+ if (child == null) {
|
|
|
1362
|
+ return false;
|
|
|
1363
|
+ }
|
|
|
1364
|
+ final boolean checkHorizontal = mCallback.getViewHorizontalDragRange(child) > 0;
|
|
|
1365
|
+ final boolean checkVertical = mCallback.getViewVerticalDragRange(child) > 0;
|
|
|
1366
|
+
|
|
|
1367
|
+ if (checkHorizontal && checkVertical) {
|
|
|
1368
|
+ return dx * dx + dy * dy > mTouchSlop * mTouchSlop;
|
|
|
1369
|
+ } else if (checkHorizontal) {
|
|
|
1370
|
+ return Math.abs(dx) > mTouchSlop;
|
|
|
1371
|
+ } else if (checkVertical) {
|
|
|
1372
|
+ return Math.abs(dy) > mTouchSlop;
|
|
|
1373
|
+ }
|
|
|
1374
|
+ return false;
|
|
|
1375
|
+ }
|
|
|
1376
|
+
|
|
|
1377
|
+ /**
|
|
|
1378
|
+ * Check if any pointer tracked in the current gesture has crossed the
|
|
|
1379
|
+ * required slop threshold.
|
|
|
1380
|
+ * <p>
|
|
|
1381
|
+ * This depends on internal state populated by
|
|
|
1382
|
+ * {@link #shouldInterceptTouchEvent(MotionEvent)} or
|
|
|
1383
|
+ * {@link #processTouchEvent(MotionEvent)}. You should only
|
|
|
1384
|
+ * rely on the results of this method after all currently available touch
|
|
|
1385
|
+ * data has been provided to one of these two methods.
|
|
|
1386
|
+ * </p>
|
|
|
1387
|
+ *
|
|
|
1388
|
+ * @param directions Combination of direction flags, see
|
|
|
1389
|
+ * {@link #DIRECTION_HORIZONTAL}, {@link #DIRECTION_VERTICAL},
|
|
|
1390
|
+ * {@link #DIRECTION_ALL}
|
|
|
1391
|
+ * @return true if the slop threshold has been crossed, false otherwise
|
|
|
1392
|
+ */
|
|
|
1393
|
+ public boolean checkTouchSlop(int directions) {
|
|
|
1394
|
+ final int count = mInitialMotionX.length;
|
|
|
1395
|
+ for (int i = 0; i < count; i++) {
|
|
|
1396
|
+ if (checkTouchSlop(directions, i)) {
|
|
|
1397
|
+ return true;
|
|
|
1398
|
+ }
|
|
|
1399
|
+ }
|
|
|
1400
|
+ return false;
|
|
|
1401
|
+ }
|
|
|
1402
|
+
|
|
|
1403
|
+ /**
|
|
|
1404
|
+ * Check if the specified pointer tracked in the current gesture has crossed
|
|
|
1405
|
+ * the required slop threshold.
|
|
|
1406
|
+ * <p>
|
|
|
1407
|
+ * This depends on internal state populated by
|
|
|
1408
|
+ * {@link #shouldInterceptTouchEvent(MotionEvent)} or
|
|
|
1409
|
+ * {@link #processTouchEvent(MotionEvent)}. You should only
|
|
|
1410
|
+ * rely on the results of this method after all currently available touch
|
|
|
1411
|
+ * data has been provided to one of these two methods.
|
|
|
1412
|
+ * </p>
|
|
|
1413
|
+ *
|
|
|
1414
|
+ * @param directions Combination of direction flags, see
|
|
|
1415
|
+ * {@link #DIRECTION_HORIZONTAL}, {@link #DIRECTION_VERTICAL},
|
|
|
1416
|
+ * {@link #DIRECTION_ALL}
|
|
|
1417
|
+ * @param pointerId ID of the pointer to slop check as specified by
|
|
|
1418
|
+ * MotionEvent
|
|
|
1419
|
+ * @return true if the slop threshold has been crossed, false otherwise
|
|
|
1420
|
+ */
|
|
|
1421
|
+ public boolean checkTouchSlop(int directions, int pointerId) {
|
|
|
1422
|
+ if (!isPointerDown(pointerId)) {
|
|
|
1423
|
+ return false;
|
|
|
1424
|
+ }
|
|
|
1425
|
+
|
|
|
1426
|
+ final boolean checkHorizontal = (directions & DIRECTION_HORIZONTAL) == DIRECTION_HORIZONTAL;
|
|
|
1427
|
+ final boolean checkVertical = (directions & DIRECTION_VERTICAL) == DIRECTION_VERTICAL;
|
|
|
1428
|
+
|
|
|
1429
|
+ final float dx = mLastMotionX[pointerId] - mInitialMotionX[pointerId];
|
|
|
1430
|
+ final float dy = mLastMotionY[pointerId] - mInitialMotionY[pointerId];
|
|
|
1431
|
+
|
|
|
1432
|
+ if (checkHorizontal && checkVertical) {
|
|
|
1433
|
+ return dx * dx + dy * dy > mTouchSlop * mTouchSlop;
|
|
|
1434
|
+ } else if (checkHorizontal) {
|
|
|
1435
|
+ return Math.abs(dx) > mTouchSlop;
|
|
|
1436
|
+ } else if (checkVertical) {
|
|
|
1437
|
+ return Math.abs(dy) > mTouchSlop;
|
|
|
1438
|
+ }
|
|
|
1439
|
+ return false;
|
|
|
1440
|
+ }
|
|
|
1441
|
+
|
|
|
1442
|
+ /**
|
|
|
1443
|
+ * Check if any of the edges specified were initially touched in the
|
|
|
1444
|
+ * currently active gesture. If there is no currently active gesture this
|
|
|
1445
|
+ * method will return false.
|
|
|
1446
|
+ *
|
|
|
1447
|
+ * @param edges Edges to check for an initial edge touch. See
|
|
|
1448
|
+ * {@link #EDGE_LEFT}, {@link #EDGE_TOP}, {@link #EDGE_RIGHT},
|
|
|
1449
|
+ * {@link #EDGE_BOTTOM} and {@link #EDGE_ALL}
|
|
|
1450
|
+ * @return true if any of the edges specified were initially touched in the
|
|
|
1451
|
+ * current gesture
|
|
|
1452
|
+ */
|
|
|
1453
|
+ public boolean isEdgeTouched(int edges) {
|
|
|
1454
|
+ final int count = mInitialEdgeTouched.length;
|
|
|
1455
|
+ for (int i = 0; i < count; i++) {
|
|
|
1456
|
+ if (isEdgeTouched(edges, i)) {
|
|
|
1457
|
+ return true;
|
|
|
1458
|
+ }
|
|
|
1459
|
+ }
|
|
|
1460
|
+ return false;
|
|
|
1461
|
+ }
|
|
|
1462
|
+
|
|
|
1463
|
+ /**
|
|
|
1464
|
+ * Check if any of the edges specified were initially touched by the pointer
|
|
|
1465
|
+ * with the specified ID. If there is no currently active gesture or if
|
|
|
1466
|
+ * there is no pointer with the given ID currently down this method will
|
|
|
1467
|
+ * return false.
|
|
|
1468
|
+ *
|
|
|
1469
|
+ * @param edges Edges to check for an initial edge touch. See
|
|
|
1470
|
+ * {@link #EDGE_LEFT}, {@link #EDGE_TOP}, {@link #EDGE_RIGHT},
|
|
|
1471
|
+ * {@link #EDGE_BOTTOM} and {@link #EDGE_ALL}
|
|
|
1472
|
+ * @return true if any of the edges specified were initially touched in the
|
|
|
1473
|
+ * current gesture
|
|
|
1474
|
+ */
|
|
|
1475
|
+ public boolean isEdgeTouched(int edges, int pointerId) {
|
|
|
1476
|
+ return isPointerDown(pointerId) && (mInitialEdgeTouched[pointerId] & edges) != 0;
|
|
|
1477
|
+ }
|
|
|
1478
|
+
|
|
|
1479
|
+ private void releaseViewForPointerUp() {
|
|
|
1480
|
+ mVelocityTracker.computeCurrentVelocity(1000, mMaxVelocity);
|
|
|
1481
|
+ final float xvel = clampMag(
|
|
|
1482
|
+ VelocityTrackerCompat.getXVelocity(mVelocityTracker, mActivePointerId),
|
|
|
1483
|
+ mMinVelocity, mMaxVelocity);
|
|
|
1484
|
+ final float yvel = clampMag(
|
|
|
1485
|
+ VelocityTrackerCompat.getYVelocity(mVelocityTracker, mActivePointerId),
|
|
|
1486
|
+ mMinVelocity, mMaxVelocity);
|
|
|
1487
|
+ dispatchViewReleased(xvel, yvel);
|
|
|
1488
|
+ }
|
|
|
1489
|
+
|
|
|
1490
|
+ private void dragTo(int left, int top, int dx, int dy) {
|
|
|
1491
|
+ int clampedX = left;
|
|
|
1492
|
+ int clampedY = top;
|
|
|
1493
|
+ final int oldLeft = mCapturedView.getLeft();
|
|
|
1494
|
+ final int oldTop = mCapturedView.getTop();
|
|
|
1495
|
+ if (dx != 0) {
|
|
|
1496
|
+ clampedX = mCallback.clampViewPositionHorizontal(mCapturedView, left, dx);
|
|
|
1497
|
+ mCapturedView.offsetLeftAndRight(clampedX - oldLeft);
|
|
|
1498
|
+ }
|
|
|
1499
|
+ if (dy != 0) {
|
|
|
1500
|
+ clampedY = mCallback.clampViewPositionVertical(mCapturedView, top, dy);
|
|
|
1501
|
+ mCapturedView.offsetTopAndBottom(clampedY - oldTop);
|
|
|
1502
|
+ }
|
|
|
1503
|
+
|
|
|
1504
|
+ if (dx != 0 || dy != 0) {
|
|
|
1505
|
+ final int clampedDx = clampedX - oldLeft;
|
|
|
1506
|
+ final int clampedDy = clampedY - oldTop;
|
|
|
1507
|
+ mCallback
|
|
|
1508
|
+ .onViewPositionChanged(mCapturedView, clampedX, clampedY, clampedDx, clampedDy);
|
|
|
1509
|
+ }
|
|
|
1510
|
+ }
|
|
|
1511
|
+
|
|
|
1512
|
+ /**
|
|
|
1513
|
+ * Determine if the currently captured view is under the given point in the
|
|
|
1514
|
+ * parent view's coordinate system. If there is no captured view this method
|
|
|
1515
|
+ * will return false.
|
|
|
1516
|
+ *
|
|
|
1517
|
+ * @param x X position to test in the parent's coordinate system
|
|
|
1518
|
+ * @param y Y position to test in the parent's coordinate system
|
|
|
1519
|
+ * @return true if the captured view is under the given point, false
|
|
|
1520
|
+ * otherwise
|
|
|
1521
|
+ */
|
|
|
1522
|
+ public boolean isCapturedViewUnder(int x, int y) {
|
|
|
1523
|
+ return isViewUnder(mCapturedView, x, y);
|
|
|
1524
|
+ }
|
|
|
1525
|
+
|
|
|
1526
|
+ /**
|
|
|
1527
|
+ * Determine if the supplied view is under the given point in the parent
|
|
|
1528
|
+ * view's coordinate system.
|
|
|
1529
|
+ *
|
|
|
1530
|
+ * @param view Child view of the parent to hit test
|
|
|
1531
|
+ * @param x X position to test in the parent's coordinate system
|
|
|
1532
|
+ * @param y Y position to test in the parent's coordinate system
|
|
|
1533
|
+ * @return true if the supplied view is under the given point, false
|
|
|
1534
|
+ * otherwise
|
|
|
1535
|
+ */
|
|
|
1536
|
+ public boolean isViewUnder(View view, int x, int y) {
|
|
|
1537
|
+ if (view == null) {
|
|
|
1538
|
+ return false;
|
|
|
1539
|
+ }
|
|
|
1540
|
+ return x >= view.getLeft() && x < view.getRight() && y >= view.getTop()
|
|
|
1541
|
+ && y < view.getBottom();
|
|
|
1542
|
+ }
|
|
|
1543
|
+
|
|
|
1544
|
+ /**
|
|
|
1545
|
+ * Find the topmost child under the given point within the parent view's
|
|
|
1546
|
+ * coordinate system. The child order is determined using
|
|
|
1547
|
+ * {@link me.imid.swipebacklayout.lib.ViewDragHelper.Callback#getOrderedChildIndex(int)}
|
|
|
1548
|
+ * .
|
|
|
1549
|
+ *
|
|
|
1550
|
+ * @param x X position to test in the parent's coordinate system
|
|
|
1551
|
+ * @param y Y position to test in the parent's coordinate system
|
|
|
1552
|
+ * @return The topmost child view under (x, y) or null if none found.
|
|
|
1553
|
+ */
|
|
|
1554
|
+ public View findTopChildUnder(int x, int y) {
|
|
|
1555
|
+ final int childCount = mParentView.getChildCount();
|
|
|
1556
|
+ for (int i = childCount - 1; i >= 0; i--) {
|
|
|
1557
|
+ final View child = mParentView.getChildAt(mCallback.getOrderedChildIndex(i));
|
|
|
1558
|
+ if (x >= child.getLeft() && x < child.getRight() && y >= child.getTop()
|
|
|
1559
|
+ && y < child.getBottom()) {
|
|
|
1560
|
+ return child;
|
|
|
1561
|
+ }
|
|
|
1562
|
+ }
|
|
|
1563
|
+ return null;
|
|
|
1564
|
+ }
|
|
|
1565
|
+
|
|
|
1566
|
+ private int getEdgeTouched(int x, int y) {
|
|
|
1567
|
+ int result = 0;
|
|
|
1568
|
+
|
|
|
1569
|
+ if (x < mParentView.getLeft() + mEdgeSize)
|
|
|
1570
|
+ result = EDGE_LEFT;
|
|
|
1571
|
+ if (y < mParentView.getTop() + mEdgeSize)
|
|
|
1572
|
+ result = EDGE_TOP;
|
|
|
1573
|
+ if (x > mParentView.getRight() - mEdgeSize)
|
|
|
1574
|
+ result = EDGE_RIGHT;
|
|
|
1575
|
+ if (y > mParentView.getBottom() - mEdgeSize)
|
|
|
1576
|
+ result = EDGE_BOTTOM;
|
|
|
1577
|
+
|
|
|
1578
|
+ return result;
|
|
|
1579
|
+ }
|
|
|
1580
|
+}
|
|
|
|
@@ -0,0 +1,6 @@
|
|
|
1
|
+<?xml version="1.0" encoding="utf-8"?>
|
|
|
2
|
+<com.android.views.swipebacklayout.SwipeBackLayout xmlns:android="http://schemas.android.com/apk/res/android"
|
|
|
3
|
+ android:id="@+id/swipe"
|
|
|
4
|
+ android:layout_width="match_parent"
|
|
|
5
|
+ android:layout_height="match_parent" />
|
|
|
6
|
+
|
|
|
|
@@ -73,4 +73,18 @@
|
|
73
|
73
|
</attr>
|
|
74
|
74
|
</declare-styleable>
|
|
75
|
75
|
|
|
|
76
|
+ <declare-styleable name="SwipeBackLayout">
|
|
|
77
|
+ <attr name="edge_size" format="dimension"/>
|
|
|
78
|
+ <attr name="edge_flag">
|
|
|
79
|
+ <enum name="left" value="0" />
|
|
|
80
|
+ <enum name="right" value="1" />
|
|
|
81
|
+ <enum name="bottom" value="2" />
|
|
|
82
|
+ <enum name="all" value="3" />
|
|
|
83
|
+ </attr>
|
|
|
84
|
+ <attr name="shadow_left" format="reference"/>
|
|
|
85
|
+ <attr name="shadow_right" format="reference"/>
|
|
|
86
|
+ <attr name="shadow_bottom" format="reference"/>
|
|
|
87
|
+ </declare-styleable>
|
|
|
88
|
+
|
|
|
89
|
+ <attr name="SwipeBackLayoutStyle" format="reference"/>
|
|
76
|
90
|
</resources>
|
|
|
|
@@ -6,21 +6,12 @@
|
|
6
|
6
|
<item name="android:background">@color/line_bg</item>
|
|
7
|
7
|
<item name="android:layout_margin">2dp</item>
|
|
8
|
8
|
</style>
|
|
9
|
|
- <declare-styleable name="SwipeLayout">
|
|
10
|
|
- <attr name="drag_edge">
|
|
11
|
|
- <flag name="left" value="1" />
|
|
12
|
|
- <flag name="right" value="2" />
|
|
13
|
|
- <flag name="top" value="4" />
|
|
14
|
|
- <flag name="bottom" value="8" />
|
|
15
|
|
- </attr>
|
|
16
|
|
- <attr name="leftEdgeSwipeOffset" format="dimension" />
|
|
17
|
|
- <attr name="rightEdgeSwipeOffset" format="dimension" />
|
|
18
|
|
- <attr name="topEdgeSwipeOffset" format="dimension" />
|
|
19
|
|
- <attr name="bottomEdgeSwipeOffset" format="dimension" />
|
|
20
|
|
- <attr name="show_mode" format="enum">
|
|
21
|
|
- <enum name="lay_down" value="0" />
|
|
22
|
|
- <enum name="pull_out" value="1" />
|
|
23
|
|
- </attr>
|
|
24
|
|
- <attr name="clickToClose" format="boolean" />
|
|
25
|
|
- </declare-styleable>
|
|
|
9
|
+
|
|
|
10
|
+ <style name="SwipeBackLayout">
|
|
|
11
|
+ <item name="edge_size">50dip</item>
|
|
|
12
|
+ <item name="shadow_left">@drawable/shadow_left</item>
|
|
|
13
|
+ <item name="shadow_right">@drawable/shadow_right</item>
|
|
|
14
|
+ <item name="shadow_bottom">@drawable/shadow_bottom</item>
|
|
|
15
|
+ </style>
|
|
|
16
|
+
|
|
26
|
17
|
</resources>
|
