hyperviseurgraphique.cpp

Aller à la documentation de ce fichier.

#include "hyperviseurgraphique.h"



HyperviseurGraphique::HyperviseurGraphique(QVariantMap donnees, QList<QVariantMap> donneesVMs)
{
    this->changerDonnees(donnees, donneesVMs);
}



QString HyperviseurGraphique::name(){
    return this->donnees.value("name",QVariant("")).toString();
}



float HyperviseurGraphique::etatDeSante(){
    return this->etatSante;
}



QTime HyperviseurGraphique::derniereReception(){
    return this->derniereReception_d;
}



void HyperviseurGraphique::changerDonnees(QVariantMap donnees, QList<QVariantMap> donneesVMs){
    //qDebug() << "Mise à jour.";
    this->donnees = donnees;
    this->donneesVMs = donneesVMs;
    this->derniereReception_d = QTime::currentTime();

    float cpu  = this->donnees.value("cpu",  QVariant(0)).toFloat();
    cpu = cpu*cpu*cpu/10000;
    float ram  = this->donnees.value("ram",  QVariant(0)).toFloat();
    ram = 1.5*ram*ram/100-50;
    float disk = this->donnees.value("disk", QVariant(0)).toFloat();
    disk = disk*disk/100;

    float cputemp = this->donnees.value("cputemp", QVariant(0)).toFloat();
    if(cputemp < 40) cputemp = cputemp * 0.875;
    else if(cputemp < 60) cputemp = cputemp * 1.25 - 15;
    else cputemp = cputemp * 1.3333 - 20;

    float mbtemp  = this->donnees.value("mbtemp",  QVariant(0)).toFloat();
    if(mbtemp < 33) mbtemp = mbtemp * 1.0606;
    else if(mbtemp < 45) mbtemp = mbtemp * 2.0833 - 33.75;
    else mbtemp = mbtemp * 1.6 - 12;

    float indice = qMax(cpu, qMax(ram, qMax(disk, qMax(cputemp, mbtemp))));

    QVariantMap vminfos;
    QListIterator<QVariantMap> li(this->donneesVMs);
    float plusGrandeCPU = 0;
    float plusGrandeRAM = 0;
    while(li.hasNext()){
        vminfos = li.next();
        plusGrandeCPU = qMax(plusGrandeCPU, vminfos.value("cpu").toFloat());
        if(vminfos.value("maxram", QVariant(0)).toFloat() > 0) plusGrandeRAM = qMax(plusGrandeRAM, vminfos.value("ram").toFloat() / vminfos.value("maxram").toFloat());
    }

    indice = qMax(indice, qMax(plusGrandeCPU, plusGrandeRAM));
    this->etatSante = (indice > 100)? 100 : indice;

    /*QGraphicsScene *scene = 0;
    if( (scene = this->scene()) != 0) scene->update();*/
    this->update(QRectF(0, 0, 380, 262));
}



QBrush HyperviseurGraphique::calcBarreBrush(float pourcent){
    if(pourcent > 100.0) pourcent = 100.0;
    QLinearGradient gradient;
    gradient.setCoordinateMode(QGradient::ObjectBoundingMode);
    gradient.setColorAt(0, QColor::fromHsvF(0.3334-pourcent*0.0033334, 0.8, 0.75));
    gradient.setColorAt(1, QColor::fromHsvF(0.3334-pourcent*0.0033334, 0.8, 0.35));
    gradient.setStart(0,0);
    gradient.setStart(1,0);
    return QBrush(gradient);
}



QBrush HyperviseurGraphique::calcCercleBrush(float pourcent, int rayon, QPoint centre, bool desactive){
    if(pourcent > 100.0) pourcent = 100.0;
    QRadialGradient gradient;
    gradient.setCoordinateMode(QGradient::ObjectBoundingMode);
    if(!desactive){
        gradient.setColorAt(0, QColor::fromHsvF(0.3334-pourcent*0.0033334, 0.8, 0.75));
        gradient.setColorAt(1, QColor::fromHsvF(0.3334-pourcent*0.0033334, 0.8, 0.35));
    }else{
        gradient.setColorAt(0, QColor::fromHsvF(0, 0, 0.55));
        gradient.setColorAt(1, QColor::fromHsvF(0, 0, 0.35));
    }
    gradient.setCoordinateMode(QGradient::LogicalMode);
    gradient.setRadius((qreal)rayon);
    gradient.setCenter(QPointF(centre));
    gradient.setFocalPoint(QPointF(centre));
    return QBrush(gradient);
}



QRectF HyperviseurGraphique::boundingRect() const{
    return QRectF(0, 0, this->largeurTotale+1, this->hauteurTotale+1);
}



