Qt Repository 와 잡담

압축파일 참조 Qt Mingw32bit 라이브러리 사용

//출처 : 내가만든거

QString CUtil::hexaToHexaString(uint target, ENDIAN endian)
{
    QString retValue;
    uchar targetBuf[4] = { 0, };
    uchar* targetPtr = (uchar*)⌖

    if (endian == ENDIAN_BIG)
    {
        targetBuf[0] = targetPtr[3];
        targetBuf[1] = targetPtr[2];
        targetBuf[2] = targetPtr[1];
        targetBuf[3] = targetPtr[0];
    }
    else
    {
        targetBuf[0] = targetPtr[0];
        targetBuf[1] = targetPtr[1];
        targetBuf[2] = targetPtr[2];
        targetBuf[3] = targetPtr[3];
    }

    retValue.sprintf("%02x%02x%02x%02x", targetBuf[0], targetBuf[1], targetBuf[2], targetBuf[3]);
    return retValue;
}

QString CUtil::hexaToAsciiString(const uint hexaData, CUtil::ENDIAN endian)
{
    char* ascStr = (char*)&hexaData;

    QString ret;

    if (endian == ENDIAN_BIG)
    {
        ret.append(ascStr[3]);
        ret.append(ascStr[2]);
        ret.append(ascStr[1]);
        ret.append(ascStr[0]);
    }
    else
    {
        ret.append(ascStr[0]);
        ret.append(ascStr[1]);
        ret.append(ascStr[2]);
        ret.append(ascStr[3]);
    }


    return ret;
}

함수설명

예를들어 데이터를 int(4byte)에 담아서 뭔가를 한다고 하자 근데 1byte마다 hexa형태의 데이터를 사용해야 할 때가있다.

가령 데이터가

0x31313131 < - 요런식으로

첫번째함수는

0x31313131를 -> 고대로 "31313131" 로 바꾸어준다

두번째함수는

0x31313131를 -> 아스키형태의 String으로 "1111"로 바꾸어준다. 필요한사람 가져다쓰세요~

함수는 uint로 했지만 다른 메모리를 사용하고 싶다면 적당히 오버로딩해서 여러타입을 넣어서쓰면된다.

#include <QBitArray>

QBitArray charToBitArray(char bits)
{
    QBitArray array(8);
    return array.fromBits(&bits, 8);
}

Connect를 하다보면 같은 프로토콜이 다른 위젯에서 일시적으로 필요한 경우가있다.

이 경우 위젯이 메모리에서 삭제되면 disconnect가 자동으로 일어나기때문에 문제는 안되지만

상시적으로 살아있는 인스턴스라던가 혹은 자신의 부모위젯일경우 문제가 발생한다.

따라서 qt에서는 시그널을 끊을수있는 옵션이있다.

QMetaObject::Connection connectSignal;

connectSignal = connect(...);

//해제가 필요한 시점

disconnect(connectSignal);

간단하게 사용가능하다 :)

connectSignal은 실수를 방지하기 위해 해제후 초기화 해주는것이 좋다.

#ifdef __WIN32

#include <windows.h>

#include <qt_windows.h>

#include <dbt.h>

#endif

bool MainWindow::nativeEvent(const QByteArray & /*eventType*/, void msg, long /*result*/)
{
MSG* message = static_cast<MSG*>(msg);

if(message == nullptr)
    return false;

switch(message->message)
{
case  WM_DEVICECHANGE:
{
    DEV_BROADCAST_HDR* deviceType = (DEV_BROADCAST_HDR*) message->lParam;

    if(deviceType == nullptr)
        return false;

    if(deviceType->dbch_devicetype == DBT_DEVTYP_VOLUME) //USB
    {
        switch(message->wParam)
        {
        case DBT_DEVICEARRIVAL:
            //in
            break;

        case DBT_DEVICEREMOVECOMPLETE:
            //out
            break;
        }
    }


}   break;
}


return false;

}

//QWidget을 상속받은 클래스에서만 사용가능.

//.pro

