三大自定义控件

最新推荐文章于 2024-06-12 11:45:10 发布
最新推荐文章于 2024-06-12 11:45:10 发布
阅读量276 收藏
点赞数
分类专栏： 控件细节
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36331942/article/details/64442831
版权

1. 组合控件  (组合两种已有的控件得来的自定义控件 通常继承自布局)


//public class PuzzleSumView extends RelativeLayout implements View.OnClickListener {
//
//    private Context mContext;
//    private TextView mBackText;
//    private  TextView mFontText;
//
//
//    public PuzzleSumView(Context context) {
//        this(context,null);
//    }
//
//    public PuzzleSumView(Context context, AttributeSet attrs) {
//        super(context, attrs);
//        this.mContext=context;
//        init();
//
//    }
//
//    @Override
//    public void onClick(View v) {
//
//    }
//
//    private void init() {
//        initView();
//        initData();
//        initEvent();
//    }
//
//    private void initData() {
//    }
//
//    private void initView() {
//        View view= LayoutInflater.from(mContext).inflate(R.layout.puzzle_sum_view,null);
//        mBackText= (TextView) view.findViewById(R.id.puzzle_view_tv_next);
//        mFontText= (TextView) view.findViewById(R.id.tv_sum);
//        addView(view);
//    }
//
//    private void initEvent() {
//        mBackText.setText("选图");
//        mFontText.setText("0");
//
//
//    }
//
//    public  void  setNum(int sum){
//        mFontText.setText(sum+"");
//        if(sum>=2){
//            mBackText.setText("下一步");
//        }else {
//            mBackText.setText("选图");
//        }
//    }
//}


public class SelectItem extends RelativeLayout {


    public static int mImageViewHeight;
    public final int mImageViewWidth;
    private ImageView mImageView;
    private ImageView mCheckImg;

    public SelectItem(Context context) {
        super(context);
//        setGravity(Gravity.CENTER);
        mImageView = new ImageView(context);
        mImageView.setAdjustViewBounds(true);
        mImageView.setScaleType(ImageView.ScaleType.CENTER_CROP);
        mImageView.setPadding(DensityUtil.dip2px(context, 1), DensityUtil.dip2px(context, 1), DensityUtil.dip2px(context, 1), DensityUtil.dip2px(context, 1));
        int selectPicWitdh = DensityUtil.dip2px(context, 70);
        int selectPicHeight = DensityUtil.dip2px(context, 70);
        LayoutParams mImageViewRLP = new LayoutParams(selectPicWitdh, selectPicHeight);
        mImageViewRLP.setMargins(DensityUtil.dip2px(context, 20), 0, 0, 0);
        addView(mImageView, mImageViewRLP);

        //添加红色删除图标
        mCheckImg = new ImageView(context);
        mCheckImg.setImageResource(R.drawable.del_select_pic);
        LayoutParams checkImgRLP = new LayoutParams(ViewGroup.LayoutParams.WRAP_CONTENT, ViewGroup.LayoutParams.WRAP_CONTENT);
        checkImgRLP.setMargins(DensityUtil.dip2px(context, 70), DensityUtil.dip2px(context, 5), 0, 0);
        mImageViewHeight = mImageView.getHeight();
        mImageViewWidth = mImageView.getWidth();
        addView(mCheckImg, checkImgRLP);
    }

    public ImageView getmImageView() {
        return mImageView;
    }

    public ImageView getCheckImg() {
        return mCheckImg;
    }

    public View hideView() {
        mCheckImg.setVisibility(INVISIBLE);
        mImageView.setVisibility(INVISIBLE);
        return this;
    }
}


二 继承控件 (扩展已有的控件,继承自该控件) 


public class CustomTestView extends TextView {

    public CustomTestView(Context context, AttributeSet attrs, int defStyle) {
        super(context, attrs, defStyle);
        init();
    }

    public CustomTestView(Context context, AttributeSet attrs) {
        super(context, attrs);
        init();
    }

    public CustomTestView(Context context) {
        super(context);
        init();
    }

    private void init() {
        Typeface tf = Typeface.createFromAsset(getContext().getAssets(),
                "gotham-medium.otf");
        setTypeface(tf);
    }
}

 

 