void HyperviseurGraphique::dessinerLegendeVerticale(QPainter *painter, unsigned int hauteurTotale, unsigned int largeurVMsBloc, unsigned int largeurBarres){
    painter->save();

    QFont font3("Verdana");
    font3.setWeight(QFont::DemiBold);
    painter->setFont(font3);

    painter->rotate(270);

    painter->translate(-int(hauteurTotale)+7, largeurBarres/2+6);
    painter->drawText(0, 0, "CPU");

    painter->translate(0, largeurBarres+1);
    painter->drawText(0, 0, "MB");

    painter->translate(0, largeurVMsBloc+largeurBarres+4);
    painter->drawText(0, 0, "CPU");

    painter->translate(0, largeurBarres+1);
    painter->drawText(0, 0, "RAM");

    painter->translate(0, largeurBarres+1);
    painter->drawText(0, 0, "HDD");

    painter->restore();
}



void HyperviseurGraphique::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget){
    QPen   pen   = painter->pen();
    QBrush brush = painter->brush();
    QLinearGradient gradient;

    gradient.setCoordinateMode(QGradient::ObjectBoundingMode);
    gradient.setColorAt(0, QColor::fromHsvF(0.3334-this->etatSante*0.0033334, 0.8, 0.75));
    gradient.setColorAt(1, QColor::fromHsvF(0.3334-this->etatSante*0.0033334, 0.8, 0.35));
    gradient.setStart(0,0);
    gradient.setStart(1,0);
    QBrush gradientBrush(gradient);

    pen.setStyle(Qt::SolidLine);
    pen.setColor(QColor(0, 0, 0, 255));
    pen.setBrush(QBrush(QColor(0, 0, 0, 255)));
    pen.setWidth(0);

    // les valeurs ci-dessous sont sans bordure
    unsigned int largeurBarres  = 16;
    unsigned int hauteurTitre   = 33;
    this->hauteurTotale         = 262; //avec les bordures
    unsigned int largeurVMsBloc = 288;
    unsigned int largeurBlocGauche = (largeurBarres+1)*2+1;
    unsigned int largeurBlocDroit  = (largeurBarres+1)*3+1;
    unsigned int hauteurContenu    = this->hauteurTotale-hauteurTitre-2;
    this->largeurTotale            = largeurBlocGauche+largeurVMsBloc+largeurBlocDroit+4; // avec les bordures
    unsigned int posBlocGauche     = largeurBlocGauche+largeurVMsBloc+2;

#ifdef Q_WS_WIN
    this->dessinerLegendeVerticale(painter, this->hauteurTotale, largeurVMsBloc, largeurBarres);
#endif
    painter->setPen(pen);
    painter->setBrush(Qt::NoBrush);
    //               | X (horizontal) |  Y (vertical)  |       Largeur       |     Hauteur     |
    painter->drawRect(               0,               0,      this->largeurTotale-1,  this->hauteurTotale-1); // Block total
    painter->drawRect(               0,  hauteurTitre+1,   largeurBlocGauche+1,   hauteurContenu); // Block droite
    painter->drawRect(   posBlocGauche,  hauteurTitre+1,  largeurBlocDroit+1,   hauteurContenu); // Block gauche
    painter->setBrush(gradientBrush);
    painter->drawRect(               0,               0,      this->largeurTotale-1,   hauteurTitre+1); // Titre

    pen.setStyle(Qt::NoPen);
    painter->setPen(pen);

    unsigned int hauteur;
    float pourcent;

    // CPU Temp. Barre
    pourcent = this->donnees.value("cputemp", QVariant(0)).toFloat()*120.0/80.0-20; //50;
    if(pourcent < 0) pourcent = 0;
    if(pourcent > 100) pourcent = 100.0;
    hauteur = (hauteurContenu-3)*pourcent/100;
    painter->setBrush(this->calcBarreBrush(pourcent+5));
    painter->drawRect(2, this->hauteurTotale-2-hauteur, largeurBarres, hauteur);

    // MB Temp. Barre
    pourcent = this->donnees.value("mbtemp", QVariant(0)).toFloat()*110.0/80.0-10; //20;
    if(pourcent < 0) pourcent = 0;
    if(pourcent > 100) pourcent = 100.0;
    hauteur = (hauteurContenu-3)*pourcent/100;
    painter->setBrush(this->calcBarreBrush(pourcent+20));
    painter->drawRect(largeurBarres+3,  this->hauteurTotale-2-hauteur, largeurBarres, hauteur);

    // CPU Barre
    pourcent = this->donnees.value("cpu", QVariant(0)).toFloat(); //94;
    hauteur = (hauteurContenu-3)*pourcent/100;
    painter->setBrush(this->calcBarreBrush(pourcent));
    painter->drawRect(largeurBlocGauche+largeurVMsBloc+4,  this->hauteurTotale-2-hauteur, largeurBarres, hauteur);

    // RAM Barre
    pourcent = this->donnees.value("ram", QVariant(0)).toFloat(); //41;
    hauteur = (hauteurContenu-3)*pourcent/100;
    painter->setBrush(this->calcBarreBrush(pourcent));
    painter->drawRect(largeurBlocGauche+largeurVMsBloc+4+largeurBarres+1,  this->hauteurTotale-2-hauteur, largeurBarres, hauteur);

    // HDD Barre
    pourcent = this->donnees.value("disk", QVariant(0)).toFloat(); //73;
    hauteur = (hauteurContenu-3)*pourcent/100;
    painter->setBrush(this->calcBarreBrush(pourcent));
    painter->drawRect(largeurBlocGauche+largeurVMsBloc+4+2*(largeurBarres+1),  this->hauteurTotale-2-hauteur, largeurBarres, hauteur);


    pen.setStyle(Qt::SolidLine);
    pen.setColor(Qt::white);
    painter->setPen(pen);
    QFont font1("Verdana", 12, QFont::Bold);
    painter->setFont(font1);

    // Nom machine
    painter->drawText(QRect(0, 0, this->largeurTotale-1, hauteurTitre+1), Qt::AlignCenter , this->donnees.value("name", QVariant("Sans Nom")).toString());

    QFont font2("Verdana", 7, QFont::DemiBold);
    painter->setFont(font2);

    painter->drawText(QRect(3, hauteurTitre/2, this->largeurTotale/3, hauteurTitre/2), Qt::AlignLeft|Qt::AlignBottom, "Températures");
    painter->drawText(QRect(this->largeurTotale*2/3, hauteurTitre/2, this->largeurTotale/3-3, hauteurTitre/2), Qt::AlignRight|Qt::AlignBottom, "Utilisation");
#ifdef Q_WS_WIN
    painter->save();
    painter->setCompositionMode((QPainter::CompositionMode)15);
#else
    pen.setColor(Qt::black);
    painter->setPen(pen);
#endif
    this->dessinerLegendeVerticale(painter, this->hauteurTotale, largeurVMsBloc, largeurBarres);
#ifdef Q_WS_WIN
    painter->restore();
#endif


    if(!this->donneesVMs.isEmpty()){
        int i;
        int rayon;
        float surface;
        int marges = 4;
        int espace = 15;
        int L = largeurVMsBloc-(marges*2);
        int H = hauteurContenu-(marges*2);
        qreal temp1 = sqrt((double)this->donneesVMs.size() * (double)H/ (double)L);
        qreal temp2 = (temp1 * (qreal)L / (qreal)H);
        int nby = qRound(temp1);
        int nbx = qRound(temp2);
        qreal nbyDec = (temp1-(qreal)nby);
        qreal nbxDec = (temp2-(qreal)nbx);
        if( (nbyDec > 0 && nbxDec > 0) || (nbyDec+nbxDec) > 0 ){
            if(nbyDec > nbxDec){
                nby++;
            }else{
                nbx++;
            }
        }
        int dx =  L / nbx;
        int dy =  H / nby;
        int maxRayon = qMin(dx, dy) / 2;

        /*if(nby < 1) nby = 1;
        if(nbx > this->donneesVMs.size()) nbx = this->donneesVMs.size();
        if(nby > (this->donneesVMs.size()/nbx)) nby = this->donneesVMs.size()/nbx;*/
        int centrageX = (L - (maxRayon*2)*nbx) /2;
        int centrageY = (H - (maxRayon*2)*nby) /2;
        QPoint centre;
        pen.setColor(Qt::black);
        painter->setPen(pen);
        painter->setRenderHint(QPainter::Antialiasing);

        QVariantMap vminfos;
        QListIterator<QVariantMap> li(this->donneesVMs);
        int plusGrandeRam = 0;
        while(li.hasNext()){
            vminfos = li.next();
            if(vminfos.value("maxram").toInt() > plusGrandeRam) plusGrandeRam = vminfos.value("maxram").toInt();
        }
        li.toFront();
        i = 0;
        while(li.hasNext()){
            vminfos = li.next();
            if(plusGrandeRam > 0){
                surface = 3.1416 * maxRayon * maxRayon;
                rayon = qSqrt( (surface*(vminfos.value("maxram").toInt()+500000) / (plusGrandeRam+500000)) / 3.1416 );
                //rayon =  (maxRayon * vminfos.value("maxram").toInt()) / plusGrandeRam;
            }else{
                rayon = maxRayon;
            }
            pourcent = 0.7;//vminfos.value("ram").toFloat() / vminfos.value("maxram").toFloat();
            centre = QPoint( largeurBlocGauche+marges+(maxRayon*2)*(i%nbx)+maxRayon+centrageX, hauteurTitre+marges+(maxRayon*2)*qFloor(i/nbx)+maxRayon+centrageY );
            painter->setBrush(Qt::NoBrush);
            painter->drawEllipse(centre, rayon-espace/2, rayon-espace/2);
            painter->setBrush(this->calcCercleBrush(vminfos.value("cpu",QVariant(0)).toFloat(), (rayon-espace/2)*pourcent, centre, (vminfos.value("state").toInt() != 1) ));
            painter->drawEllipse(centre, (int)((rayon-espace/2)*pourcent), (int)((rayon-espace/2)*pourcent) );
            i++;
            //qDebug() << "Nom:" << vminfos.value("name").toString() << " NbVM:" << this->donneesVMs.size() << " maxRayon:" << maxRayon << " plusGrandeRam:" << plusGrandeRam << " rayon:" << rayon << " ram:" << vminfos.value("ram").toString()+"/"+vminfos.value("maxram").toString() << " pourcent:" << pourcent << " centre:" << centre;
        }
    }

}