标签流控件

最新推荐文章于 2021-02-25 09:19:41 发布
最新推荐文章于 2021-02-25 09:19:41 发布
阅读量285 收藏
点赞数
分类专栏： Android

标签流LabelsView

自定义控件代码
public class LabelsView extends ViewGroup implements View.OnClickListener {

    private Context mContext;

    private ColorStateList mTextColor;
    private float mTextSize;
    private int mLabelBgResId;
    private int mTextPaddingLeft;
    private int mTextPaddingTop;
    private int mTextPaddingRight;
    private int mTextPaddingBottom;
    private int mWordMargin;
    private int mLineMargin;
    private SelectType mSelectType;
    private int mMaxSelect;

    private ArrayList<String> mLabels = new ArrayList<>();
    //保存选中的label的位置
    private ArrayList<Integer> mSelectLabels = new ArrayList<>();

    private OnLabelClickListener mLabelClickListener;
    private OnLabelSelectChangeListener mLabelSelectChangeListener;

    /**
     * Label的选择类型
     */
    public enum SelectType {
        //不可选中，也不响应选中事件回调。（默认）
        NONE(1),
        //单选
        SINGLE(2),
        //多选
        MULTI(3);

        int value;

        SelectType(int value) {
            this.value = value;
        }

        static SelectType get(int value) {
            switch (value) {
                case 1:
                    return NONE;
                case 2:
                    return SINGLE;
                case 3:
                    return MULTI;
            }
            return NONE;
        }
    }

    public LabelsView(Context context) {
        super(context);
        mContext = context;
    }

    public LabelsView(Context context, AttributeSet attrs) {
        super(context, attrs);
        mContext = context;
        getAttrs(context, attrs);
    }

    public LabelsView(Context context, AttributeSet attrs, int defStyleAttr) {
        super(context, attrs, defStyleAttr);
        mContext = context;
        getAttrs(context, attrs);
    }

    private void getAttrs(Context context, AttributeSet attrs) {
        if (attrs != null) {
            TypedArray mTypedArray = context.obtainStyledAttributes(attrs, R.styleable.labels_view);
            int type = mTypedArray.getInt(R.styleable.labels_view_selectType, 1);
            mSelectType = SelectType.get(type);

            mMaxSelect = mTypedArray.getInteger(R.styleable.labels_view_maxSelect, 0);
            mTextColor = mTypedArray.getColorStateList(R.styleable.labels_view_labelTextColor);
            mTextSize = mTypedArray.getDimension(R.styleable.labels_view_labelTextSize,
                    sp2px(context, 14));
            mTextPaddingLeft = mTypedArray.getDimensionPixelOffset(
                    R.styleable.labels_view_labelTextPaddingLeft, 0);
            mTextPaddingTop = mTypedArray.getDimensionPixelOffset(
                    R.styleable.labels_view_labelTextPaddingTop, 0);
            mTextPaddingRight = mTypedArray.getDimensionPixelOffset(
                    R.styleable.labels_view_labelTextPaddingRight, 0);
            mTextPaddingBottom = mTypedArray.getDimensionPixelOffset(
                    R.styleable.labels_view_labelTextPaddingBottom, 0);
            mLineMargin = mTypedArray.getDimensionPixelOffset(R.styleable.labels_view_lineMargin, 0);
            mWordMargin = mTypedArray.getDimensionPixelOffset(R.styleable.labels_view_wordMargin, 0);
            mLabelBgResId = mTypedArray.getResourceId(R.styleable.labels_view_labelBackground, 0);
            mTypedArray.recycle();
        }
    }

