自定义view之无限滚动的刻度尺

别再只用picker了!用scroll-view手搓一个微信小程序刻度尺组件(附完整源码) 本文详细介绍了如何利用微信小程序的scroll-view组件开发一个高度可定制的刻度尺组件,替代原生picker组件,适用于医疗健康、健身记录等专业场景。通过核心算法设计、性能优化和动态渲染策略,实现流畅交互与高复用性,并附完整源码供开发者直接集成。 阅读详情

具体思路是把一个view分成三段,当总长度>=40个刻度向左滚动,滚动到2/3的时候view移动到1/3出然后刷新显示的刻度这时为第一页,一次更新页数,当向右滚动的时候滚动且不为第一页则每滚动到1/3处view移动到2/3处。之后在添加一些首页和最后一页的判断。
这一次除了无限滚动还比我上一次写的多了手指滑动速度的判断,去掉了滚动结束自动归位到对应刻度的效果,代码中除了极端情况默认使用的view显示的刻度为30个,也就是说除了开始和结束,显示的位置始终在10~20之间,向右拖动图示:
无标题.png

效果展示:
GIF.gif

核心代码

package com.zqb.scrolldividingrule;

import android.annotation.SuppressLint;
import android.content.Context;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Paint;
import android.os.Handler;
import android.os.Looper;
import android.support.annotation.Nullable;
import android.util.AttributeSet;
import android.view.MotionEvent;
import android.view.VelocityTracker;
import android.view.View;
import android.widget.Scroller;
import java.util.ArrayList;

/**
 * 横向滚动的刻度尺
 * Created by zhangqingbin on 2018/1/5.
 */

public class ScrollDividingRuleView extends View {

  private Scroller mScroller;
  private Paint mPaint;
  private VelocityTracker mVelocityTracker;
  private OnScrollListener mListener;
  private int mScaleMargin; //刻度间距
  private float mScaleWidth; //总刻度宽度
  private float mTextSize;//文字大小
  private ArrayList<String> mTextList;//刻度文字
  private ArrayList<String> mTotalTextList;//所有的刻度
  private float mLineHeight;//线高度
  private int mRectHeight;//总高度
  private int mScrollLastX;
  private int mInitDistance;//初始距离
  private int mInitPosition;//初始位置
  private int mTextLineMargin;//文字距线的距离
  private int mPage;//当前为复用所在页
  private long mLastInstance;//余数刻度
  private long mStartMoney;//开始金额
  private int mUnit;//每个小格的单位
  private long mFinalMoney;//结束金额

  public ScrollDividingRuleView(Context context) {
    this(context, null);
  }

  public ScrollDividingRuleView(Context context, @Nullable AttributeSet attrs) {
    this(context, attrs, 0);
  }

  public ScrollDividingRuleView(Context context, @Nullable AttributeSet attrs, int defStyleAttr) {
    super(context, attrs, defStyleAttr);
    setWillNotDraw(false);
    init(context, attrs);
  }

  private void init(Context context, @Nullable AttributeSet attrs) {
    if (attrs != null) {
      for (int i = 0; i < attrs.getAttributeCount(); i++) {
        String name = attrs.getAttributeName(i);
        if ("layout_width".equals(name)) {
          String value = attrs.getAttributeValue(i);
          if (value.length() > 2) {
            if (value.endsWith("dp")) {
              float margin = Float.valueOf(value.substring(0, value.length() - 2));
              mScaleWidth = Utils.dp2px(context, margin);
            } else {
              mScaleWidth = Float.valueOf(value.substring(0, value.length() - 2));
            }
          } else if (value.equals("-1") || value.equals("-2") || value.equals("0")) {
            mScaleWidth = 0;
          }
        } else if ("line_height".equals(name)) {
          String value = attrs.getAttributeValue(i);
          if (value.length() > 2) {
            if (value.endsWith("dp")) {
              mLineHeight =
                  Utils.dp2px(context, Float.valueOf(value.substring(0, value.length() - 2)));
            } else {
              mLineHeight = Float.valueOf(value.substring(0, value.length() - 2));
            }
          } else {
            mLineHeight = 50;
          }
        } else if ("dividing_text_size".equals(name)) {
          String value = attrs.getAttributeValue(i);
          if (value.length() > 2) {
            if (value.endsWith("sp")) {
              mTextSize =
                  Utils.sp2px(context, Float.valueOf(value.substring(0, value.length() - 2)));
            } else {
              mTextSize = Float.valueOf(value.substring(0, value.length() - 2));
            }
          } else {
            mTextSize = 32;
          }
        }
      }
    }
    // 画笔
    mPaint = new Paint();
    //总的高度,因为text的高度和设置的textSize会有误差所以加上20的高度
    mRectHeight = (int) (mLineHeight + mTextSize + mTextLineMargin + 20);
    //初始设置每个刻度间距为30px
    mScaleMargin = 20;
    mTextList = new ArrayList<>();
    mTotalTextList = new ArrayList<>();
    mScroller = new Scroller(context);
  }