DEFINES += USE_FLAG=1 #띄어쓰기 금지

CONFIG += USE_FLAG

USE_FLAG{

TARGET = MY_APP_NAME

}

//.cpp or .h

#ifdef USE_FLAG

 printf("매크로 사용");

#endif

cannot queue arguments of type qregistermetatype 이런 에러가나온다면

Q_DECLARE_METATYPE(MY_SCOPE::MY_TYPE) 

을사용한다 

만약 템플릿 클래스를 사용한다면

이런식으로

Q_DECLARE_METATYPE(QVector<MY_SCOPE::MY_TYPE>)) 

템플릿 클래스까지 같이 기재하고 스코프도 명확하게 기재하여

클래스바깥

class MY_SCOPE

{

};

Q_DELARE~~~~ 

를 기재해야한다 .

//.h

//////////////////////////////////////////////////////////////////////////////
// Date of creation: 04.07.2013
// Creator: Alexander Egorov aka mofr
// Modifier : sp.Park 2018.10.30
// Authors: mofr
//////////////////////////////////////////////////////////////////////////////


#pragma once


#include <QWidget>
#include <QPropertyAnimation>


class ProgressCircle : public QWidget
{
private:
    Q_OBJECT
    Q_PROPERTY(int value READ value WRITE setValue NOTIFY valueChanged)
    Q_PROPERTY(int maximum READ maximum WRITE setMaximum NOTIFY maximumChanged)
    Q_PROPERTY(qreal innerRadius READ innerRadius WRITE setInnerRadius)
    Q_PROPERTY(qreal outerRadius READ outerRadius WRITE setOuterRadius)
    Q_PROPERTY(QColor color READ color WRITE setColor)


    Q_PROPERTY(qreal infiniteAnimationValue READ infiniteAnimationValue WRITE setInfiniteAnimationValue)
    Q_PROPERTY(int visibleValue READ visibleValue WRITE setVisibleValue)


    struct privateStruct;
public:
    explicit ProgressCircle(QWidget *parent = nullptr);
    virtual ~ProgressCircle();


    int value() const;


    /**
     * @brief maximum
     * If maximum <= 0, widget shows infinite process;
     * @return
     */
    int maximum() const;


    /**
     * @brief innerRadius = [0.0 .. 1.0]
     * @return
     */
    qreal innerRadius() const;


    /**
     * @brief outerRadius = [0.0 .. 1.0]
     * @return
     */
    qreal outerRadius() const;


    QColor color() const;




    void animationStart();
    void animationFinished();
    void animationPaused();


    void startInfiniteAnimation();
    void stopInfiniteAnimation();
    void pauseInfiniteAnimation();


public slots:
    void setValue(int value);
    void setMaximum(int maximum);


    void setInnerRadius(qreal innerRadius);
    void setOuterRadius(qreal outerRadius);


    void setColor(QColor color);


signals:
    void valueChanged(int);
    void maximumChanged(int);


protected:
    void paintEvent(QPaintEvent *);


private slots:
    void setInfiniteAnimationValue(qreal value);
    void setVisibleValue(int value);


private:
    void initAnimation();
    QString key() const;
    QPixmap generatePixmap() const;
    qreal infiniteAnimationValue() const;
    int visibleValue() const;


private:
    QScopedPointer<privateStruct> d;
};

-------------------------------------

.cpp

/////////////////////////////////////////////////////////////////////////////

// Date of creation: 04.07.2013

// Creator: Alexander Egorov aka mofr

// Modifier : sp.Park 2018.10.30

// Authors: mofr

/////////////////////////////////////////////////////////////////////////////

#include "ProgressCircle.h"

#include <QPainter>

#include <QPixmapCache>

struct ProgressCircle::privateStruct

{

    qreal mInnerRadius;

    qreal mOuterRadius;

    qreal mInfiniteAnimationValue;

    QColor mColor;

    QPropertyAnimation mValueAnimation;

    QPropertyAnimation mInfiniteAnimation;

    int mValue = 0;