    @Override
    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {

        int count = getChildCount();
        int maxWidth = MeasureSpec.getSize(widthMeasureSpec) - getPaddingLeft() - getPaddingRight();

        int contentHeight = 0; //记录内容的高度
        int lineWidth = 0; //记录行的宽度
        int maxLineWidth = 0; //记录最宽的行宽
        int maxItemHeight = 0; //记录一行中item高度最大的高度
        boolean begin = true; //是否是行的开头

        for (int i = 0; i < count; i++) {
            View view = getChildAt(i);
            measureChild(view, widthMeasureSpec, heightMeasureSpec);

            if (maxWidth < lineWidth + view.getMeasuredWidth()) {
                contentHeight += mLineMargin;
                contentHeight += maxItemHeight;
                maxItemHeight = 0;
                maxLineWidth = Math.max(maxLineWidth, lineWidth);
                lineWidth = 0;
                begin = true;
            }
            maxItemHeight = Math.max(maxItemHeight, view.getMeasuredHeight());
            if (!begin) {
                lineWidth += mWordMargin;
            } else {
                begin = false;
            }
            lineWidth += view.getMeasuredWidth();
        }

        contentHeight += maxItemHeight;
        maxLineWidth = Math.max(maxLineWidth, lineWidth);

        setMeasuredDimension(measureWidth(widthMeasureSpec, maxLineWidth),
                measureHeight(heightMeasureSpec, contentHeight));
    }

    private int measureWidth(int measureSpec, int contentWidth) {
        int result = 0;
        int specMode = MeasureSpec.getMode(measureSpec);
        int specSize = MeasureSpec.getSize(measureSpec);

        if (specMode == MeasureSpec.EXACTLY) {
            result = specSize;
        } else {
            result = contentWidth + getPaddingLeft() + getPaddingRight();
            if (specMode == MeasureSpec.AT_MOST) {
                result = Math.min(result, specSize);
            }
        }
        result = Math.max(result, getSuggestedMinimumWidth());
        return result;
    }

    private int measureHeight(int measureSpec, int contentHeight) {
        int result = 0;
        int specMode = MeasureSpec.getMode(measureSpec);
        int specSize = MeasureSpec.getSize(measureSpec);

        if (specMode == MeasureSpec.EXACTLY) {
            result = specSize;
        } else {
            result = contentHeight + getPaddingTop() + getPaddingBottom();
            if (specMode == MeasureSpec.AT_MOST) {
                result = Math.min(result, specSize);
            }
        }
        result = Math.max(result, getSuggestedMinimumHeight());
        return result;
    }

    @Override
    protected void onLayout(boolean changed, int left, int top, int right, int bottom) {

        int x = getPaddingLeft();
        int y = getPaddingTop();

        int contentWidth = right - left;
        int maxItemHeight = 0;

        int count = getChildCount();
        for (int i = 0; i < count; i++) {
            View view = getChildAt(i);

            if (contentWidth < x + view.getMeasuredWidth() + getPaddingRight()) {
                    x = getPaddingLeft();
                    y += mLineMargin;
                    y += maxItemHeight;
                    maxItemHeight = 0;
            }
//            if ((i+1)%3==0){
//                x = getPaddingLeft();
//                y += mLineMargin;
//                y += maxItemHeight;
//                maxItemHeight = 0;
//            }
            view.layout(x, y, x + view.getMeasuredWidth(), y + view.getMeasuredHeight());
            x += view.getMeasuredWidth();
            x += mWordMargin;
            maxItemHeight = Math.max(maxItemHeight, view.getMeasuredHeight());
        }
    }

    /*  用于保存View的信息的key  */
    private static final String KEY_SUPER_STATE = "key_super_state";
    private static final String KEY_TEXT_COLOR_STATE = "key_text_color_state";
    private static final String KEY_TEXT_SIZE_STATE = "key_text_size_state";
    private static final String KEY_BG_RES_ID_STATE = "key_bg_res_id_state";
    private static final String KEY_PADDING_STATE = "key_padding_state";
    private static final String KEY_WORD_MARGIN_STATE = "key_word_margin_state";
    private static final String KEY_LINE_MARGIN_STATE = "key_line_margin_state";
    private static final String KEY_SELECT_TYPE_STATE = "key_select_type_state";
    private static final String KEY_MAX_SELECT_STATE = "key_max_select_state";
    private static final String KEY_LABELS_STATE = "key_labels_state";
    private static final String KEY_SELECT_LABELS_STATE = "key_select_labels_state";

