C#自定义控件之竖滚动条

最新推荐文章于 2021-01-06 21:17:50 发布
最新推荐文章于 2021-01-06 21:17:50 发布
阅读量628 收藏
点赞数
文章标签： c#
原文链接：http://www.cnblogs.com/pnglooog/archive/2013/01/07/2848561.html
版权

参考自定义控件滚动条 自：http://www.cnblogs.com/top5/archive/2010/04/29/1724039.html

上面只有水平滚动条，感觉效果不错， 在此基础上修改。  代码bug, 规范请自行处理。

效果一：

说明：

滚动条
Minimun
Maximun
Value

滚动块
SteepDistance  滚动块间隔,设置为0为连续滚动条
SteepHeight    滚动块高度

GradientStyle  滚动块渐变方式

源代码：

View Code 
using System;
using System.ComponentModel;
using System.Drawing;
using System.Drawing.Drawing2D;
using System.Drawing.Text;
using System.Windows.Forms;

// Copyright 2004-2005 Marcos Meli - www.MarcosMeli.com.ar

namespace FounderUI.UIProgressBar
{

   

    /// <summary>
    /// Text 设置文字
    /// ColorText 文字颜色
    /// GradientStyle 设置滚动条颜色渐变路径
    /// SteepDistance 滚动条间距
    /// SteepHeight    滚动条宽度
    /// </summary>
    public class XpVerticalProgressBar : Control
    {
        #region "  Gradient Mode  "

        public enum GradientMode
        {
            Vertical,
            VerticalCenter,
            Horizontal,
            HorizontalCenter,
            Diagonal
        } ;

        #endregion

        #region "  Constructor  "

        private const string CategoryName = "Xp Vertical ProgressBar";

        public XpVerticalProgressBar()
        { }

        #endregion

        #region "  Private Fields  "

        private Color mColor1 = Color.FromArgb(170, 240, 170);

        private Color mColor2 = Color.FromArgb(10, 150, 10);

        private Color mColorBackGround = Color.White;

        private Color mColorText = Color.Black;

        private Image mDobleBack = null;

        private GradientMode mGradientStyle = GradientMode.VerticalCenter;

        private int mMax = 100;

        private int mMin = 0;

        private int mValue = 50;

        private byte mSteepDistance = 2;

        private byte mSteepHeight = 6;

        #endregion

        #region "  Dispose  "

        protected override void Dispose(bool disposing)
        {
            if (!this.IsDisposed)
            {
                if (mDobleBack != null)
                {
                    mDobleBack.Dispose();
                }
                if (mBrush1 != null)
                {
                    mBrush1.Dispose();
                }

                if (mBrush2 != null)
                {
                    mBrush2.Dispose();
                }

                base.Dispose(disposing);
            }
        }

        #endregion

        #region "  Colors   "

        [Category(CategoryName)]
        [Description("The Back Color of the Progress Bar")]
        public Color ColorBackGround
        {
            get { return mColorBackGround; }
            set
            {
                mColorBackGround = value;
                this.InvalidateBuffer(true);
            }
        }

        [Category(CategoryName)]
        [Description("The Border Color of the gradient in the Progress Bar")]
        public Color ColorBarBorder
        {
            get { return mColor1; }
            set
            {
                mColor1 = value;
                this.InvalidateBuffer(true);
            }
        }

        [Category(CategoryName)]
        [Description("The Center Color of the gradient in the Progress Bar")]
        public Color ColorBarCenter
        {
            get { return mColor2; }
            set
            {
                mColor2 = value;
                this.InvalidateBuffer(true);
            }
        }

        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        [RefreshProperties(RefreshProperties.Repaint)]
        [Description("Set to TRUE to reset all colors like the Windows XP Progress Bar?")]
        [Category(CategoryName)]
        [DefaultValue(false)]
        public bool ColorsXP
        {
            get { return false; }
            set
            {
                ColorBarBorder = Color.FromArgb(170, 240, 170);
                ColorBarCenter = Color.FromArgb(10, 150, 10);
                ColorBackGround = Color.White;
            }
        }

        [Category(CategoryName)]
        [Description("The Color of the text displayed in the Progress Bar")]
        public Color ColorText
        {
            get { return mColorText; }
            set
            {
                mColorText = value;

                if (this.Text != String.Empty)
                {
                    this.Invalidate();
                }
            }
        }

