android - Fling手势和检测的四个屏幕侧面的CustomDrawerLayout问题-6ren

android - Fling手势和检测的四个屏幕侧面的CustomDrawerLayout问题

转载作者：IT老高更新时间：2023-10-28 22:18:46

我正在尝试创建和改进现有的 SlidingDrawers 项目，这些项目可以在屏幕的所有四个侧面 {LEFT、RIGHT、TOP、BOTTOM} 上工作。有一些库，但是，它们都有局限性、复杂性和错误。比较常见的一个是 umano 的 AndroidSlidingUpPanel，但是，我不喜欢这个库，因为您必须只包含两个子布局，并且还需要注意主要内容到抽屉的特定安排。其他库类似，或者更复杂，或者有错误。

我即将完成我的 SlidingDrawers 版本，我专注于底部重力。我需要一些有关 throw 手势的帮助。单击抽屉将打开和关闭它。您也可以用手指滑动抽屉。但是如果你把抽屉一扔，整个 View 就会移动得高于或低于应有的位置。

我该如何解决这个问题？据我所知，我的数学是正确的。我传递给动画师的翻译值应该是正确的。下面是我完成的工作。请查看此项目https://github.com/drxeno02/CustomDrawerLayout.git .先感谢您。

对于那些想看看有问题的代码看起来如何的 fragment 的人，这里是我目前做手势的方式。

@Override
public boolean onInterceptTouchEvent(MotionEvent event) {
    switch (event.getAction()) {
        case MotionEvent.ACTION_DOWN:
            mActivePointerId = MotionEventCompat.getPointerId(event, 0);
            switch (mStickTo) {
                case GRAVITY_BOTTOM:
                case GRAVITY_TOP:
                    mInitialCoordinate = event.getY();
                    break;
                case GRAVITY_LEFT:
                case GRAVITY_RIGHT:
                    mInitialCoordinate = event.getX();
                    break;
            }
            break;

        case MotionEvent.ACTION_MOVE:

            float coordinate = 0;
            switch (mStickTo) {
                case GRAVITY_BOTTOM:
                case GRAVITY_TOP:
                    coordinate = event.getY();

                    break;
                case GRAVITY_LEFT:
                case GRAVITY_RIGHT:
                    coordinate = event.getX();
                    break;
            }

            final int diff = (int) Math.abs(coordinate - mInitialCoordinate);

            // confirm that difference is enough to indicate drag action
            if (diff > mTouchSlop) {
                // start capturing events
                Logger.d(TAG, "drag is being captured");
                return true;
            }
            break;

        case MotionEvent.ACTION_UP:
            if (!FrameworkUtils.checkIfNull(mVelocityTracker)) {
                mVelocityTracker.recycle();
                mVelocityTracker = null;
            }
            break;
    }
    // add velocity movements
    if (FrameworkUtils.checkIfNull(mVelocityTracker)) {
        mVelocityTracker = VelocityTracker.obtain();
    }
    mVelocityTracker.addMovement(event);

    return super.onInterceptTouchEvent(event);
}