    @Override
    public Parcelable onSaveInstanceState() {

        Bundle bundle = new Bundle();
        //保存父类的信息
        bundle.putParcelable(KEY_SUPER_STATE, super.onSaveInstanceState());
        //保存标签文字颜色
        if (mTextColor != null) {
            bundle.putParcelable(KEY_TEXT_COLOR_STATE, mTextColor);
        }
        //保存标签文字大小
        bundle.putFloat(KEY_TEXT_SIZE_STATE, mTextSize);
        //保存标签背景
        bundle.putInt(KEY_BG_RES_ID_STATE, mLabelBgResId);
        //保存标签内边距
        bundle.putIntArray(KEY_PADDING_STATE, new int[]{mTextPaddingLeft, mTextPaddingTop,
                mTextPaddingRight, mTextPaddingBottom});
        //保存标签间隔
        bundle.putInt(KEY_WORD_MARGIN_STATE, mWordMargin);
        //保存行间隔
        bundle.putInt(KEY_LINE_MARGIN_STATE, mLineMargin);
        //保存标签的选择类型
        bundle.putInt(KEY_SELECT_TYPE_STATE, mSelectType.value);
        //保存标签的最大选择数量
        bundle.putInt(KEY_MAX_SELECT_STATE, mMaxSelect);
        //保存标签列表
        if (!mLabels.isEmpty()) {
            bundle.putStringArrayList(KEY_LABELS_STATE, mLabels);
        }
        //保存已选择的标签列表
        if (!mSelectLabels.isEmpty()) {
            bundle.putIntegerArrayList(KEY_SELECT_LABELS_STATE, mSelectLabels);
        }

        return bundle;
    }

    @Override
    public void onRestoreInstanceState(Parcelable state) {
        if (state instanceof Bundle) {
            Bundle bundle = (Bundle) state;
            //恢复父类信息
            super.onRestoreInstanceState(bundle.getParcelable(KEY_SUPER_STATE));

            //恢复标签文字颜色
            ColorStateList color = bundle.getParcelable(KEY_TEXT_COLOR_STATE);
            if (color != null) {
                setLabelTextColor(color);
            }
            //恢复标签文字大小
            setLabelTextSize(bundle.getFloat(KEY_TEXT_SIZE_STATE, mTextSize));
            //恢复标签背景
            int resId = bundle.getInt(KEY_BG_RES_ID_STATE, mLabelBgResId);
            if (resId != 0) {
                setLabelBackgroundResource(resId);
            }
            //恢复标签内边距
            int[] padding = bundle.getIntArray(KEY_PADDING_STATE);
            if (padding != null && padding.length == 4) {
                setLabelTextPadding(padding[0], padding[1], padding[2], padding[3]);
            }
            //恢复标签间隔
            setWordMargin(bundle.getInt(KEY_WORD_MARGIN_STATE, mWordMargin));
            //恢复行间隔
            setLineMargin(bundle.getInt(KEY_LINE_MARGIN_STATE, mLineMargin));
            //恢复标签的选择类型
            setSelectType(SelectType.get(bundle.getInt(KEY_SELECT_TYPE_STATE, mSelectType.value)));
            //恢复标签的最大选择数量
            setMaxSelect(bundle.getInt(KEY_MAX_SELECT_STATE, mMaxSelect));
            //恢复标签列表
            ArrayList<String> labels = bundle.getStringArrayList(KEY_LABELS_STATE);
            if (labels != null && !labels.isEmpty()) {
                setLabels(labels);
            }
            //恢复已选择的标签列表
            ArrayList<Integer> selectLabel = bundle.getIntegerArrayList(KEY_SELECT_LABELS_STATE);
            if (selectLabel != null && !selectLabel.isEmpty()) {
                int size = selectLabel.size();
//                int[] positions = new int[size];
//                for (int i = 0; i < size; i++) {
//                    positions[i] = selectLabel.get(i);
//                }
                ArrayList<Integer> positions=new ArrayList<>();
                for (int i = 0; i < size; i++) {
                    positions.add(selectLabel.get(i)) ;
                }
                setSelects(positions);
            }
            return;
        }
        super.onRestoreInstanceState(state);
    }