        #endregion

        #region "  Value   "

        [RefreshProperties(RefreshProperties.Repaint)]
        [Category(CategoryName)]
        [Description("The Current Value of the Progress Bar")]
        public int Value
        {
            get { return mValue; }
            set
            {
                if (value > mMax)
                {
                    mValue = mMax;
                }
                else if (value < mMin)
                {
                    mValue = mMin;
                }
                else
                {
                    mValue = value;
                }
                this.Invalidate();
            }
        }

        [RefreshProperties(RefreshProperties.Repaint)]
        [Category(CategoryName)]
        [Description("The Max Value of the Progress Bar")]
        public int Maximum
        {
            get { return mMax; }
            set
            {
                if (value > mMin)
                {
                    mMax = value;

                    if (mValue > mMax)
                    {
                        Value = mMax;
                    }

                    this.InvalidateBuffer(true);
                }
            }
        }

        [RefreshProperties(RefreshProperties.Repaint)]
        [Category(CategoryName)]
        [Description("The Min Value of the Progress Bar")]
        public int Minimum
        {
            get { return mMin; }
            set
            {
                if (value < mMax)
                {
                    mMin = value;

                    if (mValue < mMin)
                    {
                        Value = mMin;
                    }
                    this.InvalidateBuffer(true);
                }
            }
        }

        [Category(CategoryName)]
        [Description("The number of Pixels between two Steeps in Progress Bar")]
        [DefaultValue((byte)2)]
        public byte SteepDistance
        {
            get { return mSteepDistance; }
            set
            {
                if (value >= 0)
                {
                    mSteepDistance = value;
                    this.InvalidateBuffer(true);
                }
            }
        }

        #endregion

        #region  "  Progress Style   "

        [Category(CategoryName)]
        [Description("The Style of the gradient bar in Progress Bar")]
        [DefaultValue(GradientMode.VerticalCenter)]
        public GradientMode GradientStyle
        {
            get { return mGradientStyle; }
            set
            {
                if (mGradientStyle != value)
                {
                    mGradientStyle = value;
                    CreatePaintElements();
                    this.Invalidate();
                }
            }
        }

        [Category(CategoryName)]
        [Description("The number of Pixels of the Steeps in Progress Bar")]
        [DefaultValue((byte)6)]
        public byte SteepHeight
        {
            get { return mSteepHeight; }
            set
            {
                if (value > 0)
                {
                    mSteepHeight = value;
                    this.InvalidateBuffer(true);
                }
            }
        }

        #endregion

        #region "  BackImage  "

        [RefreshProperties(RefreshProperties.Repaint)]
        [Category(CategoryName)]
        public override Image BackgroundImage
        {
            get { return base.BackgroundImage; }
            set
            {
                base.BackgroundImage = value;
                InvalidateBuffer();
            }
        }

        #endregion

        #region "  Text Override  "

        [Category(CategoryName)]
        [Description("The Text displayed in the Progress Bar")]
        [DefaultValue("")]
        public override string Text
        {
            get
            {
                return base.Text;
            }
            set
            {
                if (base.Text != value)
                {
                    base.Text = value;
                    this.Invalidate();
                }
            }
        }

        #endregion

        #region "  Text Shadow  "

        private bool mTextShadow = true;

        [Category(CategoryName)]
        [Description("Set the Text shadow in the Progress Bar")]
        [DefaultValue(false)]
        public bool TextShadow
        {
            get { return mTextShadow; }
            set
            {
                mTextShadow = value;
                this.Invalidate();
            }
        }

        #endregion

        #region "  Text Shadow Alpha  "

        private byte mTextShadowAlpha = 150;

        [Category(CategoryName)]
        [Description("Set the Alpha Channel of the Text shadow in the Progress Bar")]
        [DefaultValue((byte)150)]
        public byte TextShadowAlpha
        {
            get { return mTextShadowAlpha; }
            set
            {
                if (mTextShadowAlpha != value)
                {
                    mTextShadowAlpha = value;
                    this.TextShadow = true;
                }
            }
        }

        #endregion

        #region "  Paint Methods  "