@Override
public boolean onTouchEvent(@NonNull MotionEvent event) {
    if (event.getAction() == MotionEvent.ACTION_DOWN && event.getEdgeFlags() != 0) {
        return false;
    }

    // add velocity movements
    if (FrameworkUtils.checkIfNull(mVelocityTracker)) {
        mVelocityTracker = VelocityTracker.obtain();
    }
    mVelocityTracker.addMovement(event);

    final View parent = (View) getParent();
    final int coordinate;
    final int distance = getDistance();
    final int tapCoordinate;

    switch (mStickTo) {
        case GRAVITY_BOTTOM:
            coordinate = (int) event.getRawY();
            tapCoordinate = (int) event.getRawY();
            break;
        case GRAVITY_LEFT:
            coordinate = parent.getWidth() - (int) event.getRawX();
            tapCoordinate = (int) event.getRawX();
            break;
        case GRAVITY_RIGHT:
            coordinate = (int) event.getRawX();
            tapCoordinate = (int) event.getRawX();
            break;
        case GRAVITY_TOP:
            coordinate = getRawDisplayHeight(getContext()) - (int) event.getRawY();
            tapCoordinate = (int) event.getRawY();
            break;
        // if view position is not initialized throw an error
        default:
            throw new IllegalStateException("Failed to initialize coordinates");
    }

    switch (event.getAction() & MotionEvent.ACTION_MASK) {
        case MotionEvent.ACTION_DOWN:

            /*
             * Return the pointer identifier associated with a particular pointer data index is
             * this event. The identifier tells you the actual pointer number associated with
             * the data, accounting for individual pointers going up and down since the start
             * of the current gesture.
             */
            mActivePointerId = event.getPointerId(0);

            switch (mStickTo) {
                case GRAVITY_BOTTOM:
                    mDelta = coordinate - ((RelativeLayout.LayoutParams) getLayoutParams()).topMargin;
                    break;
                case GRAVITY_LEFT:
                    mDelta = coordinate - ((RelativeLayout.LayoutParams) getLayoutParams()).rightMargin;
                    break;
                case GRAVITY_RIGHT:
                    mDelta = coordinate - ((RelativeLayout.LayoutParams) getLayoutParams()).leftMargin;
                    break;
                case GRAVITY_TOP:
                    mDelta = coordinate - ((RelativeLayout.LayoutParams) getLayoutParams()).bottomMargin;
                    break;
            }

            mLastCoordinate = coordinate;
            mPressStartTime = System.currentTimeMillis();
            break;

        case MotionEvent.ACTION_MOVE:

            RelativeLayout.LayoutParams layoutParams = (RelativeLayout.LayoutParams) getLayoutParams();
            final int farMargin = coordinate - mDelta;
            final int closeMargin = distance - farMargin;

            switch (mStickTo) {
                case GRAVITY_BOTTOM:
                    if (farMargin > distance && closeMargin > mOffsetHeight - getHeight()) {
                        layoutParams.bottomMargin = closeMargin;
                        layoutParams.topMargin = farMargin;
                    }
                    break;
                case GRAVITY_LEFT:
                    if (farMargin > distance && closeMargin > mOffsetHeight - getWidth()) {
                        layoutParams.leftMargin = closeMargin;
                        layoutParams.rightMargin = farMargin;
                    }
                    break;
                case GRAVITY_RIGHT:
                    if (farMargin > distance && closeMargin > mOffsetHeight - getWidth()) {
                        layoutParams.rightMargin = closeMargin;
                        layoutParams.leftMargin = farMargin;
                    }
                    break;
                case GRAVITY_TOP:
                    if (farMargin > distance && closeMargin > mOffsetHeight - getHeight()) {
                        layoutParams.topMargin = closeMargin;
                        layoutParams.bottomMargin = farMargin;
                    }
                    break;
            }
            setLayoutParams(layoutParams);
            break;

        case MotionEvent.ACTION_UP:

            final int diff = coordinate - mLastCoordinate;
            final long pressDuration = System.currentTimeMillis() - mPressStartTime;

            switch (mStickTo) {
                case GRAVITY_BOTTOM:

                    // determine if fling
                    int relativeVelocity;
                    final VelocityTracker velocityTracker = mVelocityTracker;
                    velocityTracker.computeCurrentVelocity(1000, mMaximumVelocity);
                    final int initialVelocityY = (int) VelocityTrackerCompat.getYVelocity(
                            velocityTracker, mActivePointerId);
                    relativeVelocity = initialVelocityY * -1;
                    // take absolute value to have positive values
                    final int absoluteVelocity = Math.abs(relativeVelocity);

                    if (Math.abs(diff) > mFlingDistance && absoluteVelocity > mMinimumVelocity) {
                        if (tapCoordinate > parent.getHeight() - mOffsetHeight &&
                                mLockMode == LockMode.LOCK_MODE_CLOSED) {
                            notifyActionAndAnimateForState(LockMode.LOCK_MODE_OPEN, parent.getHeight() - mOffsetHeight, true);
                        } else if (Math.abs(getRawDisplayHeight(getContext()) -
                                tapCoordinate - getHeight()) < mOffsetHeight &&
                                mLockMode == LockMode.LOCK_MODE_OPEN) {
                            notifyActionAndAnimateForState(LockMode.LOCK_MODE_CLOSED, parent.getHeight() - mOffsetHeight, true);
                        }
                    } else {
                        if (isClicked(getContext(), diff, pressDuration)) {
                            if (tapCoordinate > parent.getHeight() - mOffsetHeight &&
                                    mLockMode == LockMode.LOCK_MODE_CLOSED) {
                                notifyActionAndAnimateForState(LockMode.LOCK_MODE_OPEN, parent.getHeight() - mOffsetHeight, true);
                            } else if (Math.abs(getRawDisplayHeight(getContext()) -
                                    tapCoordinate - getHeight()) < mOffsetHeight &&
                                    mLockMode == LockMode.LOCK_MODE_OPEN) {
                                notifyActionAndAnimateForState(LockMode.LOCK_MODE_CLOSED, parent.getHeight() - mOffsetHeight, true);
                            }
                        } else {
                            smoothScrollToAndNotify(diff);
                        }
                    }
                    break;
                case GRAVITY_TOP:
                    if (isClicked(getContext(), diff, pressDuration)) {
                        final int y = getLocationInYAxis(this);
                        if (tapCoordinate - Math.abs(y) <= mOffsetHeight &&
                                mLockMode == LockMode.LOCK_MODE_CLOSED) {
                            notifyActionAndAnimateForState(LockMode.LOCK_MODE_OPEN, parent.getHeight() - mOffsetHeight, true);
                        } else if (getHeight() - (tapCoordinate - Math.abs(y)) < mOffsetHeight &&
                                mLockMode == LockMode.LOCK_MODE_OPEN) {
                            notifyActionAndAnimateForState(LockMode.LOCK_MODE_CLOSED, parent.getHeight() - mOffsetHeight, true);
                        }
                    } else {
                        smoothScrollToAndNotify(diff);
                    }
                    break;
                case GRAVITY_LEFT:
                    if (isClicked(getContext(), diff, pressDuration)) {
                        if (tapCoordinate <= mOffsetHeight &&
                                mLockMode == LockMode.LOCK_MODE_CLOSED) {
                            notifyActionAndAnimateForState(LockMode.LOCK_MODE_OPEN, getWidth() - mOffsetHeight, true);
                        } else if (tapCoordinate > getWidth() - mOffsetHeight &&
                                mLockMode == LockMode.LOCK_MODE_OPEN) {
                            notifyActionAndAnimateForState(LockMode.LOCK_MODE_CLOSED, getWidth() - mOffsetHeight, true);
                        }
                    } else {
                        smoothScrollToAndNotify(diff);
                    }
                    break;
                case GRAVITY_RIGHT:
                    if (isClicked(getContext(), diff, pressDuration)) {
                        if (parent.getWidth() - tapCoordinate <= mOffsetHeight &&
                                mLockMode == LockMode.LOCK_MODE_CLOSED) {
                            notifyActionAndAnimateForState(LockMode.LOCK_MODE_OPEN, getWidth() - mOffsetHeight, true);
                        } else if (parent.getWidth() - tapCoordinate > getWidth() - mOffsetHeight &&
                                mLockMode == LockMode.LOCK_MODE_OPEN) {
                            notifyActionAndAnimateForState(LockMode.LOCK_MODE_CLOSED, getWidth() - mOffsetHeight, true);
                        }
                    } else {
                        smoothScrollToAndNotify(diff);
                    }
                    break;
            }
            break;
    }
    return true;
}