  @Override
  protected void onDraw(Canvas canvas) {
    mPaint.setColor(Color.GRAY);
    // 抗锯齿
    mPaint.setAntiAlias(true);
    // 设定是否使用图像抖动处理,会使绘制出来的图片颜色更加平滑和饱满,图像更加清晰
    mPaint.setDither(true);
    // 空心
    mPaint.setStyle(Paint.Style.STROKE);
    // 文字居中
    mPaint.setTextAlign(Paint.Align.CENTER);
    onDrawScale(canvas, mPaint); //画刻度
    onDrawLine(canvas, mPaint);//画刻度中间横线
    super.onDraw(canvas);
  }

  @Override
  protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
    int height = MeasureSpec.makeMeasureSpec(mRectHeight, MeasureSpec.AT_MOST);
    super.onMeasure(widthMeasureSpec, height);
    //初始化开始位置
    mInitDistance = getMeasuredWidth() / 2 - mInitPosition * mScaleMargin * 10;
  }

  @SuppressLint("ClickableViewAccessibility")
  @Override
  public boolean onTouchEvent(MotionEvent event) {
    if (mVelocityTracker == null) {
      mVelocityTracker = VelocityTracker.obtain();
    }
    mVelocityTracker.addMovement(event);
    int x = (int) event.getX();
    int startX = 0;
    switch (event.getAction()) {
      case MotionEvent.ACTION_DOWN:
        if (mScroller != null) {//重新初始化fling效果,防止下一次移动有初始速度
          mScroller.fling(mScroller.getFinalX(), mScroller.getFinalY(), 0, 0, 0,
              (int) (mScaleWidth - mInitPosition * mScaleMargin * 10), 0, 0);
          mScroller.abortAnimation();
        }
        startX = x;
        mScrollLastX = x;
        return true;
      case MotionEvent.ACTION_MOVE:
        int dataX = mScrollLastX - x;
        smoothScrollBy(dataX, 0);
        mScrollLastX = x;
        return true;
      case MotionEvent.ACTION_CANCEL:
      case MotionEvent.ACTION_UP:
        dealActionUp(x - startX);
        return true;
    }
    return super.onTouchEvent(event);
  }

  /**
   * 处理手势抬起之后的操作
   *
   * @param i 根据正负判断方向
   */
  private void dealActionUp(int i) {
    mVelocityTracker.computeCurrentVelocity(1000);
    if (mScroller.getFinalX() >= mScaleMargin * 10 * 10 * 2 - 10 * mScaleMargin && i > 0) {
      if (!notifyDataChanged(0)) {
        dealFling();
      }
    } else if (mScroller.getFinalX() <= mScaleMargin * 10 * 10 - 10 * mScaleMargin && i < 0) {
      if (!notifyDataChanged(1)) {
        dealFling();
      }
    } else {
      dealFling();
    }
    long i1 = mPage > 0 ? mPage * 100 : 0;
    if (mListener != null) {
      mListener.onScaleScrollChanged(
          mScroller.getFinalX() / mScaleMargin + mInitPosition * 10 + i1 + mStartMoney);//返回滚动选中的位置
    }
    mVelocityTracker.clear();
    mVelocityTracker.recycle();
    mVelocityTracker = null;
  }

  /**
   * 处理手指抬起之后的减速滚动
   */
  private void dealFling() {
    int minX;//最小值
    if (mPage == 0) {
      minX = -mInitPosition * mScaleMargin * 10;
    } else {
      minX = -mInitPosition * mScaleMargin * 10 + mScaleMargin * 10 * 10 - mScaleMargin * 10;
    }
    int maxX;//最大值 根据位置和总数改变
    if (mPage == (mTotalTextList.size() - 20) / 10 - 1 || mTotalTextList.size() < 40) {
      maxX = (int) (mScaleWidth - mInitPosition * mScaleMargin * 10);
    } else {
      maxX = mScaleMargin * 10 * 20 - mScaleMargin * 10;
    }
    mScroller.fling(mScroller.getFinalX(), mScroller.getFinalY(),
        -(int) mVelocityTracker.getXVelocity(), 0, minX, maxX, 0, 0);
  }

  private void onDrawScale(Canvas canvas, Paint paint) {
    paint.setAntiAlias(true);
    paint.setTextSize(mTextSize);
    paint.setStyle(Paint.Style.FILL);
    for (int i = 0, k = 0; i < mTextList.size() * 10; i++) {
      if (i < mTextList.size() * 10 - 9) {
        if (i % 10 == 0) { //整值
          paint.setColor(Color.GRAY);
          canvas.drawLine(i * mScaleMargin + mInitDistance, mRectHeight,
              i * mScaleMargin + mInitDistance, mRectHeight - mLineHeight - mTextLineMargin + 20,
              paint);
          //整值文字
          paint.setColor(Color.GRAY);
          canvas.drawText(mTextList.get(k), i * mScaleMargin + mInitDistance,
              mRectHeight - mLineHeight - mTextLineMargin, paint);
          k++;
        } else {
          paint.setColor(Color.GRAY);
          canvas.drawLine(i * mScaleMargin + mInitDistance, mRectHeight,
              i * mScaleMargin + mInitDistance, mRectHeight - mLineHeight / 2 - mTextLineMargin,
              paint);
        }
      } else {//画滚动到末尾余数 30200
        if (mPage == (mTotalTextList.size() - 20) / 10 - 1 || mTotalTextList.size() < 40) {
          if ((mLastInstance / mScaleMargin) > 0
              && (mLastInstance / mScaleMargin) > i - (mTextList.size() * 10 - 9)) {
            paint.setColor(Color.GRAY);
            canvas.drawLine(i * mScaleMargin + mInitDistance, mRectHeight,
                i * mScaleMargin + mInitDistance, mRectHeight - mLineHeight / 2 - mTextLineMargin,
                paint);
          }
        }
      }
    }
  }

  private void onDrawLine(Canvas canvas, Paint paint) {
    paint.setStrokeWidth(2);
    canvas.drawLine(mInitDistance, mRectHeight, mScaleWidth + mInitDistance, mRectHeight, paint);
  }

  /**
   * 使用Scroller的时候需要重写该方法
   */
  @Override
  public void computeScroll() {
    if (mScroller.computeScrollOffset()) {
      scrollTo(mScroller.getCurrX(), 0);
      postInvalidate();
    }
  }

  private void smoothScrollBy(int dx, int dy) {
    if (mScroller.getFinalX() >= mScaleMargin * 10 * 10 * 2 - 10 * mScaleMargin
        && dx > 0) {//向左滚动,判断是否滚动到第三部分起始位置
      if (!notifyDataChanged(0)) {
        mScroller.startScroll(mScroller.getFinalX(), mScroller.getFinalY(), dx, dy);
      }
    } else if (mScroller.getFinalX() <= mScaleMargin * 10 * 10 - 10 * mScaleMargin
        && dx < 0) {///向右滚动,判断是否滚动到第二部分开始位置
      if (!notifyDataChanged(1)) {
        mScroller.startScroll(mScroller.getFinalX(), mScroller.getFinalY(), dx, dy);
      }
    } else {//否则根据手指滚动
      mScroller.startScroll(mScroller.getFinalX(), mScroller.getFinalY(), dx, dy);
    }
    postInvalidate();
  }

  public interface OnScrollListener {
    void onScaleScrollChanged(long scale);
  }

  /**
   * 设置当前位置
   *
   * @param scale 刻度
   */
  public void setNowScale(float scale) {
    float i = scale * mScaleMargin;
    int maxPage = (mTotalTextList.size() - 20) / 10 - 1;
    mPage = 0;
    if (mTotalTextList.size() < 40) {//如果总数小于40 不需要处理多页
      mPage = 0;
      smoothScrollBy((int) (i - mScroller.getFinalX()), 0);
      return;
    } else if (i < mScaleMargin * 10 * 10 * 2 - mScaleMargin * 10) {//判断刻度是否在第一页
      mPage = 0;
    } else if (scale >= 10 * 10 + maxPage * 10 * 10) {//判断刻度是否在最后一页
      mPage = maxPage;
    } else {
      mPage = (int) (scale / 100 - 1);
    }
    if (scale * mUnit >= mFinalMoney) {//如果要设置的刻度大于集合里的最大值 则只滚动到末尾
      mPage = maxPage;
      mTextList.clear();
      for (int j = mPage * 10; j < mTotalTextList.size(); j++) {
        mTextList.add(mTotalTextList.get(j));
      }
      mScaleWidth = (mTextList.size() * 10 - 10) * mScaleMargin + mLastInstance;
      smoothScrollBy((int) (mScaleWidth - mScroller.getFinalX()), 0);
    } else {
      if (mPage == (mTotalTextList.size() - 20) / 10 - 1) {//判断是否是最后一页
        if (mTotalTextList.size() >= mPage * 10 + 30) {
          mTextList.clear();
          for (int j = mPage * 10; j < mTotalTextList.size(); j++) {//更新刻度
            mTextList.add(mTotalTextList.get(j));
          }
          mScaleWidth = (mTextList.size() * 10 - 10) * mScaleMargin + mLastInstance;//加上余数的宽度
          smoothScrollBy((int) (i - ((mPage + 1) * 10 * 10 * mScaleMargin) + 10 * 10 * mScaleMargin
              - mScroller.getFinalX()), 0);
        }
      } else {
        if (mTotalTextList.size() >= mPage * 10 + 30) {
          mTextList.clear();
          for (int j = mPage * 10; j < mPage * 10 + 30; j++) {//更新刻度
            mTextList.add(mTotalTextList.get(j));
          }
          mScaleWidth = (mTextList.size() * 10 - 10) * mScaleMargin;
          smoothScrollBy((int) (i - ((mPage + 1) * 10 * 10 * mScaleMargin) + 10 * 10 * mScaleMargin
              - mScroller.getFinalX()), 0);
        }
      }
    }
  }

  /**
   * 初始化数据
   *
   * @param startMoney 开始金额
   * @param finalMoney 最终金额
   * @param unit 每个刻度单位
   * @param listener 滚动监听
   */
  public void bindMoneyData(int startMoney, int finalMoney, int unit, OnScrollListener listener) {
    if (mTotalTextList != null && mTotalTextList.size() > 0) {
      refresh(startMoney, finalMoney);
    } else {
      mPage = 0;
      mUnit = unit;
      mStartMoney = startMoney / unit;
      mTextList = new ArrayList<>();
      mTotalTextList = new ArrayList<>();
      mFinalMoney = finalMoney;
      for (int i = 0; i < (finalMoney - startMoney) / (unit * 10) + 1; i++) {
        if (i < 30 || (finalMoney - startMoney) / (unit * 10) + 1 < 40) {//当前显示刻度数
          mTextList.add(String.valueOf(i * unit * 10 + startMoney));
        }
        mTotalTextList.add(String.valueOf(i * unit * 10 + startMoney));//总共刻度数
      }
      mLastInstance = ((finalMoney - startMoney) % (unit * 10)) / 100 * mScaleMargin;//余数刻度
      if (mTotalTextList.size() < 40) {
        mScaleWidth = (mTextList.size() * 10 - 10) * mScaleMargin + mLastInstance;
      } else {
        mScaleWidth = (mTextList.size() * 10 - 10) * mScaleMargin;
      }
      mListener = listener;
      postInvalidate();
    }
  }

  /**
   * 判断更新当前页
   *
   * @param type 0左滑  1右滑
   * @return 是否处理了滚动到对应页
   */
  private boolean notifyDataChanged(int type) {
    if (mTotalTextList.size() < 40) {
      return false;
    }
    if (type == 0) {//向前移动
      if ((mTotalTextList.size() - 20) / 10 - 1 == 0) {
        return false;
      }
      if (mPage < (mTotalTextList.size() - 20) / 10 - 1) {
        mPage++;
        if (mPage == (mTotalTextList.size() - 20) / 10 - 1) {
          if (mTotalTextList.size() >= mPage * 10 + 30) {
            mTextList.clear();
            for (int i = mPage * 10; i < mTotalTextList.size(); i++) {
              mTextList.add(mTotalTextList.get(i));
            }
            mScaleWidth = (mTextList.size() * 10 - 10) * mScaleMargin + mLastInstance;
            mScroller.startScroll(mScroller.getFinalX(), mScroller.getFinalY(),
                -mScroller.getFinalX() + mScaleMargin * 10 * 10 - 10 * mScaleMargin,
                mScroller.getFinalY());
            return true;
          }
        } else {
          if (mTotalTextList.size() >= mPage * 10 + 30) {
            mTextList.clear();
            for (int i = mPage * 10; i < mPage * 10 + 30; i++) {
              mTextList.add(mTotalTextList.get(i));
            }
            mScaleWidth = (mTextList.size() * 10 - 10) * mScaleMargin;
            mScroller.startScroll(mScroller.getFinalX(), mScroller.getFinalY(),
                -mScroller.getFinalX() + mScaleMargin * 10 * 10 - 10 * mScaleMargin,
                mScroller.getFinalY());
            return true;
          }
        }
      }
    } else {//向后移动
      if (mPage > 0) {
        mPage--;
        if (mTotalTextList.size() > mPage * 10 + 30) {
          mTextList.clear();
          for (int i = mPage * 10; i < mPage * 10 + 30; i++) {
            mTextList.add(mTotalTextList.get(i));
          }
          mScaleWidth = (mTextList.size() * 10 - 10) * mScaleMargin;
          mScroller.startScroll(mScroller.getFinalX(), mScroller.getFinalY(),
              mScaleMargin * 10 * 10, mScroller.getFinalY());
          return true;
        }
      }
    }
    return false;
  }

  /**
   * 刷新操作
   */
  public void refresh(final int startMoney, final int finalMoney) {
    new Thread(new Runnable() {//防止数据量过多导致阻塞主线程
      @Override
      public void run() {
        mPage = 0;
        mStartMoney = startMoney / mUnit;
        mFinalMoney = finalMoney;
        mTextList.clear();
        mTotalTextList.clear();
        for (int i = 0; i < (finalMoney - startMoney) / (mUnit * 10) + 1; i++) {
          if (i < 30 || (finalMoney - startMoney) / (mUnit * 10) + 1 < 40) {//当前显示刻度数
            mTextList.add(String.valueOf(i * mUnit * 10 + startMoney));
          }
          mTotalTextList.add(String.valueOf(i * mUnit * 10 + startMoney));//总共刻度数
        }
        mLastInstance = ((finalMoney - startMoney) % (mUnit * 10)) / 100 * mScaleMargin;//余数刻度
        if (mTotalTextList.size() < 40) {
          mScaleWidth = (mTextList.size() * 10 - 10) * mScaleMargin + mLastInstance;
        } else {
          mScaleWidth = (mTextList.size() * 10 - 10) * mScaleMargin;
        }
        new Handler(Looper.getMainLooper()).post(new Runnable() {
          @Override
          public void run() {
            postInvalidate();
          }
        });
      }
    });
  }

  /**
   * 设置每个刻度间距
   *
   * @param margin 间距
   * @return 返回当前view 链式编程
   */
  public ScrollDividingRuleView setScaleMargin(int margin) {
    mScaleMargin = margin;
    mRectHeight = (int) (mLineHeight + mTextSize + mTextLineMargin + 20);
    return this;
  }

  /**
   * 设置文字和刻度线的间距
   */
  public ScrollDividingRuleView setTextLineMargin(int textLineMargin) {
    mTextLineMargin = textLineMargin;
    mRectHeight = (int) (mLineHeight + mTextSize + mTextLineMargin + 20);
    return this;
  }

  /**
   * 设置文字和刻度线的间距(滚动有问题)
   */
  public ScrollDividingRuleView setInitPosition(int position) {
    mInitPosition=position;
    return this;
  }
}