    /**
     * 设置标签列表
     *
     * @param labels
     */
    public void setLabels(ArrayList<String> labels) {
        //清空原有的标签
        clearAllSelect();
        removeAllViews();
        mLabels.clear();

        if (labels != null) {
            mLabels.addAll(labels);
            int size = labels.size();
            for (int i = 0; i < size; i++) {
                addLabel(labels.get(i), i);
            }
        }
    }

    /**
     * 获取标签列表
     *
     * @return
     */
    public ArrayList<String> getLabels() {
        return mLabels;
    }

    public void Add(String label){
        mLabels.add(label);
    }

    private void addLabel(String text, int position) {
        final TextView label = new TextView(mContext);
        label.setPadding(mTextPaddingLeft, mTextPaddingTop, mTextPaddingRight, mTextPaddingBottom);
        label.setTextSize(TypedValue.COMPLEX_UNIT_PX, mTextSize);
        label.setTextColor(mTextColor != null ? mTextColor : ColorStateList.valueOf(0xFF000000));
        label.setText(text);
        if (mLabelBgResId != 0) {
            label.setBackgroundResource(mLabelBgResId);
        }
        //label通过tag保存自己的位置(position)
        label.setTag(position);
        label.setOnClickListener(this);
        addView(label);
    }

    @Override
    public void onClick(View v) {
        if (v instanceof TextView) {
            TextView label = (TextView) v;
            if (mSelectType != SelectType.NONE) {
                if (label.isSelected()) {
                    setLabelSelect(label, false);
                } else if (mSelectType == SelectType.SINGLE) {
                    clearAllSelect();
                    setLabelSelect(label, true);
                } else if (mSelectType == SelectType.MULTI
                        && (mMaxSelect <= 0 || mMaxSelect > mSelectLabels.size())) {
                    setLabelSelect(label, true);
                }
            }

            if (mLabelClickListener != null) {
                mLabelClickListener.onLabelClick(label, label.getText().toString(), (int) v.getTag());
            }
        }
    }

    private void setLabelSelect(TextView label, boolean isSelect) {
        if (label.isSelected() != isSelect) {
            label.setSelected(isSelect);
            if (isSelect) {
                mSelectLabels.add((Integer) label.getTag());
            } else {
                mSelectLabels.remove((Integer) label.getTag());
            }
            if (mLabelSelectChangeListener != null) {
                mLabelSelectChangeListener.onLabelSelectChange(label, label.getText().toString(),
                        isSelect, (int) label.getTag());
            }
        }
    }

    /**
     * 取消所有选中的label
     */
    public void clearAllSelect() {
        int count = getChildCount();
        for (int i = 0; i < count; i++) {
            setLabelSelect((TextView) getChildAt(i), false);
        }
        mSelectLabels.clear();
    }

    /**
     * 设置选中label
     *
     * @param positions
     */
    public void setSelects(ArrayList<Integer> positions) {
        if (mSelectType != SelectType.NONE) {
            ArrayList<TextView> selectLabels = new ArrayList<>();
            int count = getChildCount();
            int size = mSelectType == SelectType.SINGLE ? 1 : mMaxSelect;
            for (int p : positions) {
                if (p < count) {
                    TextView label = (TextView) getChildAt(p);
                    if (!selectLabels.contains(label)) {                     
                        setLabelSelect(label, true);
                        selectLabels.add(label);
                    }
                    if (size > 0 && selectLabels.size() == size) {
                        break;
                    }
                }
            }

            for (int i = 0; i < count; i++) {
                TextView label = (TextView) getChildAt(i);
                if (!selectLabels.contains(label)) {
                    setLabelSelect(label, false);
                }
            }
        }
    }