/**
 * Method is used to animate the view to the given position
 *
 * @param diff
 */
private void smoothScrollToAndNotify(int diff) {
    int length = getLength();
    LockMode stateToApply;
    if (diff > 0) {
        if (diff > length / 2.5) {
            stateToApply = LockMode.LOCK_MODE_CLOSED;
            notifyActionAndAnimateForState(stateToApply, getTranslationFor(stateToApply), true);
        } else if (mLockMode == LockMode.LOCK_MODE_OPEN) {
            stateToApply = LockMode.LOCK_MODE_OPEN;
            notifyActionAndAnimateForState(stateToApply, getTranslationFor(stateToApply), false);
        }
    } else {
        if (Math.abs(diff) > length / 2.5) {
            stateToApply = LockMode.LOCK_MODE_OPEN;
            notifyActionAndAnimateForState(stateToApply, getTranslationFor(stateToApply), true);
        } else if (mLockMode == LockMode.LOCK_MODE_CLOSED) {
            stateToApply = LockMode.LOCK_MODE_CLOSED;
            notifyActionAndAnimateForState(stateToApply, getTranslationFor(stateToApply), false);
        }
    }
}

/**
 * Method is used to retrieve dimensions meant for translation
 *
 * @param stateToApply
 * @return
 */
private int getTranslationFor(LockMode stateToApply) {

    switch (mStickTo) {
        case GRAVITY_BOTTOM:
            switch (stateToApply) {
                case LOCK_MODE_OPEN:
                    return getHeight() - (getRawDisplayHeight(getContext()) - getLocationInYAxis(this));

                case LOCK_MODE_CLOSED:
                    return getRawDisplayHeight(getContext()) - getLocationInYAxis(this) - mOffsetHeight;
            }
            break;
        case GRAVITY_TOP:
            final int actionBarDiff = getRawDisplayHeight(getContext()) - ((View) getParent()).getHeight();
            final int y = getLocationInYAxis(this) + getHeight();

            switch (stateToApply) {
                case LOCK_MODE_OPEN:
                    return getHeight() - y + actionBarDiff;

                case LOCK_MODE_CLOSED:
                    return y - mOffsetHeight - actionBarDiff;
            }
            break;
        case GRAVITY_LEFT:
            final int x = getLocationInXAxis(this) + getWidth();
            switch (stateToApply) {
                case LOCK_MODE_OPEN:
                    return getWidth() - x;

                case LOCK_MODE_CLOSED:
                    return x - mOffsetHeight;
            }
            break;
        case GRAVITY_RIGHT:
            switch (stateToApply) {
                case LOCK_MODE_OPEN:
                    return getWidth() - (getRawDisplayWidth(getContext()) - getLocationInXAxis(this));

                case LOCK_MODE_CLOSED:
                    return getRawDisplayWidth(getContext()) - getLocationInXAxis(this) - mOffsetHeight;
            }
            break;
    }
    throw new IllegalStateException("Failed to return translation for drawer");
}