        #region "  OnPaint  "

        protected override void OnPaint(PaintEventArgs e)
        {
            //System.Diagnostics.Debug.WriteLine("Paint " + this.Name + "  Pos: "+this.Value.ToString());
            if (!this.IsDisposed)
            {
                //滚动条height
                int mSteepTotal = mSteepHeight + mSteepDistance;
                //
                float mUtilHeight = this.Height - 6 + mSteepDistance;

                if (mDobleBack == null)
                {
                    mUtilHeight = this.Height - 6 + mSteepDistance;
                    int mMaxSteeps = (int)(mUtilHeight / mSteepTotal);
                    this.Height = 6 + mSteepTotal * mMaxSteeps;

                    mDobleBack = new Bitmap(this.Width, this.Height);

                    Graphics g2 = Graphics.FromImage(mDobleBack);

                    CreatePaintElements();

                    g2.Clear(mColorBackGround);

                    if (this.BackgroundImage != null)
                    {
                        TextureBrush textuBrush = new TextureBrush(this.BackgroundImage, WrapMode.Tile);
                        g2.FillRectangle(textuBrush, 0, 0, this.Width, this.Height);
                        textuBrush.Dispose();
                    }
                    

                    g2.DrawRectangle(mPenOut2, outnnerRect2);
                    
                    g2.DrawRectangle(mPenOut, outnnerRect);

                    g2.DrawRectangle(mPenIn, innerRect);
                    g2.Dispose();

                }

                Image ima = new Bitmap(mDobleBack);

                Graphics gtemp = Graphics.FromImage(ima);

                int mCantSteeps = (int)((((float)mValue - mMin) / (mMax - mMin)) * mUtilHeight / mSteepTotal);

                for (int i = 0; i < mCantSteeps; i++)
                {
                    DrawSteep(gtemp, i);
                }

                if (this.Text != String.Empty)
                {
                    gtemp.TextRenderingHint = TextRenderingHint.AntiAlias;
                    DrawCenterString(gtemp, this.ClientRectangle);
                }

                e.Graphics.DrawImage(ima, e.ClipRectangle.X, e.ClipRectangle.Y, e.ClipRectangle, GraphicsUnit.Pixel);
                ima.Dispose();
                gtemp.Dispose();

            }

        }

        protected override void OnPaintBackground(PaintEventArgs e)
        {
        }

        #endregion

        #region "  OnSizeChange  "

        protected override void OnSizeChanged(EventArgs e)
        {
            if (!this.IsDisposed)
            {
                if (this.Width < 12)
                {
                    this.Width = 12;
                }

                base.OnSizeChanged(e);
                this.InvalidateBuffer(true);
            }

        }

        protected override Size DefaultSize
        {
            get { return new Size(29, 100); }
        }


        #endregion

        #region "  More Draw Methods  "

        private void DrawSteep(Graphics g, int number)
        {
            number++;
            g.FillRectangle(mBrush1, mSteepRect1.X + 1,this.Height - (2 + number * (mSteepDistance + mSteepHeight)), mSteepRect1.Width, mSteepHeight);
            g.FillRectangle(mBrush2, mSteepRect2.X + 1,this.Height - (2 + number * (mSteepDistance + mSteepHeight)), mSteepRect2.Width - 1, mSteepHeight);
        }

        private void InvalidateBuffer()
        {
            InvalidateBuffer(false);
        }

        private void InvalidateBuffer(bool InvalidateControl)
        {
            if (mDobleBack != null)
            {
                mDobleBack.Dispose();
                mDobleBack = null;
            }

            if (InvalidateControl)
            {
                this.Invalidate();
            }
        }

        private void DisposeBrushes()
        {
            if (mBrush1 != null)
            {
                mBrush1.Dispose();
                mBrush1 = null;
            }

            if (mBrush2 != null)
            {
                mBrush2.Dispose();
                mBrush2 = null;
            }

        }