调用代码:

final ScrollDividingRuleView scrollDividingRuleView = findViewById(R.id.scroll_dividing_rule_view);
    editText = findViewById(R.id.edit_text);
    scrollDividingRuleView.bindMoneyData(0, 100000, 100,
        new ScrollDividingRuleView.OnScrollListener() {
          @Override public void onScaleScrollChanged(long scale) {
            isDividingScroll=true;//防止滚动的时候和edittext绑定数据出问题
            editText.setText(String.valueOf(scale*100));
            editText.setSelection(String.valueOf(scale*100).length());
          }
        });

    scrollDividingRuleView.setScaleMargin(30)
        .setTextLineMargin(30);

    editText.addTextChangedListener(new TextWatcher() {
      @Override
      public void beforeTextChanged(CharSequence s, int start, int count, int after) {
      }

      @Override
      public void onTextChanged(CharSequence s, int start, int before, int count) {
      }

      @Override
      public void afterTextChanged(Editable s) {
        String money = s.toString().trim();
        if (money.length() > 0 && !TextUtils.isEmpty(money)) {
          float i = Float.parseFloat(money);
            if (!isDividingScroll) {
              scrollDividingRuleView.setNowScale(i >= 100? i / 100 : 0);
            } else {
              isDividingScroll = false;
            }
          }
      }
    });