    /**
     * 获取选中的label
     *
     * @return
     */
    public ArrayList<Integer> getSelectLabels() {
        return mSelectLabels;
    }


    /**
     * 设置标签背景
     *
     * @param resId
     */
    public void setLabelBackgroundResource(int resId) {
        if (mLabelBgResId != resId) {
            mLabelBgResId = resId;
            int count = getChildCount();
            for (int i = 0; i < count; i++) {
                TextView label = (TextView) getChildAt(i);
                label.setBackgroundResource(mLabelBgResId);
            }
        }
    }

    /**
     * 设置标签内边距
     *
     * @param left
     * @param top
     * @param right
     * @param bottom
     */
    public void setLabelTextPadding(int left, int top, int right, int bottom) {
        if (mTextPaddingLeft != left || mTextPaddingTop != top
                || mTextPaddingRight != right || mTextPaddingBottom != bottom) {
            mTextPaddingLeft = left;
            mTextPaddingTop = top;
            mTextPaddingRight = right;
            mTextPaddingBottom = bottom;
            int count = getChildCount();
            for (int i = 0; i < count; i++) {
                TextView label = (TextView) getChildAt(i);
                label.setPadding(left, top, right, bottom);
            }
        }
    }

    public int getTextPaddingLeft() {
        return mTextPaddingLeft;
    }

    public int getTextPaddingTop() {
        return mTextPaddingTop;
    }

    public int getTextPaddingRight() {
        return mTextPaddingRight;
    }

    public int getTextPaddingBottom() {
        return mTextPaddingBottom;
    }

    /**
     * 设置标签的文字大小（单位是px）
     *
     * @param size
     */
    public void setLabelTextSize(float size) {
        if (mTextSize != size) {
            mTextSize = size;
            int count = getChildCount();
            for (int i = 0; i < count; i++) {
                TextView label = (TextView) getChildAt(i);
                label.setTextSize(TypedValue.COMPLEX_UNIT_PX, size);
            }
        }
    }

    public float getLabelTextSize() {
        return mTextSize;
    }

    /**
     * 设置标签的文字颜色
     *
     * @param color
     */
    public void setLabelTextColor(int color) {
        setLabelTextColor(ColorStateList.valueOf(color));
    }

    /**
     * 设置标签的文字颜色
     *
     * @param color
     */
    public void setLabelTextColor(ColorStateList color) {
        mTextColor = color;
        int count = getChildCount();
        for (int i = 0; i < count; i++) {
            TextView label = (TextView) getChildAt(i);
            label.setTextColor(mTextColor != null ? mTextColor : ColorStateList.valueOf(0xFF000000));
        }
    }

    public ColorStateList getLabelTextColor() {
        return mTextColor;
    }

    /**
     * 设置行间隔
     */
    public void setLineMargin(int margin) {
        if (mLineMargin != margin) {
            mLineMargin = margin;
            requestLayout();
        }
    }

    public int getLineMargin() {
        return mLineMargin;
    }

    /**
     * 设置标签的间隔
     */
    public void setWordMargin(int margin) {
        if (mWordMargin != margin) {
            mWordMargin = margin;
            requestLayout();
        }
    }

    public int getWordMargin() {
        return mWordMargin;
    }

    /**
     * 设置标签的选择类型
     *
     * @param selectType
     */
    public void setSelectType(SelectType selectType) {
        if (mSelectType != selectType) {
            mSelectType = selectType;
            //选择类型发生改变，就要恢复到初始状态。
            clearAllSelect();
        }
    }

    public SelectType getSelectType() {
        return mSelectType;
    }

    /**
     * 设置最大的选择数量
     *
     * @param maxSelect
     */
    public void setMaxSelect(int maxSelect) {
        if (mMaxSelect != maxSelect) {
            mMaxSelect = maxSelect;
            if (mSelectType == SelectType.MULTI) {
                //最大选择数量发生改变，就要恢复到初始状态。
                clearAllSelect();
            }
        }
    }

