精华内容
下载资源
问答
  • canvas制作水波进度条

    2019-09-08 21:29:45
    canvas制作水波进度条
  • QT水波进度条DEMO

    2018-12-17 16:50:09
    QT水波进度条,可设置水波密度、高度、边框大小、各种颜色。 代码详解见:https://blog.csdn.net/pingis58/article/details/85051267
  • 主要为大家详细介绍了Android自定义view实现水波进度条控件,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • Android自定义View-实现圆形水波进度条
  • 纯canvas制作的水波纹进度条动画,支持拖到设置水波进度条大小代码
  • QT 带有动画的 圆形进度条 水波进度条

    千次阅读 多人点赞 2019-07-29 18:18:23
    所以这次我们就使用QT的paint 以及定时器来实现类似的水波进度条。 先看一下最终效果图: 这个是怎样实现的呢? 我们仍然是在一个QWidget上的paintEvent上重绘实现图形绘制 + QTimer 实现动画效果。 首...

    我们在使用其他软件的时候,经常能看到各种绚丽的进度条,其中带有水波波纹的进度条就是其中一个。对于PC端软件开发使用的QT,只是提供了process bar,样式十分单一。 所以这次我们就使用QT的paint 以及定时器来实现类似的水波进度条。
    先看一下最终效果图:
    在这里插入图片描述

    这个是怎样实现的呢? 我们仍然是在一个QWidget上的paintEvent上重绘实现图形绘制 + QTimer 实现动画效果。

    首先,我们是在一个QWidget 上进行绘制,绘制是在paintEvent 里面进行开始绘制。水波动画是使用QTimer 定时器进行定时触,重绘控件,造成水波波动的动画。
    我们照例来分解一下整个实现过程: 圆形背景(边框+背景) + 水波进度 + 进度数值。
    第一步,我们先绘制圆形的背景,这个背景包含边框,以及未被占有的背景。这个背景是一个圆形,我们使用 drawEllipse函数:

    void QPainter::drawEllipse(const QRectF &rectangle)

    其中我们通过设置 画笔QPen 的宽度来实现 边框:

    QPen pen;
    pen.setColor(borderColor);
    pen.setWidthF(borderWidth);
    pen.setJoinStyle(Qt::RoundJoin);
    painter->setPen(pen);

    通过设置画刷 QBrush 来设置未占用的的背景色:

    painter->setBrush(QBrush(m_bgColor));

    这样就完成了第一步,背景的绘制:

    void WaterProcess::drawBg(QPainter *painter)
    {
        int width = this->width();
        int height = this->height();
        int side = qMin(width, height) - m_borderWidth;
    
        int startX = (width - side) * 0.5;
        int startY = (height - side) * 0.5;
    
        painter->save();
        painter->setBrush(QBrush(m_bgColor));
        if (m_borderWidth == 0) {
            painter->setPen(Qt::NoPen);
        } else {
            QBrush brush(m_borderColor);
            painter->setPen(QPen(brush, m_borderWidth, Qt::SolidLine));
        }
    
        painter->drawEllipse(startX, startY, side, side);
        painter->restore();
    }
    
    

    我们来看看效果:
    在这里插入图片描述

    第二步,是需要绘制水波,这也是至关重要的一步。我们使用设定的颜色使用QPainterPath来设定,其中最重要的有两个,第一个就是QPainterPath 的一个intersected(求相交、挖除)功能。

    QPainterPath QPainterPath::intersected(const QPainterPath &p) const

    这个功能是返回两个路径相交(重合)的部分。我们来分析一下为什么使用这个求相交的功能。
    因为我们要实现水波,所以我们需要使用我们以前学过的正弦sin 或者余弦cos 函数,进行模拟水波。

    正弦曲线公式 y = A * qSin(ωx + φ) + k

    • A : 表示振幅, 我们可以用作水波的高度。
    • w : 表示周期,可以理解为水波密度,W越大,表示水波越密集。
    • k : 标识Y轴偏移量,可以理解为进度,取值是进度百分比

    我们可以设置两个透明度不同、起始位置有偏差的两条正弦曲线相互交错,形成波浪的起伏,更具有真实性。
    我们的大路径 totalPainterPath,是整个圆形。上面用到的正弦公式模拟的水波。我们就要使用到了上面提到的intersected相交函数,来去除额外不需要显示的部分。

    void WaterProcess::drawProcess(QPainter *painter)
    {
        int width = this->width();
        int height = this->height();
        int side = qMin(width, height) - (2 * m_borderWidth); //直径
    
        int startX = (width - side) * 0.5;
        int startY = (height - side) *0.5;
        int endX = startX + side;
        int endY = startY + side;
    
        double percent = (m_value * 1.0) / (m_maxValue - m_minValue);
    
        double w = 2 * M_PI / endX;
        double A = endY * m_waterHeight;
        double k = endY * (1.0 - percent);
    
        painter->save();
        painter->setPen(Qt::NoPen);
        painter->setBrush(m_usedColor);
    
        QPainterPath totalPath;
        //加入圆形路径
        totalPath.addEllipse(startX, startY, side, side);
    
        //水波路径
        QPainterPath water1;
        QPainterPath water2;
    
        water1.moveTo(startX, endY);
        water2.moveTo(startX, endY);
    
        m_offset += 0.6;
        if (m_offset > (endX / 2)) {
            m_offset = 0;
        }
    
        for(int i = startX; i < endX; i++) {
            //第一条波浪Y轴
            double waterY1 = (double)(A * qSin(w * i + m_offset)) + k;
            //第二条波浪Y轴
            double waterY2;
            waterY2 = (double)(A * qSin(w * i + m_offset + (endX / 2 * w))) + k;
    
            water1.lineTo(i, waterY1);
            water2.lineTo(i, waterY2);
    
            if (m_value == m_minValue) {
                waterY1 = endY;
            }
    
            if (m_value == m_maxValue) {
                waterY1 = startY;
            }
        }
        //封闭
        water1.lineTo(endX, endY);
        water2.lineTo(endX, endY);
    
        QPainterPath path;
        QColor waterColor1 = m_usedColor;
        waterColor1.setAlpha(100);
        QColor waterColor2 = m_usedColor;
        waterColor2.setAlpha(200);
    
        //第一条波浪
        path = totalPath.intersected(water1);
        painter->setBrush(waterColor1);
        painter->drawPath(path);
    
        //第二条波浪挖去后的路径
        path = totalPath.intersected(water2);
        painter->setBrush(waterColor2);
        painter->drawPath(path);
    
    
        painter->restore();
    }
    
    

    这个时候我们看一下效果图:
    在这里插入图片描述
    这时候就已经完成了大部分功能,不过很重要的是没有显示进度百分比。

    第三步就是 完成文字百分比的显示了,我们使用drawText函数进行函数绘制。

    void QPainter::drawText(const QPointF &position, const QString &text)

    这个就比较简单了,只需要算出来百分比就可以了,其实上一步我们已经完成了对百分比的算法了

    void WaterProcess::drawValue(QPainter *painter)
    {
        painter->save();
        int width = this->width();
        int height = this->height();
        int side = qMin(width, height) - m_borderWidth;
    
        int startX = (width - side) * 0.5;
        int startY = (height - side) * 0.5;
    
        int fontSize = side / 3;
    
    
        QFont font;
        font.setFamily("微软雅黑");
        font.setPixelSize(fontSize);
        font.setBold(true);
    
        painter->setFont(font);
        painter->setPen(Qt::white);
        painter->drawText(QRectF(startX, startY, side, side), Qt::AlignCenter, QString("%1%").arg(m_value));
    
        painter->restore();
    }
    
    

    到这里我们就完成了所有动作的绘制,只需要在paintEvent函数里进行调用了

    void WaterProcess::paintEvent(QPaintEvent *ev)
    {
        Q_UNUSED(ev)
    
        QPainter painter(this);
        painter.setRenderHints(QPainter::Antialiasing | QPainter::TextAntialiasing);
    
        //背景
        drawBg(&painter);
    
        //进度、水波
        drawProcess(&painter);
    
        //进度数字
        drawValue(&painter);
    }
    
    

    在初始化的时候启动定时器就好了!

    写在最后,例子已经上传到csdn了,没有积分的小伙伴,评论留下你的邮箱,看到后会立刻发出。

    demo下载地址

    没有积分支持的小伙伴,也可以访问、下载git代码,欢迎加星,会持续更新:https://github.com/xiezhongyuan/waterProcess

    展开全文
  • 因为需求所致,需要采用进度条,开始采用的是普通的横线进度条,感觉效果也不错,后面改成了水波进度条,也就是好看了一点,在后面改成了扇形进度条,逼迫无奈啊!!!最终采用了扇形进度条, 除了横线的QML自己提供...

    前言

    因为需求所致,需要采用进度条,开始采用的是普通的横线进度条,感觉效果也不错,后面改成了水波进度条,也就是好看了一点,在后面改成了扇形进度条,逼迫无奈啊!!!最终采用了扇形进度条,
    除了横线的QML自己提供,其他的都要自己计算位置自己来画,甚是麻烦,于是记录下来,也给后面需求的人一个参考吧!

    废话不多说了,看下面代码,,列出三种不同的进度条画法和对应的效果图!!!
    下面效果图的时间测试都是800ms
    横线进度条: 不会一顿一顿的,效果看起来还是不错
    在这里插入图片描述
    水波进度条
    进度条满状态时的效果:
    在这里插入图片描述
    进度条只到70%的效果
    在这里插入图片描述
    扇形进度条
    在这里插入图片描述
    圆环进度条
    在这里插入图片描述
    下面两个抗锯齿实在不敢恭维,没法,研究N久还是不能解决,使用scale还是效果不显著

    点状进度条

    在这里插入图片描述
    针形进度条
    在这里插入图片描述




    分割线




    正文

    下面来说说具体的实现把,先从横线进度条说起,其实没啥好说的,这个是qml自带的,所以使用自带ProgressBar控件就能实现,文档也有具体实现步骤,只是走动会一卡一卡的,流程走动需要自己优化,下面贴出我实现的代码:

    横线进度条

    import QtQuick 2.12
    import QtQuick.Controls 2.12
    import QtGraphicalEffects 1.0
    
    ProgressBar {
        id: control
        value: 0.5
        padding: 2
    
        //进度条的宽和高,也可以直接外面指定width和height
        property var pwidth: 200
        property var pheight: 4
    
        //是否显示进度条文本百分比进度
        property bool showText: true  //是否显示进度条的文本
        property color textForegroundColor: "#8B0000"//被进度条遮挡后的颜色
        property color textBackgroundColor: "#363636" //未被进度条遮挡时的颜色
    
        //进度条内部颜色
        property color  barColorS:"#ffffff";  //进度条的前度颜色
        property color  barColorM:"#97FFFF"; //进度条的中度颜色
        property color  barColorE:"#36d1e8";//进度条的尾度颜色
    
    
        background: Rectangle {
            implicitWidth: pwidth
            implicitHeight: 6
            color: "#e6e6e6"
            radius: 3
        }
    
        contentItem: Item {
            implicitWidth: pwidth
            implicitHeight: pheight
    
            Rectangle {
                id:id_progressRect
                width: control.visualPosition * parent.width
                height: parent.height
                radius: 2
                Behavior on width{
                     NumberAnimation { duration: 900 }
                }
    
                //color: "#17a81a"
                LinearGradient{
                                      anchors.fill: parent;
                                      gradient: Gradient {
                                          GradientStop {
                                              position: 0.00;
                                              color: barColorS
                                          }
                                          GradientStop {
                                              position: 0.45;
                                              color: barColorM;
                                          }
                                          GradientStop {
                                              position: 1.00;
                                              color: barColorE;
                                          }
                                      }
                                      start:Qt.point(0, 0);
                                      end: Qt.point(parent.width, 0);
                                  }
    
            }
            Text {
                color: id_progressRect.width > x?textForegroundColor:textBackgroundColor
                anchors.verticalCenter: parent.verticalCenter
                anchors.right: parent.right
    
                font.bold:true
                text:(control.value * 100).toFixed(2) +"%"
            }
        }
    }
    

    水波进度条

    这个进度条需求自己使用画布实现,还有具体的公式,我也是参考网上的html实现来的,具体看到代码:

    import QtQuick 2.0
    
    Item {
    
        height:300
        width: 300
        //range信息
        property int rangeValue: 0; //外面调用设置此致即可
    
    
        property bool startPainter:true //启动定时器刷新,默认是16ms,也就是60fps
        //画布
        property int mW: height>width?height/2:width/2 // 250;
        property int mH:height>width?height/2:width/2  //250;
        property int lineWidth: 2;
    
        //圆
        property double r: mH / 2; //圆心
        property double cR: r - 16 * lineWidth; //圆半径
    
        //圆外圈的颜色
        property color  outerRingLineColor:'#36d1e8'
    
        //波浪颜色
        property color waveColor: '#1c86d1'
    
        //显示进度的字体颜色
        property string textColor: "rgba(14, 80, 14, 0.8)"
        //Sin曲线
        property int sX: 0;
        property int sY: mH / 2;
        property int axisLength: mW;        //轴长
        property double waveWidth: 0.015;   //波浪宽度,数越小越宽
        property double waveHeight: 6;      //波浪高度,数越大越高
        property double speed: 0.09;        //波浪速度,数越大速度越快
        property double xOffset: 0;         //波浪x偏移量
    
    
        Canvas{
            id: canvas
            height: mH
            width: mW
            anchors.centerIn: parent
            property int nowRange: 0; //不要设置该值
            //antialiasing: true
            onPaint: {
                var ctx = getContext("2d");
    
                ctx.clearRect(0, 0, mW, mH);
    
                //显示外圈
                ctx.beginPath();
                ctx.strokeStyle = outerRingLineColor;
                ctx.arc(r, r, cR+5, 0, 2*Math.PI);
                ctx.stroke();
                ctx.beginPath();
                ctx.arc(r, r, cR, 0, 2*Math.PI);
                ctx.clip();
    
                //显示sin曲线
                ctx.save();
                var points=[];
                ctx.beginPath();
                for(var x = sX; x < sX + axisLength; x += 20 / axisLength){
                    var y = -Math.sin((sX + x) * waveWidth + xOffset);
                    var dY = mH * (1 - nowRange / 100 );
                    points.push([x, dY + y * waveHeight]);
                    ctx.lineTo(x, dY + y * waveHeight);
                }
    
                //显示波浪
                ctx.lineTo(axisLength, mH);
                ctx.lineTo(sX, mH);
                ctx.lineTo(points[0][0],points[0][1]);
                ctx.fillStyle = waveColor;
                ctx.fill();
                ctx.restore();
    
                //显示百分数
                ctx.save();
                var size = 0.4*cR;
                ctx.font = size + 'px Arial';
                ctx.textAlign = 'center';
                ctx.fillStyle = textColor
                ctx.fillText(~~nowRange + '%', r, r + size / 2);
                ctx.restore();
    
    
                //增加Rang值
                if(canvas.nowRange <= rangeValue){
                    canvas.nowRange  += 1;
                }
                if(canvas.nowRange > rangeValue){
                    canvas.nowRange -= 1;
                }
    
                xOffset += speed;
            }
    
            Timer{
                id: timer
                running: startPainter
                repeat: true
                interval: 16
                onTriggered:{
                    parent.requestPaint();
                }
            }
        }
    }
    
    

    扇形进度条

    扇形进度条具体实现原理可以参考我的这篇博客,Qml–canvas实践小实例 —— 扇形看了此博客,定会让你眼前一亮的,我其他的进度条也是基于此博客的基础上改编的,下面贴出实现的代码:

    import QtQuick 2.5
    import QtQuick.Layouts 1.2
    import QtQuick.Controls 1.4
    
    // draws two arcs (portion of a circle)
    // fills the circle with a lighter secondary color
    // when pressed
    
    Rectangle{
        id:id_progress
        height: 300
        width: 300
        
        
        //当前进度值,
        property alias value: canvas.rangeValue;
        
        property color backgroundColor: "#5B5B5B"   //背景颜色
        property color foregroundColor:"#394450"   //前景颜色
        
        //线宽
        property int lineWidth: 10 //10
        
        //消息状态
        property alias messageText: id_TextMessaageprogress.text
        
        //最大值范围,默认是100
        property alias maxRangeValue: canvas.maximumValue
        
        
        property var canvasW:id_progress.width
        property var canvasH:id_progress.height
        
        //字体颜色
        property color textColor: "#DC5712" //"#00BFFF"
        
        color: "#00000000"
        Canvas {
            id: canvas
            width: canvasW
            height: canvasH
            anchors.centerIn: parent
            antialiasing: true
            
            property int rangeValue: 0;
            property color primaryColor: foregroundColor//  "orange"
            property color secondaryColor: backgroundColor  //"lightblue"
            
            property real centerWidth: width/2
            property real centerHeight: height/2
            //property real radius: Math.min(canvas.width, canvas.height) / 2
            property real  radius: Math.min(canvas.width - lineWidth, canvas.height -lineWidth) / 2
            
            property real minimumValue: 0
            property real maximumValue: 100
            
            property real currentValue: 0  //当前值
            // this is the angle that splits the circle in two arcs
            // first arc is drawn from 0 radians to angle radians
            // second arc is angle radians to 2*PI radians
            property real angle: (currentValue - minimumValue) / (maximumValue - minimumValue) * 2 * Math.PI
            
            // we want both circle to start / end at 12 o'clock
            // without this offset we would start / end at 9 o'clock
            property real angleOffset: -Math.PI / 2
            
            signal clicked()
            
            onPrimaryColorChanged: requestPaint()
            onSecondaryColorChanged: requestPaint()
            onMinimumValueChanged: requestPaint()
            onMaximumValueChanged: requestPaint()
            onCurrentValueChanged: requestPaint()
            
            // 把角度转换为弧度
            function angleToRadian( angle ) {
                return Math.PI / 180 * angle;
            }
            
            onPaint: {
                var ctx = getContext("2d");
                ctx.save();
                
                
                //先画一个静态的内部圆(满圆)
                ctx.beginPath();
                ctx.moveTo(canvas.centerWidth,canvas.centerHeight);
                ctx.lineWidth = 1;
                ctx.strokeStyle = primaryColor;
                ctx.arc(canvas.centerWidth,
                        canvas.centerHeight,
                        canvas.radius , //canvas.radius
                        angleOffset+ canvas.angle,
                        angleOffset + 2*Math.PI);
                
                ctx.fillStyle = primaryColor;
                ctx.fill();
                ctx.stroke();
                ctx.closePath();
                ctx.restore();
                
                //开始画一个走动的扇形圆
                ctx.beginPath();
                ctx.lineWidth = 1;
                ctx.strokeStyle = secondaryColor;
                ctx.moveTo(canvas.centerWidth,canvas.centerHeight);
                
                ctx.arc(canvas.centerWidth,canvas.centerHeight,radius,angleOffset,angleOffset+angle);
                ctx.closePath();
                ctx.fillStyle = secondaryColor;
                ctx.fill();
                ctx.stroke();
                ctx.restore();
                if(currentValue <= rangeValue ){
                    currentValue  += 1;
                }
                if(currentValue > rangeValue){
                    currentValue -= 1;
                }
            }
            
            Text {
                id: txt_progress
                anchors.centerIn: parent
                
                font.pixelSize: 18//FQmlSingleton.font_SuperBig
                text:  canvas.currentValue.toString()+"%"; // canvas.text
                color: textColor
            }
            Text {
                id: id_TextMessaageprogress
                anchors.top: txt_progress.bottom
                anchors.topMargin:10 //FQmlSingleton.spacingMiddle
                anchors.horizontalCenter: parent.horizontalCenter
                font.pixelSize: 14// FQmlSingleton.font_Middle
                
                color: textColor
            }
            
            MouseArea {
                id: mouseArea
                
                anchors.fill: parent
                onClicked: canvas.clicked()
                onPressedChanged: canvas.requestPaint()
            }
            
            
            Timer{
                id: timer
                interval: 16;
                running: true;
                repeat: true;
                onTriggered: {
                    
                    parent.requestPaint();
                }
                
            }
        }
        
    }
    

    至于其他进度条可以根据此进度条来改善,也算是留给有需求的道友一个参考延伸!!!

    展开全文
  • Qt编写水波进度条控件

    千次阅读 2017-08-24 13:46:50
    手机app中经常能见到各种各样的水波进度条之类的效果,觉得不错,用QWidget的QPainter绘制了一个。集成到了QUC自定义控件中。原理是利用正弦曲线产生平滑曲线点集合,然后用大路径减去当前进度路径,形成水波效果。...

    手机app中经常能见到各种各样的水波进度条之类的效果,觉得不错,用QWidgetQPainter绘制了一个。集成到了QUC自定义控件中。原理是利用正弦曲线产生平滑曲线点集合,然后用大路径减去当前进度路径,形成水波效果。 
    /**
    * 水波进度条控件 作者:feiyangqingyun(QQ:517216493) 2017-8-23
    * 1:可设置范围值,支持负数值
    * 2:可设置水波密度,密度越大浪越多
    * 3:可设置水波高度,高度越大越浪
    * 4:可设置边框宽度
    * 5:可设置是否显示进度值
    * 6:可设置进度值是否为百分比格式
    * 7:可设置背景颜色、边框颜色、当前进度颜色、文字颜色
    * 8:提供三种样式风格选择 方形风格 圆形风格 椭圆风格
    */

    核心代码:

     

    void ProgressBarWater::drawValue(QPainter *painter)
    {
        int height = this-> height();
        int width = this->width();
        int side = qMin(width, height);
    
        //计算当前值所占百分比
        double percent = 1 - (double)(value - minValue) / (maxValue - minValue);
    
        //正弦曲线公式 y = A * sin(ωx + φ) + k
    
        //w表示周期,可以理解为水波的密度,值越大密度越大(浪越密集 ^_^),取值 密度*M_PI/宽度
        double w = waterDensity * M_PI / width;
    
        //A表示振幅,可以理解为水波的高度,值越大高度越高(越浪 ^_^),取值高度的百分比
        double A = height * waterHeight;
    
        //k表示y轴偏移,可以理解为进度,取值高度的进度百分比
        double k = height * percent;
    
        //第一条波浪路径集合
        QPainterPath waterPath1;
        //第二条波浪路径集合
        QPainterPath waterPath2;
    
        //移动到左上角起始点
        waterPath1.moveTo(0, height);
        waterPath2.moveTo(0, height);
    
        offset += 0.6;
        if (offset > (width / 2)) {
            offset = 0;
        }
    
        for(int x = 0; x <= width; x++) {
            //第一条波浪Y轴
            double waterY1 = (double)(A * sin(w * x + offset)) + k;
    
            //第二条波浪Y轴
            double waterY2 = (double)(A * sin(w * x + offset + (width / 2 * w))) + k;
    
            //如果当前值为最小值则Y轴为高度
            if (this->value == minValue) {
                waterY1 = height;
                waterY2 = height;
            }
    
            //如果当前值为最大值则Y轴为0
            if (this->value == maxValue) {
                waterY1 = 0;
                waterY2 = 0;
            }
    
            waterPath1.lineTo(x, waterY1);
            waterPath2.lineTo(x, waterY2);
        }
    
        //移动到右下角结束点,整体形成一个闭合路径
        waterPath1.lineTo(width, height);
        waterPath2.lineTo(width, height);
    
        //大路径
        QPainterPath bigPath;
    
        if (percentStyle == PercentStyle_Rect) {
            width = width - borderWidth * 2;
            height = height - borderWidth * 2;
            bigPath.addRect(borderWidth, borderWidth, width, height);
        } else if (percentStyle == PercentStyle_Circle) {
            side = side - borderWidth * 2;
            bigPath.addEllipse((width - side) / 2, borderWidth, side, side);
        } else if (percentStyle == PercentStyle_Ellipse) {
            width = width - borderWidth * 2;
            height = height - borderWidth * 2;
            bigPath.addEllipse(borderWidth, borderWidth, width, height);
        }
    
        painter->save();
    
        //新路径,用大路径减去波浪区域的路径,形成遮罩效果
        QPainterPath path;
        painter->setPen(Qt::NoPen);
        QColor waterColor1 = usedColor;
        waterColor1.setAlpha(100);
        QColor waterColor2 = usedColor;
        waterColor2.setAlpha(180);
    
        //第一条波浪挖去后的路径
        path = bigPath.intersected(waterPath1);
        painter->setBrush(waterColor1);
        painter->drawPath(path);
    
        //第二条波浪挖去后的路径
        path = bigPath.intersected(waterPath2);
        painter->setBrush(waterColor2);
        painter->drawPath(path);
    
        painter->restore();
    }

     

     

     

     

     

    展开全文
  • Qt自定义控件--水波进度条 Qt绘制水波进度条控件 样式可定制 圆形风格: 矩形风格: 椭圆风格: 如需要,留言。

    Qt自定义控件--水波进度条

    Qt绘制水波进度条控件

    样式可定制


    圆形风格:


    矩形风格:


    椭圆风格:


    如需要,留言。

    展开全文
  • wpf 水波进度条 用户控件 原文:wpf 水波进度条 用户控件之前看公司web前端做了个 圆形的水波纹 进度条,就想用wpf 做一个,奈何自己太菜 一直做不出来,在看过 “普通的地球人” 的 “ WPF实现三星...
  • android水波进度条

    2014-12-05 14:26:08
    改变单调的进度条界面,改为上升的水波进度条,可能有些简单,但却实用。
  • Android水波进度条

    2016-02-26 18:11:52
    这是我的博客地址,欢迎大家交流。 http://blog.csdn.net/u010386612
  • 纯canvas制作的水波纹进度条动画,支持拖到设置水波进度条大小代码代码结构1. HTML代码var canvas = document.getElementById('c');var ctx = canvas.getContext('2d');var range = document.getElementById('r');//...
  • Qt自定义控件——动态正弦波浪线 水波进度条 圆形、矩形、椭圆形等效果 ...
  • Qt水波进度条Demo

    千次阅读 2017-10-17 15:44:14
    多谢飞扬青春的博客,看到水波形进度条的效果觉得非常不错,于是自己也模仿着做了一个类似的,效果图: 原理: 利用正弦曲线产生平滑曲线点集合,然后用大路径减去当前进度路径,形成水波效果。  ...
  •  * 水波波峰高度落差幅度 name="waveHeightRange" format="dimension|reference"  * 水波显示的当前进度 name="waveProgress" format="float"  * 显示的文本内容 name="contentText" format="string|reference" ...
  • /*** 水波进度条*/public class BezierProgressView extends View {private float progress;private float maxProgress;private int radius;private int circleColor;private int waveColor;private int textColor...
  • 一个是 未开始下载显示建立下载链接,下载过程中更新进度百分比正在下载以及水波纹更新和下载完成之后显示下载完成以及对勾动画. 具体效果如下: 具体的功能介绍都在代码中,因UI绘制大部分都是在分部执行动画和...
  • Android,水波进度条

    千次阅读 2016-02-26 18:16:23
    这样就完成一个简单的圆形水波进度条了,不过还不能设置进度,也不够炫酷。 想继续了解的可以去Github上下载代码自己研究,也可以研究我的代码,都差不多。只是我精简了一些功能,并且加上了注释。 ...
  • 10 *lineWidth ctx.beginPath() ctx.lineWidth=lineWidth//水波动画初始参数 let axisLength= 2 *r- 16 *lineWidth//Sin 图形长度 let unit=axisLength/ 9 //波浪宽 let range=.4 //浪幅 let nowrange=range let ...
  • 安卓通过自定义view实现水滴到水波溅起水花并且水波流动上涨的进度条控件通过自定义view实现了一个水滴滴落到水波面,溅起水花并且水波流动上涨的进度条控件。之前看到过好多水波流动的进度条,感觉欠缺些东西,就...
  • 最近做了一个小项目,里面有一个需求需要添加一个动态进度条进度条的样式就类似于水波来回起伏的那种形状,下面就是最初的展示效果(有一点区别,这里我加了一个进度自动增加的功能): end_imag11252323.gif 下面先...
  • android 水波进度条WaveViewProgressBar

    千次阅读 2014-10-24 15:09:21
    Demo源码

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,930
精华内容 772
关键字:

水波进度条