布局代码:

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context="com.zqb.scrolldividingrule.MainActivity">
    <com.zqb.scrolldividingrule.ScrollDividingRuleView
        android:layout_marginTop="50px"
        android:id="@+id/scroll_dividing_rule_view"
        android:layout_width="match_parent"
        android:layout_marginLeft="30px"
        android:layout_marginRight="30px"
        android:layout_height="wrap_content"
        app:line_height="80px"
        app:dividing_text_size="30px"/>
    <View
        android:layout_marginTop="90px"
        android:background="@color/colorAccent"
        android:layout_centerHorizontal="true"
        android:layout_width="1px"
        android:layout_height="120px"/>
    <EditText
        android:inputType="number"
        android:id="@+id/edit_text"
        android:layout_marginLeft="10dp"
        android:textSize="25sp"
        android:layout_marginTop="300px"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"/>
</RelativeLayout>

下载地址

如果显示30个有卡顿的话,可以自己调整。
注:paint.setStyle(Paint.Style.FILL); 防止画出来的文字带空心
paint.measureText(“123”); 获取文字显示的宽度

别再只用picker了!用scroll-view手搓一个微信小程序刻度尺选择器(附完整代码) 本文详细介绍了如何利用微信小程序的scroll-view组件实现高精度刻度尺选择器,突破原生picker组件的限制。通过优化刻度渲染、精确同步指针位置以及实现惯性滚动等高级功能,开发者可以创建支持连续滑动、视觉冲击力强的自定义选择器,适用于体重测量、医疗设备等需要精确数值选择的场景。 阅读详情