    public int getMaxSelect() {
        return mMaxSelect;
    }

    /**
     * 设置标签的点击监听
     *
     * @param l
     */
    public void setOnLabelClickListener(OnLabelClickListener l) {
        mLabelClickListener = l;
    }

    /**
     * 设置标签的选择监听
     *
     * @param l
     */
    public void setOnLabelSelectChangeListener(OnLabelSelectChangeListener l) {
        mLabelSelectChangeListener = l;
    }

    /**
     * sp转px
     */
    public static int sp2px(Context context, float spVal) {
        return (int) TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_SP,
                spVal, context.getResources().getDisplayMetrics());
    }

    public interface OnLabelClickListener {
        void onLabelClick(View label, String labelText, int position);
    }

    public interface OnLabelSelectChangeListener {
        void onLabelSelectChange(View label, String labelText, boolean isSelect, int position);
    }

}
布局
    <LabelsView 
       xmlns:app="http://schemas.android.com/apk/res-auto"
       android:id="@+id/labels"
       android:layout_width="match_parent"
       android:layout_height="wrap_content"
       app:labelBackground="@drawable/label_bg"     //标签的背景
       app:labelTextColor="@drawable/label_text_color" //标签的字体颜色 可以是一个颜色值
       app:labelTextSize="14sp"      //标签的字体大小
       app:labelTextPaddingBottom="5dp"   //标签的上下左右边距
       app:labelTextPaddingLeft="10dp"
       app:labelTextPaddingRight="10dp"
       app:labelTextPaddingTop="5dp"
       app:lineMargin="10dp"   //行与行的距离
       app:wordMargin="10dp"   //标签与标签的距离
       app:selectType="SINGLE"   //标签的选择类型 有单选、多选、不可选三种类型
       app:maxSelect="5" />  //标签的最大选择数量，只有多选的时候才有用，0为不限数量

监听

//标签的点击监听
labelsView.setOnLabelClickListener(new LabelsView.OnLabelClickListener() {
    @Override
    public void onLabelClick(View label, String labelText, int position) {
         //label是被点击的标签，labelText是标签的文字，position是标签的位置。
    }
});
//标签的选中监听
labelsView.setOnLabelSelectChangeListener(new LabelsView.OnLabelSelectChangeListener() {
    @Override
    public void onLabelSelectChange(View label, String labelText, boolean isSelect, int position) {
        //label是被点击的标签，labelText是标签的文字，isSelect是是否选中，position是标签的位置。
    }
});

常用方法

//设置选中标签。
//positions是个可变类型，表示被选中的标签的位置。
//比喻labelsView.setSelects(1,2,5);选中第1,3,5个标签。如果是单选的话，只有第一个参数有效。
public void setSelects(int... positions);

//获取选中的标签。返回的是一个Integer的数组，表示被选中的标签的下标。如果没有选中，数组的size等于0。
public ArrayList<Integer> getSelectLabels();

//取消所有选中的标签。
public void clearAllSelect();

//设置标签的选择类型，有NONE、SINGLE和MULTI三种类型。
public void setSelectType(SelectType selectType);

//设置最大的选择数量，只有selectType等于MULTI是有效。
public void setMaxSelect(int maxSelect);

//设置标签背景
public void setLabelBackgroundResource(int resId);

//设置标签的文字颜色
public void setLabelTextColor(int color);
public void setLabelTextColor(ColorStateList color);

//设置标签的文字大小（单位是px）
public void setLabelTextSize(float size);

//设置标签内边距
public void setLabelTextPadding(int left, int top, int right, int bottom);

//设置行间隔
public void setLineMargin(int margin);

//设置标签的间隔
public void setWordMargin(int margin);

代码来自 博客：donkingliang，本人微改后使用，效果不错，感谢donkingliang！