/**
 * Method is used to perform the animations
 *
 * @param stateToApply
 * @param translation
 * @param notify
 */
private void notifyActionAndAnimateForState(final LockMode stateToApply,
                                            final int translation, final boolean notify) {

    switch (mStickTo) {
        case GRAVITY_BOTTOM:
            switch (stateToApply) {
                case LOCK_MODE_OPEN:
                    animate().translationY(-translation)
                            .setDuration(TRANSLATION_ANIM_DURATION)
                            .setInterpolator(new DecelerateInterpolator())
                            .setListener(new AnimatorListenerAdapter() {
                                @Override
                                public void onAnimationEnd(Animator animation) {
                                    super.onAnimationEnd(animation);
                                    notifyActionForState(stateToApply, notify);
                                    setTranslationY(0);
                                }
                            });
                    break;
                case LOCK_MODE_CLOSED:
                    animate().translationY(translation)
                            .setDuration(TRANSLATION_ANIM_DURATION)
                            .setInterpolator(new DecelerateInterpolator())
                            .setListener(new AnimatorListenerAdapter() {
                                @Override
                                public void onAnimationEnd(Animator animation) {
                                    super.onAnimationEnd(animation);
                                    notifyActionForState(stateToApply, notify);
                                    setTranslationY(0);
                                }
                            });
                    break;
            }
            break;
        case GRAVITY_TOP:
            switch (stateToApply) {
                case LOCK_MODE_OPEN:
                    animate().translationY(translation)
                            .setDuration(TRANSLATION_ANIM_DURATION)
                            .setInterpolator(new DecelerateInterpolator())
                            .setListener(new AnimatorListenerAdapter() {
                                @Override
                                public void onAnimationEnd(Animator animation) {
                                    super.onAnimationEnd(animation);
                                    notifyActionForState(stateToApply, notify);
                                    setTranslationY(0);
                                }
                            });
                    break;
                case LOCK_MODE_CLOSED:
                    animate().translationY(-translation)
                            .setDuration(TRANSLATION_ANIM_DURATION)
                            .setInterpolator(new DecelerateInterpolator())
                            .setListener(new AnimatorListenerAdapter() {
                                @Override
                                public void onAnimationEnd(Animator animation) {
                                    super.onAnimationEnd(animation);
                                    notifyActionForState(stateToApply, notify);
                                    setTranslationY(0);
                                }
                            });
                    break;
            }
            break;
        case GRAVITY_LEFT:
            switch (stateToApply) {
                case LOCK_MODE_OPEN:
                    animate().translationX(translation)
                            .setDuration(TRANSLATION_ANIM_DURATION)
                            .setInterpolator(new DecelerateInterpolator())
                            .setListener(new AnimatorListenerAdapter() {
                                @Override
                                public void onAnimationEnd(Animator animation) {
                                    super.onAnimationEnd(animation);
                                    notifyActionForState(stateToApply, notify);
                                    setTranslationX(0);
                                }
                            });
                    break;
                case LOCK_MODE_CLOSED:
                    animate().translationX(-translation)
                            .setDuration(TRANSLATION_ANIM_DURATION)
                            .setInterpolator(new DecelerateInterpolator())
                            .setListener(new AnimatorListenerAdapter() {
                                @Override
                                public void onAnimationEnd(Animator animation) {
                                    super.onAnimationEnd(animation);
                                    notifyActionForState(stateToApply, notify);
                                    setTranslationX(0);
                                }
                            });
                    break;
            }
            break;
        case GRAVITY_RIGHT:
            switch (stateToApply) {
                case LOCK_MODE_OPEN:
                    animate().translationX(-translation)
                            .setDuration(TRANSLATION_ANIM_DURATION)
                            .setInterpolator(new DecelerateInterpolator())
                            .setListener(new AnimatorListenerAdapter() {
                                @Override
                                public void onAnimationEnd(Animator animation) {
                                    super.onAnimationEnd(animation);
                                    notifyActionForState(stateToApply, notify);
                                    setTranslationX(0);
                                }
                            });
                    break;
                case LOCK_MODE_CLOSED:
                    animate().translationX(translation)
                            .setDuration(TRANSLATION_ANIM_DURATION)
                            .setInterpolator(new DecelerateInterpolator())
                            .setListener(new AnimatorListenerAdapter() {
                                @Override
                                public void onAnimationEnd(Animator animation) {
                                    super.onAnimationEnd(animation);
                                    notifyActionForState(stateToApply, notify);
                                    setTranslationX(0);
                                }
                            });
                    break;
            }
            break;
    }
}