相关推荐

Android-LoopScale循环滚动的刻度尺控件

LoopScale 循环滚动的 刻度尺控件

android 滚轮刻度尺的实现

遇到一个需求需要实现如下图的效果: vcPmtcS2q8730tTHsMO7xaq5/aOs0tTEv8ewxOO1xMTcwaajrM/rwcu8uNbWy7zCt7a8y8DU2sHLsOvCt8nPoaOxyMjnyc/D5rXEv8y2yM/fyOe6zsWqo6y7rLavtcTKsbry09a4w8jnus7FqqO7z8LD5rXEyv3X1tPWyOe6zsWqo7u/tMbww

xiaoxiandroid的专栏 1055

SlidingRuler是SwiftUI的滑动标尺控件-Swift开发

SlidingRuler是一个Swift程序包,其中包含一个SwiftUI控件,该控件的作用类似于线性无限滑块或有限的,更精确的滑块,这时不应在生产中使用SlidingRuler。 SlidingRuler是一个Swift软件包,其中包含一个SwiftUI控件,该控件的作用类似于线性无限滑块或有限的,更精确的滑块。 显着的区别在于,用户可以在滑尺上而不是在滑块上更精确地评​​估该值。 默认情况下,它会显示一个标尺,您可以在其中滑动,并且一个漂亮的红色光标指向当前值:这些功能是受支持的功能:动态类型触觉f