        private void DrawCenterString(Graphics gfx, Rectangle box)
        {
            
            float left = 0;
            float top = 0;

            
            SizeF ss = gfx.MeasureString(this.Text, this.Font);

            top = box.Height - (box.Height - ss.Width) / 2;
            left = ((box.Width - ss.Height) / 2);

            gfx.TranslateTransform(left, top);
            gfx.RotateTransform(270);

            
            //gfx.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.HighQuality;
            if (mTextShadow)
            {
                SolidBrush mShadowBrush = new SolidBrush(Color.FromArgb(mTextShadowAlpha, Color.Black));
                gfx.DrawString(this.Text, this.Font, mShadowBrush, -1, -1);
                mShadowBrush.Dispose();
            }

            SolidBrush mTextBrush = new SolidBrush(mColorText);
            gfx.DrawString(this.Text, this.Font, mTextBrush, 0, 0);
            mTextBrush.Dispose();
            

            /*
            float vlblControlWidth;
            float vlblControlHeight;
            float vlblTransformX;
            float vlblTransformY;

            SolidBrush labelForeColorBrush = new SolidBrush(base.ForeColor);

            vlblControlWidth = this.Size.Width;
            vlblControlHeight = this.Size.Height;

            //gfx.TextRenderingHint = this._renderMode;
            gfx.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.HighQuality;

            vlblTransformX = 0;
            vlblTransformY = vlblControlHeight;
            gfx.TranslateTransform(vlblTransformX, vlblTransformY);
            gfx.RotateTransform(270);
            gfx.DrawString(this.Text, Font, labelForeColorBrush, 0, 0);

            labelForeColorBrush.Dispose();
            */
        }

        #endregion

        #region "  CreatePaintElements   "

        private Rectangle innerRect;
        private LinearGradientBrush mBrush1;
        private LinearGradientBrush mBrush2;
        private Pen mPenIn = new Pen(Color.FromArgb(239, 239, 239));

        private Pen mPenOut = new Pen(Color.FromArgb(104, 104, 104));
        private Pen mPenOut2 = new Pen(Color.FromArgb(190, 190, 190));

        private Rectangle mSteepRect1;
        private Rectangle mSteepRect2;
        private Rectangle outnnerRect;
        private Rectangle outnnerRect2;