三  自定义控件     继承自View
 构造函数1个参数 用于代码, 2个参数用于布局文件属性需要

 
 


 
 
 

public class DragView extends View {
    private Bitmap mBitmap = null;
    private Context mContext = null;
    private Rect mFrameRect = null;
    private Paint mPaint = null;
    private Rect mThumbnailRect = null;

    public DragView(Context c) {
        super(c);
    }

    public DragView(Context c, AttributeSet attr) {
        super(c, attr);
        if (mContext == null) {
            mContext = c;
        }
        init();
    }

    private void drawFrame(Canvas canvas) {
        if (mFrameRect == null || mPaint == null) {
            return;
        }
        mPaint.setColor(Color.parseColor("#00fff0"));
        mPaint.setAlpha(255);
        canvas.drawRect(mFrameRect, mPaint);
    }

    private void drawThumbnail(Canvas canvas) {
        if (mThumbnailRect == null || mPaint == null || mBitmap == null
                || mBitmap.isRecycled()) {
            return;
        }
        mPaint.setAlpha(127);
        canvas.drawBitmap(mBitmap, null, mThumbnailRect, mPaint);
    }

    private void init() {
        if (mPaint == null) {
            mPaint = new Paint();
        }
        int i = mContext.getResources().getDimensionPixelSize(R.dimen.dragview_stroke_w);
        mPaint.setStrokeWidth(i);
        mPaint.setColor(ContextCompat.getColor(mContext, R.color.grid_collage_background));
        mPaint.setAntiAlias(true);
        mPaint.setStrokeCap(Paint.Cap.ROUND);
        mPaint.setStrokeJoin(Paint.Join.ROUND);
        mPaint.setStyle(Paint.Style.STROKE);
        mPaint.setAlpha(127);
    }

    protected void onDraw(Canvas canvas) {
        super.onDraw(canvas);
        drawThumbnail(canvas);
        drawFrame(canvas);
    }
}

 

public class PuzzleView extends View {

    private Context context;
    private Path[] path;
    private Bitmap[] bitmaps;
    private boolean[] bitmapsFlag;
    private float[][] pathLT;
    private float[][] pathOffset;
    private int pathNum;
    private int viewWdh, viewHgt;
    private int leftMargin;
    private List<ImageBean> pics;
    private final static int MARGIN_HEIGHT = 100;
    private List<ImageItem> coordinateSetList;


    public PuzzleView(Context context) {
        super(context);
        this.context = context;
    }

    public PuzzleView(Context context, AttributeSet attributeSet) {
        super(context, attributeSet);
        this.context = context;
        initPath();
    }

    public PuzzleView(Context context, AttributeSet attributeSet, int defStyle) {
        super(context, attributeSet, defStyle);
        this.context = context;
        initPath();
    }

    public void setPathCoordinate(List<ImageItem> pathCoordinate) {
        this.coordinateSetList = pathCoordinate;
        initPath();
    }

    public void setPics(List<ImageBean> imageBeans) {

        leftMargin = (AppUtil.getScreenWidth(context) - dp2px(320)) / 2;
        viewWdh = dp2px(320);
        viewHgt = dp2px(450);
        pics = new ArrayList<>();
        if (imageBeans != null) {
            pics.addAll(imageBeans);
        }
        pathNum = pics.size();
    }