    int mMaximum = 0;

    int mVisibleValue = 0;

    bool mIsInfinite = true;

};

ProgressCircle::ProgressCircle(QWidget *parent) :

    QWidget(parent),

    d(new privateStruct)

{

    d->mValueAnimation.setTargetObject(this);

    d->mValueAnimation.setPropertyName("visibleValue");

    d->mInfiniteAnimation.setTargetObject(this);

    d->mInfiniteAnimation.setPropertyName("infiniteAnimationValue");

    d->mInfiniteAnimation.setLoopCount(-1);//infinite

    d->mInfiniteAnimation.setDuration(1000);

    d->mInfiniteAnimation.setStartValue(0.0);

    d->mInfiniteAnimation.setEndValue(1.0);

}

ProgressCircle::~ProgressCircle()

{

}

int ProgressCircle::value() const

{

    return d->mValue;

}

int ProgressCircle::maximum() const

{

    return d->mMaximum;

}

qreal ProgressCircle::innerRadius() const

{

    return d->mInnerRadius;

}

qreal ProgressCircle::outerRadius() const

{

    return d->mOuterRadius;

}

QColor ProgressCircle::color() const

{

    return d->mColor;

}

void ProgressCircle::initAnimation()

{

    d->mColor = QColor(110, 190, 235);

    d->mInnerRadius = 0.6;

    d->mOuterRadius = 1.0;

    QPropertyAnimation * progressCircleAnimation = new QPropertyAnimation(this, "outerRadius", this);

    progressCircleAnimation->setDuration(1000);

    progressCircleAnimation->setEasingCurve(QEasingCurve::OutQuad);

    progressCircleAnimation->setStartValue(0.0);

    progressCircleAnimation->setEndValue(d->mOuterRadius);

    progressCircleAnimation->start(QAbstractAnimation::DeleteWhenStopped);

    progressCircleAnimation = new QPropertyAnimation(this, "innerRadius", this);

    progressCircleAnimation->setDuration(500);

    progressCircleAnimation->setEasingCurve(QEasingCurve::OutQuad);

    progressCircleAnimation->setEndValue(d->mInnerRadius);

    progressCircleAnimation->start(QAbstractAnimation::DeleteWhenStopped);

    progressCircleAnimation = new QPropertyAnimation(this, "color", this);

    progressCircleAnimation->setDuration(500);

    progressCircleAnimation->setEasingCurve(QEasingCurve::OutQuad);

    progressCircleAnimation->setEndValue(d->mColor);

    progressCircleAnimation->start(QAbstractAnimation::DeleteWhenStopped);

}

void ProgressCircle::animationStart()

{

    this->setValue(0);

    this->initAnimation();

    d->mIsInfinite = true;

    d->mInfiniteAnimation.start();

}

void ProgressCircle::animationFinished()

{

    d->mIsInfinite = false;

    d->mInfiniteAnimation.stop();

    this->setValue(this->maximum());

    QPropertyAnimation * animation = new QPropertyAnimation(this, "outerRadius", this);

    animation->setDuration(1000);

    animation->setEasingCurve(QEasingCurve::OutQuad);

    animation->setEndValue(0.5);

    animation->start(QAbstractAnimation::DeleteWhenStopped);

    animation = new QPropertyAnimation(this, "innerRadius", this);

    animation->setDuration(500);

    animation->setEasingCurve(QEasingCurve::OutQuad);

    animation->setEndValue(0.0);

    animation->start(QAbstractAnimation::DeleteWhenStopped);

    QColor color(155,219,58);

    animation = new QPropertyAnimation(this, "color", this);

    animation->setDuration(500);

    animation->setEasingCurve(QEasingCurve::OutQuad);

    animation->setEndValue(color);

    animation->start(QAbstractAnimation::DeleteWhenStopped);

}

void ProgressCircle::animationPaused()