        private void CreatePaintElements()
        {
            DisposeBrushes();

            switch (mGradientStyle)
            {

                case GradientMode.HorizontalCenter:
                    //中间渐变
                    mSteepRect1 = new Rectangle(
                        3,
                        0,
                        this.Width / 2 + (int)(this.Width * 0.05),
                        mSteepHeight);
                    mBrush1 = new LinearGradientBrush(mSteepRect1, mColor1, mColor2, LinearGradientMode.Horizontal);

                    mSteepRect2 = new Rectangle(
                        mSteepRect1.Right - 1,
                        0,
                        this.Width - mSteepRect1.Width - 4,
                        mSteepHeight);
                    mBrush2 = new LinearGradientBrush(mSteepRect2, mColor2, mColor1, LinearGradientMode.Horizontal);
                    break;

                case GradientMode.Horizontal:
                    //左渐变右
                    mSteepRect1 = new Rectangle(
                        3,
                        0,
                        this.Width - 7,
                        mSteepHeight);
                    mBrush1 = new LinearGradientBrush(mSteepRect1, mColor1, mColor2, LinearGradientMode.Horizontal);
                    mSteepRect2 = new Rectangle(
                        -100,
                        -100,
                        1,
                        1);
                    mBrush2 = new LinearGradientBrush(mSteepRect2, mColor2, mColor1, LinearGradientMode.Horizontal);
                    break;


                case GradientMode.Vertical:
                    //下渐变上
                    mSteepRect1 = new Rectangle(
                        3,
                        0,
                        this.Width-7,
                        mSteepHeight);

                    //                    mBrush1 = new LinearGradientBrush(rTemp, mColor1, mColor2, LinearGradientMode.Horizontal);
                    mBrush1 = new LinearGradientBrush(this.ClientRectangle, mColor1, mColor2, LinearGradientMode.Vertical);
                    mSteepRect2 = new Rectangle(
                        -100,
                        -100,
                        1,
                        1);
                    mBrush2 = new LinearGradientBrush(mSteepRect2, Color.Red, Color.Red, LinearGradientMode.Vertical);
                    break;


                case GradientMode.VerticalCenter:
                    //中间渐变
                    mSteepRect1 = new Rectangle(
                        3,
                        0,
                        this.Width - 7,
                        mSteepHeight);
                    //                    mBrush1 = new LinearGradientBrush(rTemp, mColor1, mColor2, LinearGradientMode.Horizontal);
                    mBrush1 = new LinearGradientBrush(this.ClientRectangle, mColor1, mColor2, LinearGradientMode.Vertical);
                    mBrush1.SetBlendTriangularShape(0.5f);

                    mSteepRect2 = new Rectangle(
                        -100,
                        -100,
                        1,
                        1);
                    mBrush2 = new LinearGradientBrush(mSteepRect2, Color.Red, Color.Red, LinearGradientMode.Vertical);
                    break;


                case GradientMode.Diagonal:
                    //对角渐变
                    mSteepRect1 = new Rectangle(
                        3,
                        0,
                        this.Width - 7,
                        mSteepHeight);
                    //                    mBrush1 = new LinearGradientBrush(rTemp, mColor1, mColor2, LinearGradientMode.ForwardDiagonal);
                    mBrush1 = new LinearGradientBrush(this.ClientRectangle, mColor1, mColor2, LinearGradientMode.ForwardDiagonal);
                    //                    ((LinearGradientBrush) mBrush1).SetBlendTriangularShape(0.5f);

                    mSteepRect2 = new Rectangle(
                        -100,
                        -100,
                        1,
                        1);
                    mBrush2 = new LinearGradientBrush(mSteepRect2, Color.Red, Color.Red, LinearGradientMode.Horizontal);
                    break;

                default:
                    mBrush1 = new LinearGradientBrush(mSteepRect1, mColor1, mColor2, LinearGradientMode.Vertical);
                    mBrush2 = new LinearGradientBrush(mSteepRect2, mColor2, mColor1, LinearGradientMode.Vertical);
                    break;

            }

            innerRect = new Rectangle(
                this.ClientRectangle.X + 2,
                this.ClientRectangle.Y + 2,
                this.ClientRectangle.Width - 4,
                this.ClientRectangle.Height - 4);
            outnnerRect = new Rectangle(
                this.ClientRectangle.X,
                this.ClientRectangle.Y,
                this.ClientRectangle.Width - 1,
                this.ClientRectangle.Height - 1);
            outnnerRect2 = new Rectangle(
                this.ClientRectangle.X + 1,
                this.ClientRectangle.Y + 1,
                this.ClientRectangle.Width,
                this.ClientRectangle.Height);

        }

        #endregion

        #endregion
    }

}

 

转载于:https://www.cnblogs.com/pnglooog/archive/2013/01/07/2848561.html