    private void initPath() {
        path = new Path[pathNum];
        for (int i = 0; i < pathNum; i++) {
            path[i] = new Path();
        }
        bitmapsFlag = new boolean[pathNum];

        pathLT = new float[pathNum][2];
        pathOffset = new float[pathNum][2];
        for (int i = 0; i < pathNum; i++) {
            bitmapsFlag[i] = false;
            pathLT[i][0] = 0f;
            pathLT[i][1] = 0f;
            pathOffset[i][0] = 0f;
            pathOffset[i][1] = 0f;
        }

        for (int i = 0; i < pathNum; i++) {
            for (int j = 0; j < coordinateSetList.get(i).getCoordinates().size(); j++) {
                float x = coordinateSetList.get(i).getCoordinates().get(j).getX();
                float y = coordinateSetList.get(i).getCoordinates().get(j).getY();
                if (j == 0) {
                    path[i].moveTo(dp2px(x), dp2px(y));
                } else {
                    path[i].lineTo(dp2px(x), dp2px(y));
                }
            }
            path[i].close();
        }

        // get bitmap
        bitmaps = new Bitmap[pathNum];
        for (int i = 0; i < pathNum; i++) {
            BitmapFactory.Options opt = new BitmapFactory.Options();
            opt.inJustDecodeBounds = true;
            BitmapFactory.decodeFile(pics.get(i).path, opt);

            int bmpWdh = opt.outWidth;
            int bmpHgt = opt.outHeight;

            Coordinates coordinate = caculateViewSize(coordinateSetList.get(i).getCoordinates());
            int size = caculateSampleSize(bmpWdh, bmpHgt, dp2px(coordinate.getX()), dp2px(coordinate.getY()));
            opt.inJustDecodeBounds = false;
            opt.inSampleSize = size;

            bitmaps[i] = scaleImage(BitmapFactory.decodeFile(pics.get(i).path, opt), dp2px(coordinate.getX()), dp2px(coordinate.getY()));
        }
    }

    private Coordinates caculateViewSize(List<Coordinates> list) {

        float viewWidth;
        float viewHeight;

        viewWidth = caculateMaxCoordinateX(list) - caculateMinCoordinateX(list);
        viewHeight = caculateMaxCoordinateY(list) - caculateMinCoordinateY(list);

        return new Coordinates(viewWidth, viewHeight);
    }


    private int caculateSampleSize(int picWdh, int picHgt, int showWdh,
                                   int showHgt) {
        // 如果此时显示区域比图片大，直接返回
        if (showWdh < picWdh && showHgt < picHgt) {
            int wdhSample = picWdh / showWdh;
            int hgtSample = picHgt / showHgt;
            // 利用小的来处理
            int sample = wdhSample > hgtSample ? hgtSample : wdhSample;
            int minSample = 2;
            while (sample > minSample) {
                minSample *= 2;
            }
            return minSample >> 1;
        } else {
            return 0;
        }
    }

    private float caculateMinCoordinateX(List<Coordinates> list) {

        float minX;
        minX = list.get(0).getX();
        for (int i = 1; i < list.size(); i++) {
            if (list.get(i).getX() < minX) {
                minX = list.get(i).getX();
            }
        }
        return minX;
    }

    private float caculateMaxCoordinateX(List<Coordinates> list) {

        float maxX;
        maxX = list.get(0).getX();
        for (int i = 1; i < list.size(); i++) {
            if (list.get(i).getX() > maxX) {
                maxX = list.get(i).getX();
            }
        }
        return maxX;
    }

    private float caculateMinCoordinateY(List<Coordinates> list) {

        float minY;
        minY = list.get(0).getY();
        for (int i = 1; i < list.size(); i++) {
            if (list.get(i).getY() < minY) {
                minY = list.get(i).getY();
            }
        }
        return minY;
    }

    private float caculateMaxCoordinateY(List<Coordinates> list) {

        float maxY;
        maxY = list.get(0).getY();
        for (int i = 1; i < list.size(); i++) {
            if (list.get(i).getY() > maxY) {
                maxY = list.get(i).getY();
            }
        }
        return maxY;
    }

    //图片缩放
    private static Bitmap scaleImage(Bitmap bm, int newWidth, int newHeight) {
        if (bm == null) {
            return null;
        }
        int width = bm.getWidth();
        int height = bm.getHeight();
        float scaleWidth = ((float) newWidth) / width;
        float scaleHeight = ((float) newHeight) / height;
        float scale = 1;
        if (scaleWidth >= scaleHeight) {
            scale = scaleWidth;
        } else {
            scale = scaleHeight;
        }
        Matrix matrix = new Matrix();
        matrix.postScale(scale, scale);
        Bitmap newbm = Bitmap.createBitmap(bm, 0, 0, width, height, matrix,
                true);
        return newbm;
    }