Android 自定义ViewGroup之实现FlowLayout-标签流容器
Angelica
06-16 7450
本篇文章讲的是Android 自定义ViewGroup之实现标签流式布局-FlowLayout，开发中我们会经常需要实现类似于热门标签等自动换行的流式布局的功能，网上也有很多这样的FlowLayout，但不影响我对其的学习。和往常一样，主要还是想总结一下自定义ViewGroup的开发过程以及一些需要注意的地方。按照惯例，我们先来看看效果图 一、写代码之前，有几个是问题是我们先要弄清楚的： 1、什
标签流式布局
u012361288的博客
06-28 617
//SZTagsView.h@interface SZTagsView : UIView /** @brief 设置标签等与视图周围内边距，视图view最大宽度 @param InsetSpace:标签等与视图周围内边距,默认为UIEdgeInsetsZero @param ViewTotalWidth:视图view最大宽度,默认为屏幕宽度 */ -(void)setInsetSpace
标签流
janeen-jn的博客
11-12 460
有好多应用要给商品或者杂志笔记添加标签，今天有应用涉及到，实现之后整理在这，方便查阅   这种流式标签效果，点击标签，改变颜色，并且限制所能添加标签的数量 首先是一个自定义控件，可以直接拿走放在项目中  package util; import android.content.Context; import android.graphics.Typeface; import
LabelFlowLayout（流式标签布局）
ylineyline的专栏
03-25 2735
LabelFlowLayout（流式标签布局） 支持: 1) 动态增加和减少label数量 2）每行最多个数 + 中心布局 3）动态修改选中状态 4）设置只选择1个（最少1个，最多1个） 5）设置只选择2个（最少2个，最多2个） 6）设置最少2个，最多4个 7）设置成高亮，全部不可点击 8）TextView背景（check、select、press三个效果同步） 等等
Android中标签容器控件的实例详解
09-01
在Android开发中，标签容器控件是一个非常实用的组件，常用于展示一组具有共同属性的标签，例如商品的分类标签。本篇文章将深入探讨如何在Android中实现这样的控件，并结合具体的实例进行详细讲解。 首先，为了实现...
C# Winform 视频流添加透明控件
03-18
在本文中，我们将深入探讨如何在C# Winform应用程序中实现视频流添加透明控件的技巧。这个主题涉及的关键知识点包括Winform控件的透明性、视频流处理以及自定义控件的创建。 首先，让我们从透明控件的概念开始。在...
自制标签云控件TagCloud（WinForm）
06-17
在本文中，我们将深入探讨如何在Windows Forms (WinForm) 应用程序中创建自定义的标签云控件，即TagCloud。这个控件是基于C#编程语言实现的，适用于教学目的，但它可能并不完全适合生产环境的使用。为了在实际项目中...
Android自定义控件（打造流布局实现热门搜索标签）
03-09
这篇博客“Android自定义控件（打造流布局实现热门搜索标签）”深入探讨了如何利用自定义控件创建一个动态流式布局，以展示热门搜索标签。这种布局方式常见于许多应用的首页，如搜索引擎、新闻应用等，它能够根据...
拖拽配置工作流控件demodemo
01-31
《拖拽配置工作流控件demodemo：深入解析与应用》 在信息化时代，工作流管理系统已经成为企业管理、协作及自动化的重要工具。本文将详细探讨一个名为“拖拽配置工作流控件demodemo”的开源项目，它为开发者提供了一...
类似淘宝评价流式标签功能实现
10-23
类似淘宝评价流式标签功能实现类似淘宝评价流式标签功能实现类似淘宝评价流式标签功能实现
LabelsView:Android的标签列表控件。可以设置标签的选中效果。 可以设置标签的选中类型：不可选中、单选、限数量多选和不限数量多选等， 并支持设置必选项、单行显示、最大显示行数等功能
05-13
LabelsView 标签列表控件的使用介绍。 1、引入依赖 在Project的build.gradle在添加以下代码 allprojects { repositories { ... maven { url 'https://jitpack.io' } } } 在Module的build.gradle在添加以下代码 dependencies { implementation 'com.github.donkingliang:LabelsView:1.6.5' } 2、编写布局： <com.donkingliang.labels.LabelsView xmlns:app="http://schemas.android.com/apk/res-auto" android:id="@+id/labels" android:l
Android代码-一个可配置的迷你版轻量级Label辅助类，支持多种配置效果。
08-08
AvatarLabelView 一个可配置的迷你版轻量级 Label 辅助类，支持多种配置效果，具体不同配置展示效果如下图。 说明文档 如下是关于 Label View 的相关使用方式、属性说明、拓展自定义的解释说明。 使用样例 已实现类说明 类别 类名 说明 library LabelViewHelper 标签辅助核心实现类 library LabelView 基于 LabelViewHelper 实现的一个纯标签 View，可嵌套在 ViewGroup 中使用等 demo LabelImageView 基于 LabelViewHelper 实现的一个具备标签的 ImageView，可属性配置等 demo LabelLinearLayout 基于 LabelViewHelper 实现的一个具备标签的 LinearLayout，可属性配置等 customer XxxView 类比上面 demo 中基于 LabelViewHelper 实现自己的 Label View 属性说明 属性 含义 app:backgroundColor La
安卓标签view
09-21
label,适用于添加一些标签 Label label = new Label(this); label.setText("POP"); label.setBackgroundColor(0xff03a9f4); // label.setTargetViewInBaseAdapter(findViewById(R.id.btn), 80,10, Label.Gravity.LEFT_TOP); label.setTargetView(findViewById(R.id.btn), 4, Label.Gravity.RIGHT_BOTTOM);
LabelsView,Android 的标签列表控件。可以设置标签的选中效果。 可以设置标签的选中类型：不可选中、单选、限数量多选和不限数量多选等， 并支持设置必选项等功能。.zip
09-25
LabelsView,Android 的标签列表控件。可以设置标签的选中效果。 可以设置标签的选中类型：不可选中、单选、限数量多选和不限数量多选等， 并支持设置必选项等功能。.zip
Android标签流布局设计
Denluoyia
08-15 308
Android中，标签流布局就是按照从左到右，从上到下的布局方式显示标签，当位置不够标签长度的时候，就换行显示。
流式布局展示评论标签
xingzhong128的博客
03-26 355
前言 电商应用开发时用户评论功能是一个很重要的模块，通过用户的反馈知道服务存在的不足，进而为改进工作流程提供依据。用户的评论会被企业使用大数据处理抽取出一些基本的评论标签，这些标签就能够展示整体评论上方供用户了解其他客户对商家或货物的整体看法。现在就来简单的使用流式布局实现展示用户评价标签。 效果 实现过程 流式布局的特点是能够根据用户提供的数据按照从左到右，从上到下的方式展示控件...
Android的标签列表控件LabelsView
jifenglie的博客
08-21 6850
GitHub地址：https://github.com/donkingliang/LabelsView LabelsView 标签列表控件的使用介绍。 1、引入依赖在Project的build.gradle在添加以下代码 allprojects { repositories { ... maven { url 'https://jitpack.io' } } } 在Mo...
安卓java代码标签_安卓标签LabelsView的简单使用
weixin_35082950的博客
02-25 378
标签：前言：可以设置标签的选中效果。 可以设置标签的选中类型：不可选中、单选、限数量多选和不限数量多选等， 并支持设置必选项等功能1、效果图2、关键代码：LabelsView.javaimport android.content.Context;import android.content.res.ColorStateList;import android.content.res.TypedArr...
Android标签容器控件实战与自定义ViewGroup详解
在Android应用开发中，标签容器控件的实现是常见的需求，特别是在展示分类信息或者对内容进行标识时。本文将详细介绍如何在Android中创建一个自定义的标签容器控件，以满足动态适应屏幕宽度、自动布局的需求。 首先...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值