android 带刻度的滑动条_Android自定义控件尺子 滚动刻度尺

自定义控件是件很有乐趣的事,慢慢的会爱上它,哈哈哈。废话不多说先上设计图 接下来我们我们要先分析一下页面中需要到哪些东西1.一条无限长的底线;2.一根在屏幕中间的红色标记线,代表当前位置;3.一个半透明的蓝色背景,改背景超过部分才会被展现;4.刻度 整数高一点刻度 非整第一点的刻度5.一个大刻度上都会标的数值6.滚动接下来进入正题,让我们开始绘制:首先我们先给控件定义它的属性,根据刚才的分析我给...

weixin_33365244的博客 623

Android-自定义时间刻度尺(随着手指自行缩放)多种显示模式

自定义时间刻度尺(随着手指自行缩放),多种显示模式

Android无限循环RecyclerView的完美实现方案

主要介绍了Android无限循环RecyclerView的完美实现方案,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧

Android自定义滑动刻度尺

一 基础: 自定义View实现跟随手指滚动的刻度尺,实现了类似SeekBar的滑动选中效果。项目地址,欢迎star! UI图: 功能: 通过设置最小值跟最大值的范围,以及offset值。View将根据这些数据去计算出需要几个小刻度和几个长刻度,和每个长刻度上面显示的数值。 指针可以随意的定制。 当滑动停止后,刻度尺会根据四舍五入将距离指针最近的长刻度滑动到指针的位置。 支持范围越界回弹。 支持设...

weixin_34080951的博客 1228

Android实现滚动刻度尺效果

本篇文章主要介绍了Android实现滚动刻度尺效果,小编觉得挺不错的,现在分享给大家,也给大家做个参考。一起跟随小编过来看看吧

Android 自定义View:实现一个 FM 刻度尺

效果图 前言 最近在做收音机项目需要绘制一个 FM 刻度尺,刚开始考虑了一下现有的开源库,后来发现都不太满足 UI 小哥哥的要求,于是决定自己画一个吧。实现的 Demo 效果如上所示。主要包含大中小三种长度的刻度线,部分刻度整数值和一根指示器。这样就完美实现了一个 FM 刻度尺。下面大致介绍一下具体的做法。只想看代码的同学可以直奔 Github 地址 开始绘制 我是通过继承 View 重写相关类...