    @Override
    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
        super.onMeasure(widthMeasureSpec, heightMeasureSpec);
        setMeasuredDimension(viewWdh, viewHgt);
    }

    @Override
    protected void onDraw(Canvas canvas) {
        super.onDraw(canvas);
        canvas.drawColor(Color.TRANSPARENT);// 显示背景颜色
        Paint paint = new Paint();
        paint.setAntiAlias(true);
        paint.setColor(Color.WHITE);
//        canvas.drawPaint(paint);
        // draw1(canvas);
        startDraw(canvas, paint);
    }


    private void startDraw(Canvas canvas, Paint paint) {
        for (int i = 0; i < pathNum; i++) {
            canvas.save();
            drawScene(canvas, paint, i);
            canvas.restore();
        }
    }

    private void drawScene(Canvas canvas, Paint paint, int idx) {
        canvas.clipPath(path[idx]);
        canvas.drawColor(Color.GRAY);
        if (bitmapsFlag[idx]) {
            canvas.drawBitmap(bitmaps[idx], dp2px(caculateMinCoordinateX(coordinateSetList.get(idx).getCoordinates())) + pathOffsetX + pathOffset[idx][0],
                    dp2px(caculateMinCoordinateY(coordinateSetList.get(idx).getCoordinates())) + pathOffsetY + pathOffset[idx][1], paint);
        } else {
            canvas.drawBitmap(bitmaps[idx], dp2px(caculateMinCoordinateX(coordinateSetList.get(idx).getCoordinates())) + pathOffset[idx][0],
                    dp2px(caculateMinCoordinateY(coordinateSetList.get(idx).getCoordinates())) + pathOffset[idx][1], paint);
        }
    }

    private int dp2px(float point) {
        return DensityUtil.dip2px(getContext(), point);
    }

    float ptx, pty;
    float pathOffsetX, pathOffsetY;

    @Override
    public boolean onTouchEvent(MotionEvent event) {
        switch (event.getAction()) {
            case MotionEvent.ACTION_DOWN:
                for (int i = 0; i < pathNum; i++) {
                    bitmapsFlag[i] = false;
                }
                ptx = event.getRawX() - dp2px(leftMargin);
                pty = event.getRawY() - dp2px(MARGIN_HEIGHT);
                pathOffsetX = 0;
                pathOffsetY = 0;
                int cflag = 0;
                for (cflag = 0; cflag < pathNum; cflag++) {
                    if (contains(path[cflag], ptx, pty)) {
                        bitmapsFlag[cflag] = true;
                        break;
                    }
                }
                break;
            case MotionEvent.ACTION_MOVE:
                pathOffsetX = event.getRawX() - dp2px(leftMargin) - ptx;
                pathOffsetY = event.getRawY() - dp2px(MARGIN_HEIGHT) - pty;
                invalidate();
                break;
            case MotionEvent.ACTION_POINTER_DOWN:
                break;
            case MotionEvent.ACTION_UP:
                for (int i = 0; i < pathNum; i++) {
                    if (bitmapsFlag[i]) {
                        pathOffset[i][0] += event.getRawX() - dp2px(leftMargin) - ptx;
                        pathOffset[i][1] += event.getRawY() - dp2px(MARGIN_HEIGHT) - pty;

                        if (pathOffset[i][0] > 0) {
                            pathOffset[i][0] = 0;
                        }
                        if (pathOffset[i][0] < -(bitmaps[i].getWidth() - getViewWidth(coordinateSetList.get(i).getCoordinates()))) {
                            pathOffset[i][0] = -(bitmaps[i].getWidth() - getViewWidth(coordinateSetList.get(i).getCoordinates()));
                        }
                        if (pathOffset[i][1] > 0) {
                            pathOffset[i][1] = 0;
                        }
                        if (pathOffset[i][1] < -(bitmaps[i].getHeight() - getViewHeight(coordinateSetList.get(i).getCoordinates()))) {
                            pathOffset[i][1] = -(bitmaps[i].getHeight() - getViewHeight(coordinateSetList.get(i).getCoordinates()));
                        }
                        bitmapsFlag[i] = false;
                        break;
                    }
                }
                invalidate();
                break;
            default:
                break;
        }

        return true;
    }

    private boolean contains(Path parapath, float pointx, float pointy) {
        RectF localRectF = new RectF();
        parapath.computeBounds(localRectF, true);
        Region localRegion = new Region();
        localRegion.setPath(parapath, new Region((int) localRectF.left,
                (int) localRectF.top, (int) localRectF.right,
                (int) localRectF.bottom));
        return localRegion.contains((int) pointx, (int) pointy);
    }

    private float getViewWidth(List<Coordinates> list) {

        return dp2px(caculateMaxCoordinateX(list) - caculateMinCoordinateX(list));
    }

    private float getViewHeight(List<Coordinates> list) {

        return dp2px(caculateMaxCoordinateY(list) - caculateMinCoordinateY(list));
    }
}
*/


 

 


                

        

        

    




    

      

        

            

              
                
                  月上繁星
                
              
            

            

                关注
              
            

        

        

          
    
            
  • 
              
                
                
                
                
                      0
                
              
              
    点赞
    
            
    • 
            
  • 
              
                
                
                
              
              
    踩
    
            
    • 
            
  • 
              
                
                
                
                
                    0
                
              
              
    
                
    
                  
                    收藏
                  
                
    
              
    
              
    
                
    
                  觉得还不错?
                  
                    一键收藏
                  
                 
                
    
              
    
            
    • 
          
  • 
            
    
              
              
            
    
              
              
              
                    0
              
            
            
    评论
    
          
    • 
          
  • 
          
    • 
          
  • 
            
              
            
              
    
            
              
                
            
    
          
    • 
        

      

      

            

                专栏目录
          










                



	

		

			

				
					