weixin_34216107
关注
C#实现为RichTextBox控件添加自定义滚动条 （附完整源码）
希望我的博客，能帮上你解决学习中工作中所遇到的问题
06-17 469
C#实现为RichTextBox控件添加自定义滚动条 （附完整源码）
自定义控件上添加滚动条的源码
12-26
自定义控件上添加滚动条的源码 环境：vs2005 C#2.0
C#的自定义滚动条
dkvzkrdok146612647的博客
12-28 456
VS工具箱自带的滚动条，不能设置颜色。 在网上找资源，找到一个控制TextBox的垂直滚动条，链接为http://www.cnblogs.com/2seek/p/4455079.html 在这个的基础上改成了控制Panel，最后效果如下图 源码下载地址：http://pan.baidu.com/s/1jI0nSs2 1. BackColor控制滚动条颜色 2. Normal...
C#自定义滚动条
06-21
C#容器的自定义滚动条C#容器的自定义滚动条C#自定义滚动条
C#自定义控件加滑动条的简单实现例子
03-17
一个给自定义控件加滑动条的简单例子，适合比较简单的自定义控件。基本思路是外层在套一个自定义控件，加Panel.
C#的自定义滚动条-附件资源
03-05
C#的自定义滚动条-附件资源
C#为RichTextBox控件设置自定义滚动条
03-17
摘要:C#源码,菜单窗体,RichTextBox,滚动条　Visual C#为RichTextBox控件设置自定义滚动条，有时候我们确实需要RichTextBox控件有滚动条的功能，这样更加强化RichTextBox控件的功能，那么增加滚动条的功能是如何实现...
C# 树结构目录自定义控件，可以勾选单个、多个，可以添加、删除root，child，有滚动条
09-06
C# 树结构目录自定义控件，可以勾选单个、多个，可以添加、删除root，child，有滚动条 详情请看我的文章介绍，有图片展示 ：https://blog.csdn.net/m0_65636467/article/details/132711246
C# ListView中添加多种自定义控件源码
04-07
本主题将深入探讨如何在C#的ListView中添加和使用各种自定义控件，如CheckBox和ComboBox，以增强用户体验和功能。 一、ListView控件基础 ListView控件允许我们展示数据列表，并提供了多种视图模式，如小图标、大...
C# 自定义滚动条样式和多窗口切换
07-29
在C#中，我们可以利用`UserControl`类或者自定义控件来实现这一目标。 1. **自定义滚动条样式**： - **Windows Forms**：你可以通过继承`VScrollBar`或`HScrollBar`控件，重写`OnPaint`方法，使用`Graphics`对象...
C# winform 自定义滚动条
08-26
C# winform 自定义滚动条
C# winform自定义滚动条
08-24
C# winform自定义滚动条, 有源码
winform 自定义滚动条
08-25
winform 自定义滚动条
c# winform自定义滚动条
09-08 9518
先来点直观的效果图1.制作自定义滚动条,参考http://www.codeproject.com/KB/miscctrl/customscrollbar.aspx2.用自定义的滚动条遮住datagridview将要显示的滚动条。3.鼠标控制自定义滚动条。 /// /// 自定义滚动条滚动事件 /// ///
[C#] （原创）一步一步教你自定义控件——02，ScrollBar（滚动条）
chinaherolts2008的博客
01-06 3611
一、前言 技术没有先进与落后，只有合适与不合适。 本篇的自定义控件是：滚动条（ScollBar）。 我们可以在网上看到很多自定义的滚动条控件，它们大都是使用UserControl去做，即至少使用一个Panel或其它控件作滑块，使用UserControl本身或另一个控件作为背景条，而有的复杂的还会加上顶端和底端的按钮。这样作的好处有很多，最主要的是支持承载更加复杂的视觉和动作效果，比如使用一系列图片来实现非常炫丽的动画效果等。 不过本次所实现的滚动条并不需要太多复杂的效果，扁平化样式即可，所以就不需要使用Us
C# 自定义滚动条控件的实现
小何程序员的博客
10-31 7547
第一步 面板方面的配置 新建一个控件项目 新建一个panel控件 调整panel和面板的大小 为滚动条的样式 添加一个事时间控件 并配置好相关属性 将enabled属性设置为true interval设置为10毫秒 第二步 代码方面的配置 在控件类中 添加五个属性 private bool wheel_move = false; [Description("标识滚轮是否发生了运动")] public bool Wheel_move
C# 创建滚动条
qqqwwwqw的专栏
09-08 492
protected virtual void CreateDockControls()         {             panelDockBottom.SuspendLayout();             panelDockBottom.Controls.A
自定义滚动条样式
hzh254052917的博客
01-03 264
#area_data::-webkit-scrollbar { width: 8px; height: 8px; -webkit-border-radius: 4px; -moz-border-radius: 4px; border-radius: 4px; } #area_data::-webkit-scrollbar-thumb { backgr
自定义滚动条CCustomerScroll
singebogo的博客
04-13 377
自制滚动条 思路 利用CStatic派生出一个自定义的滚动条，在CStatic控件上利用位图绘制滚动条箭头，滚动块，滚动条的滚动区域，在绘制滚动条时，由于滚动块是可以被拖动， 所以需要频繁的绘制滚动条，为了防止屏幕闪烁，可以一个临时的CDC对象，将所有的绘图操作都在改临时对象上进行，然后在将临时的对象的内容绘制在滚动块的显示区域，可以将临时的CDC对象封装成CMemDC类，在改类...
C# 自定义控件 滚动条
最新发布
09-14
C#自定义控件滚动条的实现方法有多种。根据提供的引用内容，我可以为您提供以下方法和步骤来实现滚动条功能： 方法一： 1. 创建一个控件类，可以继承自Panel或者UserControl。该类将作为滚动条的容器。 2. 在该控件...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值