weixin_34292402的博客 1003

变压器铁心100Hz振动噪声的COMSOL磁致伸缩仿真全流程

磁致伸缩是铁磁材料在磁场作用下发生尺寸变化的现象,也是变压器铁心振动与噪声产生的根本原因。由于应变与磁通密度近似成平方关系,50Hz电网激励下铁心振动基频为100Hz。借助COMSOL多物理场仿真,可将磁场计算结果映射为结构应力和变形,完成“电磁—结构”单向耦合分析。该技术广泛应用于变压器振动噪声预测、结构优化及故障诊断等工程场景。本文从磁致伸缩物理机理出发,系统梳理了材料参数、等效建模、边界条件设置和结果校核等关键步骤,帮助工程师掌握从磁致伸缩到结构变形的完整仿真链路,解决实际工程对标难题。

weixin_33796177的博客 315

MacOS多次踩坑后成功安装Homebrew

来一次性成功安装Homebrew吧 官网提供的安装脚本无法成功安装Homebrew,原因大家都懂的,故采用脚本安装的方式。 下载homebrew的安装脚本brew_install 在Download路径下执行如下脚本 curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install >> brew_install 修改brew_install脚本 修改brew_install脚本。如果你的脚本打开之后是如下

weixin_41847116的博客 1983

自定义view控件效果实现及实践

项目需求讨论 - Android 自定义 Dialog 实现步骤及封装根据实际项目需求出发。因为项目中的对话框要配合整个项目的 UI 风格,所以进行自定义 Dialog 的实现步骤,及最后写封装类。来快速实现各种自定义界面的对话框。 图文并茂 – 自定义 View 之 SwitchButton(切换标签)自定义 View 实现一个简单好用的切换标签 年前最后一发:带分割线的 LinearLayo

506

开源CC6920差分霍尔电流传感器模块实战指南——从选型到波形分析

本文详细介绍了CC6920差分霍尔电流传感器模块的选型、硬件连接、参数计算及波形分析技巧。通过实战案例,展示了该开源硬件在电流测量中的优势,包括超低内阻、电气隔离和抗干扰能力,适用于电机控制、开关电源保护等场景。

weixin_28738397的博客 379

自定义控件

https://github.com/dalong982242260/AndroidRuler 1、直尺(测量距离) github:https://github.com/1149863953/ruler 问题:不能适配各种手机,有的不准 2、圆尺(测量角度) github:https://github.com/1149863953/ruler  3、直尺 A screen si

tangweiguo0305的专栏 329

VI恒流源原理详细分析(0~10V转0/4~20mA)

但是此电阻也不能无限增加,首先我们所列方程均是基于运放虚短虚断的假设,此假设又是基于运放输入阻抗无穷大,输出阻抗无穷小的前提条件,然而实际的运放并非理想运放,对于TL082IDR这款运放,其Rid(Common-mode input resistance)典型值为1TΩ,以此来看感觉1MΩ确实还不是很大,但是还有另一个影响因素需要考虑,那就是电路的抗干扰能力,原则上,电阻越大受到外部干扰的可能性越大。也就是实现Uin 0~10V变化时对应Iout 0~20mA的一个线性对应关系。

IOTBOT的博客 2908

SRAM ECC原理与应用:从汉明码到高可靠嵌入式系统设计

在嵌入式系统与高可靠性计算领域,内存数据完整性是系统稳定运行的基石。软错误(Soft Error)由宇宙射线或芯片内部粒子引发,可能导致存储单元发生位翻转,进而引发程序跑飞或数据损坏。为应对这一物理层挑战,错误校验与纠正(ECC)技术应运而生,其核心原理基于扩展汉明码,通过增加校验位实现单错误纠正、双错误检测(SECDED)能力。这项技术通过硬件透明纠错,在提升系统可靠性的同时,几乎不影响访问性能。在汽车电子、工业控制及航空航天等对安全性要求极高的场景中,ECC已成为保障长期稳定运行的关键硬件机制。本文聚焦

weixin_28728265的博客 535

android自定义尺子收集demo

android自定义尺子收集demo

jacke121的专栏 6867

STM32CubeMX配置FSMC驱动外部SRAM全流程详解