自定义控件

				
			

			

				

					singhwong
				

				

					11-21
					
					1161
					
				

			

		

		

			
				
当用户控件也不能满足实际开发需求时，开发者可以编写自己的控件——自定义控件。一般来说，自定义控件应该从Control类派生，当然在需要的时候，也可以ongoing现有的控件类派生。

在控件模板中，除了可以定义控件的外观外，还可以声明控件的可视化状态(Visual State)，允许开发者在逻辑代码中操作控件的状态切换。

下面通过实例来向读者说明自定义控件的开发过程。该示例即将完成一个简单的控件，控件中显示一张图片，当操作者在图片上按下鼠标时，会在图片底部显示文本；当松开后文本会隐藏。

在项目中添加自定

			
		

	



                

              
                



	

		

			

				
					
C#自定义控件库

				
			

			

				

					01-22
				

			

		

		

			
				
"C#自定义控件库"是指使用C#语言编写的、由开发者自定义的控件集合，这些控件可以扩展.NET Framework的标准控件集，为用户提供更丰富的界面元素和功能。自定义控件是软件开发中的一个重要环节，特别是在UI设计和用户...

			
		

	



                


  
              

                


	

		

			

				
					
三大控件之————JTree

				
			

			

				

					xj1692418655的专栏
				

				

					10-10
					
					456
					
				

			

		

		

			
				
public class TreePanel extends JScrollPane {
 
 private FileSystemView fsv = FileSystemView.getFileSystemView();   //得到系统桌面文件视图
 private Object[] objects = new Object[0];                         //

			
		

	





	

		

			

				
					
C#工具箱中添加自定义控件

					
最新发布

				
			

			

				

					lingxiao16888的博客
				

				

					06-12
					
					2168
					
				

			

		

		

			
				
正则表达式</param>/// <param name="errorInfo">提示的错误信息

			
		

	



		

			
		



	

		

			

				
					
三大控件之————JTabel

				
			

			

				

					xj1692418655的专栏
				

				

					10-17
					
					617
					
				

			

		

		

			
				
JTabel的使用
重点： 一般以模型方法创建表格：
         DefaultTableModel model = new DefaultTableModel(data, colName);
     