补充说明:我对这个问题有更深入的了解。我注释掉了 ACTION_MOVE 以消除抽屉在 throw Action 之前移动的位置。动画完美运行。我相信我的想法是正确的。为了获得“开放”的翻译，我会这样做

getHeight() - (getRawDisplayHeight(getContext()) - getLocationInYAxis(this))

getHeight() 是抽屉的高度
getRawDisplayHeight(getContext()) 是设备屏幕的高度
getLocationInYAxis(this)，当ACTION_MOVE出图时，是有效地 (getRawDisplayHeight(getContext()) - mOffsetHeight)。在
在这种情况下，它们应该可以互换。

所以，剩下的就是平移所需的距离。但是，一旦抽屉被拖动 x 距离，我希望 getLocationInYAxis(this) 会返回拖动位置。但计算已关闭。

最佳答案

看来你应该使用 getTranslationFor 函数来计算状态的新翻译。

您目前只考虑高度和偏移量，但从 getTranslationFor 代码看来，您还应该考虑 getLocationInYAxis。

所以，而不是这一行:

notifyActionAndAnimateForState(LockMode.LOCK_MODE_OPEN, parent.getHeight() - mOffsetHeight, true);

试试这条线:

notifyActionAndAnimateForState(LockMode.LOCK_MODE_OPEN, getTranslationFor(LockMode.LOCK_MODE_OPEN), true);

关于android - Fling手势和检测的四个屏幕侧面的CustomDrawerLayout问题，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/43265226/

文章推荐： python - render_template 和重定向之间的区别？

文章推荐： python - 如何对 2D numpy 数组求平方或求幂(按元素)？

文章推荐： Android:是否有在任何 Android 设备上发送彩信的通用方法？