{

    QPropertyAnimation * animation = new QPropertyAnimation(this, "outerRadius", this);

    animation->setDuration(1000);

    animation->setEasingCurve(QEasingCurve::OutQuad);

    animation->setEndValue(0.5);

    animation->start(QAbstractAnimation::DeleteWhenStopped);

    animation = new QPropertyAnimation(this, "innerRadius", this);

    animation->setDuration(500);

    animation->setEasingCurve(QEasingCurve::OutQuad);

    animation->setEndValue(0.0);

    animation->start(QAbstractAnimation::DeleteWhenStopped);

    QColor color(255,100,100);

    animation = new QPropertyAnimation(this, "color", this);

    animation->setDuration(500);

    animation->setEasingCurve(QEasingCurve::OutQuad);

    animation->setEndValue(color);

    animation->start(QAbstractAnimation::DeleteWhenStopped);

}

void ProgressCircle::startInfiniteAnimation()

{

    this->animationStart();

}

void ProgressCircle::stopInfiniteAnimation()

{

    this->animationFinished();

}

void ProgressCircle::pauseInfiniteAnimation()

{

    d->mInfiniteAnimation.pause();

}

void ProgressCircle::setValue(int value)

{       

    if(d->mIsInfinite == true)

        return;

    if(value < 0)

        value = 0;

    if((qFuzzyCompare(d->mInnerRadius, 0.6) == false) || (qFuzzyCompare(d->mOuterRadius, 1.0) == false))

    {

        this->initAnimation();

        if(this->maximum() == 0)

            this->setMaximum(100);

    }

    if(d->mValue != value)

    {

        d->mValueAnimation.stop();

        d->mValueAnimation.setEndValue(value);

        d->mValueAnimation.setDuration(250);

        d->mValueAnimation.start();

        d->mValue = value;

        emit valueChanged(value);

    }

}

void ProgressCircle::setMaximum(int maximum)

{

    if(maximum < 0)

        maximum = 0;

    if(d->mMaximum != maximum)

    {

        d->mMaximum = maximum;

        this->update();

        emit maximumChanged(maximum);

    }

}

void ProgressCircle::setInnerRadius(qreal innerRadius)

{

    if(innerRadius > 1.0)

        innerRadius = 1.0;

    if(innerRadius < 0.0)

        innerRadius = 0.0;

    if(d->mInnerRadius != innerRadius)

    {

        d->mInnerRadius = innerRadius;

        this->update();

    }

}

void ProgressCircle::setOuterRadius(qreal outerRadius)

{

    if(outerRadius > 1.0)

        outerRadius = 1.0;

    if(outerRadius < 0.0)

        outerRadius = 0.0;

    if(d->mOuterRadius != outerRadius)

    {

        d->mOuterRadius = outerRadius;

        this->update();

    }

}

void ProgressCircle::setColor(QColor color)

{

    if(color != d->mColor)

    {

        d->mColor = color;

        this->update();

    }

}

QRectF squared(QRectF rect)

{

    if(rect.width() > rect.height())

    {

        qreal diff = rect.width() - rect.height();

        return rect.adjusted(diff/2, 0, -diff/2, 0);

    }

    else

    {

        qreal diff = rect.height() - rect.width();

        return rect.adjusted(0, diff/2, 0, -diff/2);

    }

}

void ProgressCircle::paintEvent(QPaintEvent *)

{

    QPixmap pixmap;

    if (!QPixmapCache::find(key(), pixmap))

    {

        pixmap = generatePixmap();

        QPixmapCache::insert(key(), pixmap);

    }

    // Draw pixmap at center of item

    QPainter painter(this);

    painter.drawPixmap( 0.5 * ( width() - pixmap.width() ), 0.5 * ( height() - pixmap.height() ), pixmap );

}

void ProgressCircle::setInfiniteAnimationValue(qreal value)

{

    d->mInfiniteAnimationValue = value;

    this->update();

}

void ProgressCircle::setVisibleValue(int value)

{

    if(d->mVisibleValue != value)

    {

        d->mVisibleValue = value;

        this->update();

    }

}

QString ProgressCircle::key() const