FSMC(灵活静态存储控制器)是STM32实现高速并行外部存储扩展的核心外设,其本质是将片外SRAM地址空间映射为CPU可直接读写的内存区域。原理上依赖于精确的时序寄存器配置(如BTRx)、GPIO复用功能启用及AHB3总线时钟同步机制,技术价值在于免DMA搬运的零拷贝访问能力与确定性低延迟。典型应用场景包括工业HMI缓存、医疗设备实时数据采集、嵌入式图形加速等对带宽和确定性要求严苛的系统。本文围绕STM32F407ZG平台,结合STM32CubeMX工程化配置、硬件信号完整性设计与HAL库底层映射逻辑,系

weixin_34718952的博客 233

列表无限滚动加载——安卓JetPack实现(LazyColumn+LazyListState实现)

LazyListState 是 Jetpack Compose 中用于跟踪LazyColumn 或LazyRow 列表滚动状态的一个组件。通过LazyListState,可以在构建列表时传递给列表组件,然后通过访问属性来获取列表的滚动状态信息,例如列表的滚动偏移量、可见项的信息等。最后一个可见项的索引是否等于列表中最后一项的索引, 如果相等则意味着已经滚动到了列表的底部。显然跟web一样,该条件会连续多次触发,此时需要对其进行防抖优化。防抖方式已发布,这里不再赘述。

m0_63548381的博客 1423

详解Xilinx FPGA高速串行收发器GTX/GTP(6)--Pattern Generator/Pattern Checker

详解Xilinx FPGA高速串行收发器GTX/GTP(6)--Pattern Generator/Pattern Checker

孤独的单刀 1629

2、机器人控制技术:阻抗/导纳控制与强化学习的融合

本文探讨了阻抗/导纳控制与强化学习在机器人控制中的融合应用。阻抗/导纳控制广泛应用于外骨骼和跟踪控制,通过改进方案提升建模误差下的鲁棒性;强化学习则为解决维度灾难、实现最优交互提供了有效途径,尤其在大输入空间、连续时间系统、冗余机器人及鲁棒控制中表现突出。结合近似器与合理奖励设计,强化学习可在无模型情况下实现高效控制。未来,两者融合有望推动更智能、更安全的机器人系统发展。

ice55的博客 300

自定义控件 ——可拖动测量尺子

原创作者地址:http://blog.youkuaiyun.com/tl792814781/article/details/52388577 前言: 最近做的一个项目,有个界面是 输入框输入数值的,后来产品觉得键盘输入麻烦,就换成了这样子,这是前几天Ui小伙子设计的界面: 分析: 其实简单的画一个测量尺子刻度控件并不会太难,其次就是被5和10整除的刻度线高度

Coding_the_world 4090

C# WinForm 基于DirectShow.dll编写的程序,可边预览边保存视频,音频和图片

基于微软的DirectShow.dll的二次开发1.自动识别连接的摄像头跟麦克风且可以对其进行选择(默认选中第一个)2.可录制wmv和avi两种格式的视频并且都带有音频,avi可以录制的分辨率和帧数进行选择,wmv默认进行了淸晰度优化如不喜欢可去除代码中有相关提示3.可在预览点开之后进行拍照,也可边录制视频边拍照4.添加了视频和音频的压缩功能(酌情使用)这次二次开发发现C#对DirectShow的相关信息太少,这次做完也不敢藏私共享出来,还望大家指正

canvas 刻度尺

参考链接:https://codepen.io/luren/pen/yEagYO。

风小猪的博客 1605

SAP B1中文培訓教材_SDK

公司内部培训资料,对开发工具 ,DIAPI, UIAPI,Add-ON有详细解说

文档:亲测可用解决vnc灰屏,黑屏,鼠标大黑叉情况

主要解决vnc-viewer灰屏,黑屏,鼠标大黑叉等现象,详细见文档。

RecyclerView滑动时添加缩放效果

通过recyclerview实现无限循环中添加缩放效果(仿心遇APP的效果)

weixin_38699155的博客 709

jdk-8u144-linux-x64.tar.gz.

该资源为搭建Linux系统Java环境用,资源的后缀为tar.gz格式的压缩包

android自定义控件-AutoScrollViewpager(无限滚动轮播控件)

在实现该控件之前,先说一下该控件的难度, 一、   每个item中如果有RadioButton之类,可以focus焦点的,点击效果可能会失效   二、无限的滚动   下面是效果图: 实现上图的效果,一共自定义了两个 控件,viewpager+底部导航图标 下面我先来讲解一下,viewpager的实现: 1.初始化 /** 点击按下的坐标 **/ PointF downP

wsad227的专栏 5511
上一篇: 通过防止按钮快速重复点击简单了解AOP和注解
下一篇: Camera2实现带照相框的可修改显示效果的自定义照相机
Alien28
博客等级 码龄10年 2粉丝 11原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值