iPhone UIPickerView 手势
我将如何向 uipickerview 添加手势事件来更改选项卡？我必须创建一个自定义类，但是，我不知道如何处理 uipickerview。我当前在 uiviews 中存在手势来执行此操作，但我在使用
android - 手势 - 手指运动时显示坐标
我需要创建一个 Activity ，当您在屏幕上拖动手指时，显示 XY 坐标(手指移动的位置)。谁能帮帮我？最佳答案 OnTouch 您需要为想要识别拖动的任何 View 实现一个 OnTouchL
opencv - 手势/姿势识别的特征提取方法
我目前正在开发手语识别应用程序，我想在其中使用隐马尔可夫模型作为分类阶段，这意味着我将对手势/姿势进行分类以获得相关的字母或单词。我目前已经完成了检测手的第一阶段。目前我可以获得许多可用于我的机器学
Python PyQT 手势
我想在我的应用程序中启用 PyQT 手势。有人有一个示例或一些简短的代码可以演示在 PyQT 应用程序中使用手势控制吗？我尝试谷歌搜索，但只能找到一篇关于自定义手势的帖子...我还没有那么远，我只是
在开始屏幕上使用的 Android 手势
什么 Android Api 用于在 Android 的开始屏幕上向左或向右滚动？最佳答案最简单的方法是检测“Fling”手势。 android API 有一个内置的检测器，用于检测基本手势，如滑
图像上的 Android 手势
按照目前的情况，这个问题不适合我们的问答形式。我们希望答案得到事实、引用或专业知识的支持，但这个问题可能会引发辩论、争论、投票或扩展讨论。如果您觉得这个问题可以改进并可能重新打开，visit the
firefox - 如何禁用 Firefox 手势？
我讨厌 Firefox 的手势，我只想点击，但如果我的 Action 在点击过程中抖动，就会一团糟! 如何禁用 Firefox 手势？最佳答案您需要更改配置，您可以通过键入 about:confi
ios - 在我自己的应用程序中使用“滑动后退”手势
我正在构建一个iOS应用程序，该应用程序需要与在Safari中来回滑动时看到的效果相同的效果。滑动后退时，前景面板会移开，但背面的面板也会移动一点。与Yahoo Weather应用程序中的水平滚动非
java - 从屏幕外滑动检测触摸/滑动/手势
我想做一些类似默认通知状态栏的东西(可从屏幕顶部扩展)。当用户在屏幕外触摸手机并将手指向下移动时，如何检测触摸？ OnTouch 监听器仅在用户在屏幕上启动时工作。最佳答案在 html-js 中，
c# - 手势 FreeDrag 性能
我有一个简单的问题，我正在尝试为 Windows Phone 制作一款大型游戏，但我仍然遇到一个重要的瓶颈/问题/性能不佳。我用过 mango profiler，但我没有发现任何问题，事实上它在我的
java - Android 手势、单笔划和多笔划产生不一致的结果
我在按照此处的手势教程进行操作时遇到了一个非常奇怪的问题:http://developer.android.com/resources/articles/gestures.html . 在 Gestu
ios - 滑动 ios 手势
我正在尝试创建一个简单的应用程序，用户可以在其中将手指保持在屏幕上的同时向左然后向右滑动。我想计算他们总共进行了多少次滑动，包括方向的改变。我正在使用带方向的 uiswipegesture，但它只在新
objective-c - CGAffineTransformmakeScale + 手势
我有一个问题。有一个uiview，它是通过手势控制的(可以水平移动)。虽然这个 uiview 很小，但一切都很好。在使用 CGAffineTransformScale 缩放它之后，奇怪的事情开始了:
iphone - UIWebview 手势 iOS
如何在 UIWebview 中识别用户 touch、tap 和 double tap。是否有可用的代表，例如触摸开始等？最佳答案这是在webview上实现单击和双击的代码 UITapGesture
ios - 禁用 UIScrollView 手势
我创建了一个自定义 ScrollView 类，它使用两个 subview ，它们可以滚动(启用分页)以在屏幕上当前显示任何一个 View 。我想做的是更改它，以便第二个 View 仅在点击特定按钮时
c++ - 向事件窗口发送 GID_ZOOM 手势
如何向当前事件窗口发送缩放手势？我尝试创建一个 GESTUREINFO 结构，但我不知道如何正确传递该结构。到目前为止，这是我得到的。 GESTUREINFO gi; POINT pt; ZeroMe
Android NYTimes 滑动动画/手势
纽约时报有一个非常有趣的翻页功能。您可以从左向右/从右向左滑动以查看其他项目(这很容易实现)。即使您没有超过阈值， View 也会随着您的手指移动并在您抬起手指后回滚到初始 View 。他们是怎么做到
ios - 如何以编程方式模拟 "pinch out"手势？
我正在开发 iOS 应用。我添加了一个 UIPinchGestureRecognizer 来监听双指张开 Action 。 [[self view]addGestureRecognizer:[[UI
ios - 通过单击按钮重置 iOS 手势
我有一个允许用户平移和放大图像的应用程序。我认为，没有太多麻烦，用户可以让自己进入一种状态，他们放大了图像的一部分，并希望将所有内容重置回“基态”(即，将所有翻译和分别重新缩放回 0 和 1)。我正
android - 手势 onSingleTapConfirmed 奇怪的行为
我相信你聪明的头脑和强大的机器人技能。我有点卡住了。我有以下情况。我创建了用于学习如何使用手势和 Canvas 的应用程序。想法很简单，当我在屏幕上点击一次，我点击的地方应该出现气泡(R.draw

IT老高

个人简介

我是一名优秀的程序员,十分优秀！

作者热门文章

滴滴打车优惠券免费领取

全站热门文章

首页

博学

6Ren·AI

商城

android - Fling手势和检测的四个屏幕侧面的CustomDrawerLayout问题