{

    return QString("%1,%2,%3,%4,%5,%6,%7,%8")

            .arg(d->mInfiniteAnimationValue)

            .arg(d->mVisibleValue)

            .arg(d->mMaximum)

            .arg(d->mInnerRadius)

            .arg(d->mOuterRadius)

            .arg(this->width())

            .arg(this->height())

            .arg(d->mColor.rgb());

}

QPixmap ProgressCircle::generatePixmap() const

{

    QPixmap pixmap(squared(rect()).size().toSize());

    pixmap.fill(QColor(0,0,0,0));

    QPainter painter(&pixmap);

    painter.setRenderHint(QPainter::Antialiasing, true);

    QRectF rect = pixmap.rect().adjusted(1,1,-1,-1);

    qreal margin = rect.width()*(1.0 - d->mOuterRadius)/2.0;

    rect.adjust(margin,margin,-margin,-margin);

    qreal innerRadius = d->mInnerRadius*rect.width()/2.0;

    //background grey circle

    painter.setBrush(QColor(225,225,225));

    painter.setPen(QColor(225,225,225));

    painter.drawPie(rect, 0, 360*16);

    painter.setBrush(d->mColor);

    painter.setPen(d->mColor);

    if(d->mIsInfinite == true)

    {

        //draw as infinite process

        int startAngle = (-d->mInfiniteAnimationValue) * 360 * 16;

        int spanAngle = 0.15 * 360 * 16;

        painter.drawPie(rect, startAngle, spanAngle);

    }

    else

    {

        int value = qMin(d->mVisibleValue, d->mMaximum);

        int startAngle = 90 * 16;

        int spanAngle = -qreal(value) * 360 * 16 / d->mMaximum;

        painter.drawPie(rect, startAngle, spanAngle);

    }

    //inner circle and frame

    painter.setBrush(QColor(255,255,255));

    painter.setPen(QColor(0,0,0, 60));

    painter.drawEllipse(rect.center(), innerRadius, innerRadius);

    //outer frame

    painter.drawArc(rect, 0, 360*16);

    return pixmap;

}

qreal ProgressCircle::infiniteAnimationValue() const

{

    return d->mInfiniteAnimationValue;

}

int ProgressCircle::visibleValue() const

{

    return d->mVisibleValue;

}

해당코드는  Git 허브에서 원본소스를 가져왔으며

제가 수정하였습니다.

문제시 삭제하겠습니다.

코드 수정 배포시 

원제작자, 수정자 남겨주시기바랍니다.

사용법은 위젯위에  Promote하시던가 그냥 만들어서 setvalue같은거 써보시면 됍니다 :)

Sample.zip

압축파일 다운로드(DownLoad) 프로젝트(Project) 참조

Qt의 차트의 경우

축에 있는 Range에 따라 차트를 그리는게아니라

데이터전체의 min max값을 파악하여 그래프를 먼저그린후 해당 데이터에 맞춰 축데이터를 수정한다 ㄱ-

d->mChart->removeAllSeries();
d->mChart->addSeries(series);
d->mChart->createDefaultAxes(); // always need this function after addSeries

따라서 createDefaultAxes 함수를 addSeries 이후에 반드시 호출해줘야 오류가 없다.

다음 도큐먼트 참고

//Referance : QtDocument 5.11.1

   Creates axes for the chart based on the series that have already been added to the chart. Any axes previously added to the chart will be deleted.

Note: This function has to be called after all series have been added to the chart. The axes created by this function will NOT get automatically attached to any series added to the chart after this function has been called. A series with no axes attached will by default scale to utilize the entire plot area of the chart, which can be confusing if there are other series with properly attached axes also present.

If there are several QXYSeries derived series added to the chart and no series of other types have been added, then only one pair of axes is created. If there are several series of different types added to the chart, then each series gets its own axes pair.

The axes specific to the series can be later obtained from the chart by providing the series as the parameter for the axes() function call. QPieSeries does not create any axes.

See also axisX(), axisY(), axes(), setAxisX(), setAxisY(), and QAbstractSeries::attachAxis().