       设置表格中的的某一列具有按钮作用
           MyCellEditor cellediter=new MyCellEditor(new JTextFiel

			
		

	





	

		

			

				
					
自定义控件大全

				
			

			

				

					hengxuan2176的博客
				

				

					01-02
					
					221
					
				

			

		

		

			
				
1，自定义Edittext， TextView，带底线的Edittext， TextView
2.自定义圆形ImageView，圆角ImageView
3，下拉刷新LinearLayout
4，多点触控ImageView
5，Gif 动画解析
6，抽拉式菜单（Sliding menu）
7，Http Request
8，异步加载图片（解决Out of Memory问题）
9，Vie

			
		

	





	

		

			

				
					
Android自定义控件

				
			

			

				

					刘永祥的专栏
				

				

					10-28
					
					4506
					
				

			

		

		

			
				
我们在开发的过程中，有时会遇到一些Android系统自带的控件解决不了我们的需求，比如说我们在开发项目时显示的图片轮播，当我们展示的时候不希望图片变形，还要保证图片能够完整的显示出来，我们如何做呢？如果只是一个简单的ImageView控件恐怕很难实现吧！有人会说ImageView的ScaleType属性就能够解决图片填充不满的问题，但是那样的话图片很容易失真，达不到产品原先的需求。首先我们来认识一下

			
		

	





	

		

			

				
					
C#自定义控件VS用户控件

				
			

			

				

					12-31
				

			

		

		

			
				
C#中自定义控件VS用户控件大比拼 1 自定义控件与用户控件区别 WinForm中， 用户控件（User Control）：继承自 UserControl，主要用于开发 Container 控件，Container控件可以添加其他Controls控件 自定义控件...

			
		

	





	

		

			

				
					
为C#自定义控件添加自定义事件

				
			

			

				

					12-22
				

			

		

		

			
				
在C#编程中，自定义控件是一种常见的方式，它允许开发者根据特定需求组合和扩展标准控件，创建具有独特功能的用户界面元素。本文将详细介绍如何为C#自定义控件添加自定义事件，以便将事件响应代码推迟到使用这些控件...

			
		

	





	

		

			

				
					
百度地图自定义控件分享

				
			

			

				

					09-03
				

			

		

		

			
				
总的来说，百度地图API的自定义控件功能为开发者提供了极大的灵活性，可以创建符合应用特色的地图交互方式。只要理解了基本原理和步骤，就能轻松地扩展和实现各种自定义控件，提升用户体验。在实际开发中，开发者还...

			
		

	





	

		

			

				
					
QT添加自定义控件

				
			

			

				

					02-03
				

			

		

		

			
				
自定义控件的开发过程虽然可能较为复杂，但它为开发者提供了极大的自由度，使得能够根据具体的应用场景定制独特的用户界面元素。  #### 六、扩展阅读  - [QT官方文档](https://doc.qt.io/qt-5/) - [Qt Widgets ...

			
		

	





	

		

			

				
					
常用自定义控件

				
			

			

				

					HUandroid的博客
				

				

					08-10
					
					698
					
				

			

		

		

			
				
常用自定义控件


仿QQ控件的头部拉伸Listview
守望先锋加载动画
viewpager的轮播控件
向上跑马灯

			
		

	





	

		

			

				
					
Android 三种自定义控件的应用

				
			

			

				

					丁少帅的博客
				

				

					04-04
					
					235
					
				

			

		

		

			
				
通常来说自定义控件分为三种：

继承于View或ViewGroup
继承于系统现有控件，如：Button、TextView、ImageView …
基于组合控件，包含了其他控件

组合控件
当我们构建这样的菜单列表，不必每一个item在布局里都重写一次，可以提取相同的元素，将单个item封装成控件，需要时直接引用即可。
思路:
分析一下布局中的元素，左边的icon，中间的text，右边的箭头，右边...

			
		

	





	

		

			

				
					
创建自定义控件

				
			

			

				

					梦否
				

				

					03-31
					
					325
					
				

			

		

		

			
				
开发环境：jdk 1.8 + adt-bundle-windows-x86_64_20140101
提取码: j24g
运行环境：mumu模拟器
使用：adb_server connect 127.0.0.1:7555

1. 基础知识
在《第一行代码》中，该章节有张图，如下：


所有的控件都是直接或者间接的继承自View;
所有的布局都是直接或者间接的继承自ViewGroup；
View也是V...

			
		

	





	

		

			

				
					
【C#】自定义控件

				
			

			

				

					不吃鱼的小时喵
				

				

					04-17
					
					165
					
				

			

		

		

			
				
自定义控件

			
		

	





	

		

			

				
					
Android自定义控件实战指南

				
			

			

				

					
				

			

		

		

			
				
 - 三个Android自定义控件实例：提供了实际的案例，涵盖不同类型的自定义控件，帮助开发者巩固自定义控件开发技能。  这些教程旨在帮助Android开发者从基础到进阶地掌握自定义控件的开发，从而能够创造更加独特和...

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值