Projet Bee-Honey't  1.0
BTS SN 2019
Connecteurs publics | Signaux | Fonctions membres publiques | Connecteurs privés | Fonctions membres privées | Attributs privés | Liste de tous les membres
Référence de la classe RucheIhm

La classe IHM. Plus de détails...

#include <rucheIhm.h>

Graphe de collaboration de RucheIhm:
Collaboration graph

Connecteurs publics

void recevoirEtatClientConnexion (bool etat)
 
void afficherTemperatureInterieur (double temperatureInterieur, QString horodatage)
 affiche temperature interieur à l'aide de widget graphique Plus de détails...
 
void afficherTemperatureExterieur (double temperatureExterieur, QString horodatage)
 affiche temperature exterieur à l'aide de widget graphique Plus de détails...
 
void afficherHumiditeInterieur (double humiditeInterieur, QString horodatage)
 affiche humidite interieur à l'aide de widget graphique Plus de détails...
 
void afficherHumiditeExterieur (double humiditeExterieur, QString horodatage)
 affiche humidite exterieur à l'aide de widget graphique Plus de détails...
 
void afficherPressionAtmospherique (double pressionAtmospherique, QString horodatage)
 affiche pression atmospherique à l'aide de widget graphique Plus de détails...
 
void afficherEnsoleillement (double ensoleillement, QString horodatage)
 affiche l'ensoleillement à l'aide de widget graphique Plus de détails...
 
void afficherBatterie (double charge, QString horodatage)
 
void afficherPoids (double poids, QString horodatage)
 
void afficherAlertesTemperatureInterieur (SeuilsAlertes typeAlerte)
 
void afficherAlertesTemperatureExterieur (SeuilsAlertes typeAlerte)
 
void afficherAlertesHumiditeInterieur (SeuilsAlertes typeAlerte)
 
void afficherAlertesHumiditeExterieur (SeuilsAlertes typeAlerte)
 
void afficherAlertesPressionAtmospherique (SeuilsAlertes typeAlerte)
 
void afficherAlertesPoids (SeuilsAlertes typeAlerte)
 
void afficherAlertesEnsoleillement (SeuilsAlertes typeAlerte, double mesure)
 
void afficherAlertesBatterie (SeuilsAlertes typeAlerte, double mesure)
 
void afficherMesuresJournalieresRuche ()
 
void afficherMesuresJournalieresEnvironement ()
 
void afficherMesuresJournalieresEnsoleillement ()
 
void quitter ()
 

Signaux

void nouvelleDonnesRuche (QString nom, QString prenom, QString email, QString nomTopic)
 

Fonctions membres publiques

 RucheIhm (QWidget *parent=0)
 Constructeur de la fenêtre principale. Plus de détails...
 
 ~RucheIhm ()
 Destructeur de la fenêtre principale. Plus de détails...
 

Connecteurs privés

void selectionnerRuche (int numeroRuche)
 instancie l'objet principal Ruche sélectionnée Plus de détails...
 
void creerNouvelleRuche ()
 creer une nouvelle ruche Plus de détails...
 
void ouvrirReglagesAlertes ()
 
void mettreAjourListeRuches ()
 
void supprimerRuche ()
 

Fonctions membres privées

void initialiserThermometre () const
 initialise les thermometres Plus de détails...
 
void initialiserWidgets ()
 
void inititialiserCourbes ()
 
void reinititialiserCourbes ()
 
void initialiserTemperatureInterieurCourbe ()
 
void initialiserTemperatureExterieurCourbe ()
 
void initialiserHumiditeInterieurCourbe ()
 
void initialiserHumiditeExterieurCourbe ()
 
void initialiserPressionAtmospheriqueCourbe ()
 
void initialiserEnsoleillementCourbe ()
 

Attributs privés

Ui::RucheIhm * ui
 agrégation de la partie graphique de l'IHM Plus de détails...
 
RuchemaRuche
 association de l'objet Ruche Plus de détails...
 
BaseDeDonneesbdd
 agrégation de l'objet BaseDeDonnees Plus de détails...
 
NouvelleRucheIhmnouvelleRuche
 
ReglagesAlertesIhmreglagesAlertesIhm
 
QVector< QStringList > mesRuches
 
QwtPlotCurve * courbeTemperatureInterieur
 
QwtPlotCurve * courbeTemperatureExterieur
 
QwtPlotCurve * courbeHumiditeInterieur
 
QwtPlotCurve * courbeHumiditeExterieur
 
QwtPlotCurve * courbePressionAtmospherique
 
QwtPlotCurve * courbeEnsoleillement
 

Description détaillée

Auteur
Florentin Mellah, Enzo Rossi
Version
0.1

Documentation des constructeurs et destructeur

◆ RucheIhm()

RucheIhm::RucheIhm ( QWidget parent = 0)
explicit
Paramètres
parentQObject Adresse de l'objet Qt parent (0 = fenêtre principale)

Références bdd, BDD_NOMBASE, BDD_PASSWORD, BDD_SERVEUR, BDD_USERNAME, BaseDeDonnees::connecter(), creerNouvelleRuche(), BaseDeDonnees::estConnecte(), BaseDeDonnees::getInstance(), initialiserWidgets(), inititialiserCourbes(), mettreAjourListeRuches(), nouvelleRuche, ouvrirReglagesAlertes(), quitter(), reglagesAlertesIhm, selectionnerRuche(), supprimerRuche(), et ui.

40  : QWidget(parent), ui(new Ui::RucheIhm), maRuche(0), bdd(0), nouvelleRuche(0), reglagesAlertesIhm(0)
41 {
42  qDebug()<< Q_FUNC_INFO;
43  // Initialisation de l'IHM
44  ui->setupUi(this);
45 
46  // Initialisation des widgets
49 
50  // Affichage plein écran
51  const int width = qApp->desktop()->availableGeometry(this).width(); // ou : qApp->desktop()->width()
52  const int height = qApp->desktop()->availableGeometry(this).height(); // ou : qApp->desktop()->height()
53  resize(width, height);
54 
55  // Ajout de l'action Quitter
56  QAction *actionQuitter = new QAction("&Quitter", this);
57  actionQuitter->setShortcut(QKeySequence(QKeySequence::Quit)); // Ctrl+Q
58  addAction(actionQuitter);
59 
60  // Connexion signaux/slots
61  connect(actionQuitter, SIGNAL(triggered()), this, SLOT(quitter()));
62  connect(ui->comboBoxChoixRuche, SIGNAL(currentIndexChanged(int)), this, SLOT(selectionnerRuche(int)));
63  connect(ui->pushButtonNouvelleRuche, SIGNAL(clicked()), this, SLOT(creerNouvelleRuche()));
64  connect(ui->pushButtonReglages, SIGNAL(clicked()), this, SLOT(ouvrirReglagesAlertes()));
65  connect(ui->pushButtonSuppressionRuche, SIGNAL(clicked()), this, SLOT(supprimerRuche()));
66 
68  if(!bdd->estConnecte())
70 
71  nouvelleRuche = new NouvelleRucheIhm(this);
73 
75  //ui->comboBoxChoixRuche->setCurrentIndex(1);
76 }
static BaseDeDonnees * getInstance(QString type="QMYSQL")
Definition: baseDeDonnees.cpp:38
#define BDD_USERNAME
Definition: parametres.h:21
void creerNouvelleRuche()
creer une nouvelle ruche
Definition: rucheIhm.cpp:196
void initialiserWidgets()
Definition: rucheIhm.cpp:583
#define BDD_SERVEUR
Definition: parametres.h:20
bool estConnecte()
Definition: baseDeDonnees.cpp:70
void supprimerRuche()
Definition: rucheIhm.cpp:629
void mettreAjourListeRuches()
Definition: rucheIhm.cpp:558
Definition: nouvelleRucheIhm.h:24
ReglagesAlertesIhm * reglagesAlertesIhm
Definition: rucheIhm.h:55
void selectionnerRuche(int numeroRuche)
instancie l&#39;objet principal Ruche sélectionnée
Definition: rucheIhm.cpp:138
#define BDD_PASSWORD
Definition: parametres.h:22
void ouvrirReglagesAlertes()
Definition: rucheIhm.cpp:206
Ui::RucheIhm * ui
agrégation de la partie graphique de l&#39;IHM
Definition: rucheIhm.h:51
#define BDD_NOMBASE
Definition: parametres.h:23
void quitter()
Definition: rucheIhm.cpp:97
NouvelleRucheIhm * nouvelleRuche
Definition: rucheIhm.h:54
Ruche * maRuche
association de l&#39;objet Ruche
Definition: rucheIhm.h:52
Definition: reglagesAlertesIhm.h:14
bool connecter(QString nomBase=BDD_NOMBASE, QString username=BDD_USERNAME, QString password=BDD_PASSWORD, QString serveur=BDD_SERVEUR)
Definition: baseDeDonnees.cpp:76
void inititialiserCourbes()
Definition: rucheIhm.cpp:650
BaseDeDonnees * bdd
agrégation de l&#39;objet BaseDeDonnees
Definition: rucheIhm.h:53

◆ ~RucheIhm()

RucheIhm::~RucheIhm ( )

Références BaseDeDonnees::detruireInstance(), et ui.

85 {
86  delete ui;
88  qDebug()<< Q_FUNC_INFO;
89 }
static void detruireInstance()
Definition: baseDeDonnees.cpp:51
Ui::RucheIhm * ui
agrégation de la partie graphique de l&#39;IHM
Definition: rucheIhm.h:51

Documentation des fonctions membres

◆ afficherAlertesBatterie

void RucheIhm::afficherAlertesBatterie ( SeuilsAlertes  typeAlerte,
double  mesure 
)
slot

Références bon, tropBas, et ui.

Référencé par selectionnerRuche().

526 {
527  qDebug() << Q_FUNC_INFO << "SeuilsAlertes " << typeAlerte << "mesure " << mesure;
528 
529  if(typeAlerte == tropBas && mesure < 0)
530  {
531  ui->labelAlerteBatterie->setText("<strong>Batterie faible</strong>");
532  QPixmap imageBatterie(":/images/images/batteryChargeMin.png");
533  ui->labelAlerteImageBatterie->setPixmap(imageBatterie);
534  }
535  else if(typeAlerte == bon)
536  {
537  if(mesure >= 75 && mesure <= 100)
538  {
539  ui->labelAlerteBatterie->setText("<strong>Batterie</strong>");
540  QPixmap imageBatterie(":/images/images/batteryChargeMax.png");
541  ui->labelAlerteImageBatterie->setPixmap(imageBatterie);
542  }
543  if(mesure >= 50 && mesure < 75)
544  {
545  ui->labelAlerteBatterie->setText("<strong>Batterie</strong>");
546  QPixmap imageBatterie(":/images/images/batteryChargeBonne.png");
547  ui->labelAlerteImageBatterie->setPixmap(imageBatterie);
548  }
549  if(mesure >= 25 && mesure < 50)
550  {
551  ui->labelAlerteBatterie->setText("<strong>Batterie</strong>");
552  QPixmap imageBatterie(":/images/images/batteryChargeMoitie.png");
553  ui->labelAlerteImageBatterie->setPixmap(imageBatterie);
554  }
555  }
556 }
Definition: parametres.h:59
Ui::RucheIhm * ui
agrégation de la partie graphique de l&#39;IHM
Definition: rucheIhm.h:51
Definition: parametres.h:58

◆ afficherAlertesEnsoleillement

void RucheIhm::afficherAlertesEnsoleillement ( SeuilsAlertes  typeAlerte,
double  mesure 
)
slot

Références bon, tropBas, tropHaut, et ui.

Référencé par selectionnerRuche().

494 {
495  qDebug() << Q_FUNC_INFO << "SeuilsAlertes " << typeAlerte << "mesure " << mesure;
496  if(typeAlerte == tropHaut)
497  {
498  ui->labelAlerteEnsoleillement->setText("<strong>Ensoleillement Elevé</strong>");
499  QPixmap imageEnsoleillement(":/images/images/alerteEnsoleillement.png");
500  ui->labelAlerteImageEnsoleillement->setPixmap(imageEnsoleillement);
501  }
502  else if(typeAlerte == tropBas && mesure < 400)
503  {
504  ui->labelAlerteEnsoleillement->setText("<strong>Nuageux</strong>");
505  QPixmap imageEnsoleillement(":/images/images/nuageux.png");
506  ui->labelAlerteImageEnsoleillement->setPixmap(imageEnsoleillement);
507  }
508  else if(typeAlerte == bon)
509  {
510  if(mesure >=800 && mesure <= 1200)
511  {
512  ui->labelAlerteEnsoleillement->setText("<strong>Ensoleillement Normal</strong>");
513  QPixmap imageEnsoleillement(":/images/images/soleil.png");
514  ui->labelAlerteImageEnsoleillement->setPixmap(imageEnsoleillement);
515  }
516  if(mesure >= 400 && mesure < 800)
517  {
518  ui->labelAlerteEnsoleillement->setText("<strong>Couvert</strong>");
519  QPixmap imageEnsoleillement(":/images/images/soleilCouvert.png");
520  ui->labelAlerteImageEnsoleillement->setPixmap(imageEnsoleillement);
521  }
522  }
523 }
Definition: parametres.h:59
Ui::RucheIhm * ui
agrégation de la partie graphique de l&#39;IHM
Definition: rucheIhm.h:51
Definition: parametres.h:57
Definition: parametres.h:58

◆ afficherAlertesHumiditeExterieur

void RucheIhm::afficherAlertesHumiditeExterieur ( SeuilsAlertes  typeAlerte)
slot

Références bon, tropBas, tropHaut, et ui.

Référencé par selectionnerRuche().

422 {
423  {
424  qDebug() << Q_FUNC_INFO << "SeuilsAlertes " << typeAlerte;
425 
426  if(typeAlerte == tropHaut)
427  {
428  ui->labelAlerteHumiditeExterieur->setText("<strong>Humidité Ext. Elevée</strong>");
429  QPixmap imageHumiditeExterieur(":/images/images/humidityHaute.png");
430  ui->labelAlerteImageHumiditeExterieur->setPixmap(imageHumiditeExterieur);
431  }
432  else if(typeAlerte == tropBas)
433  {
434  ui->labelAlerteHumiditeExterieur->setText("<strong>Humidité Ext. Basse</strong>");
435  QPixmap imageHumiditeExterieur(":/images/images/humidityHaute.png");
436  ui->labelAlerteImageHumiditeExterieur->setPixmap(imageHumiditeExterieur);
437  }
438  else if(typeAlerte == bon)
439  {
440  ui->labelAlerteHumiditeExterieur->setText("<strong>Humidité Ext. Normale</strong>");
441  QPixmap imageHumiditeExterieur(":/images/images/humiditeNormal.png");
442  ui->labelAlerteImageHumiditeExterieur->setPixmap(imageHumiditeExterieur);
443  }
444  }
445 }
Definition: parametres.h:59
Ui::RucheIhm * ui
agrégation de la partie graphique de l&#39;IHM
Definition: rucheIhm.h:51
Definition: parametres.h:57
Definition: parametres.h:58

◆ afficherAlertesHumiditeInterieur

void RucheIhm::afficherAlertesHumiditeInterieur ( SeuilsAlertes  typeAlerte)
slot

Références bon, tropBas, tropHaut, et ui.

Référencé par selectionnerRuche().

398 {
399  qDebug() << Q_FUNC_INFO << "SeuilsAlertes " << typeAlerte;
400 
401  if(typeAlerte == tropHaut)
402  {
403  ui->labelAlerteHumiditeInterieur->setText("<strong>Humidité Int. Elevée</strong>");
404  QPixmap imageHumiditeInterieur(":/images/images/humidityHaute.png");
405  ui->labelAlerteImageHumiditeInterieur->setPixmap(imageHumiditeInterieur);
406  }
407  else if(typeAlerte == tropBas)
408  {
409  ui->labelAlerteHumiditeInterieur->setText("<strong>Humidité Int. Basse</strong>");
410  QPixmap imageHumiditeInterieur(":/images/images/humidityHaute.png");
411  ui->labelAlerteImageHumiditeInterieur->setPixmap(imageHumiditeInterieur);
412  }
413  else if(typeAlerte == bon)
414  {
415  ui->labelAlerteHumiditeInterieur->setText("<strong>Humidité Int. Normale</strong>");
416  QPixmap imageHumiditeInterieur(":/images/images/humiditeNormal.png");
417  ui->labelAlerteImageHumiditeInterieur->setPixmap(imageHumiditeInterieur);
418  }
419 }
Definition: parametres.h:59
Ui::RucheIhm * ui
agrégation de la partie graphique de l&#39;IHM
Definition: rucheIhm.h:51
Definition: parametres.h:57
Definition: parametres.h:58

◆ afficherAlertesPoids

void RucheIhm::afficherAlertesPoids ( SeuilsAlertes  typeAlerte)
slot

Références bon, tropBas, tropHaut, et ui.

Référencé par selectionnerRuche().

472 {
473  qDebug() << Q_FUNC_INFO << "SeuilsAlertes " << typeAlerte;
474  if(typeAlerte == tropHaut)
475  {
476  ui->labelAlertePoids->setText("<strong>Poids Elevé</strong>");
477  QPixmap imagePoids(":/images/images/poidsAlerte.png");
478  ui->labelAlerteImagePoids->setPixmap(imagePoids);
479  }
480  else if(typeAlerte == tropBas)
481  {
482  ui->labelAlertePoids->setText("<strong>Poids Bas</strong>");
483  QPixmap imagePoids(":/images/images/poidsAlerte.png");
484  ui->labelAlerteImagePoids->setPixmap(imagePoids);
485  }
486  else if(typeAlerte == bon)
487  {
488  ui->labelAlertePoids->setText("<strong>Poids Normal</strong>");
489  QPixmap imagePoids(":/images/images/poidsnormal.png");
490  ui->labelAlerteImagePoids->setPixmap(imagePoids);
491  }
492 }
Definition: parametres.h:59
Ui::RucheIhm * ui
agrégation de la partie graphique de l&#39;IHM
Definition: rucheIhm.h:51
Definition: parametres.h:57
Definition: parametres.h:58

◆ afficherAlertesPressionAtmospherique

void RucheIhm::afficherAlertesPressionAtmospherique ( SeuilsAlertes  typeAlerte)
slot

Références bon, tropBas, tropHaut, et ui.

Référencé par selectionnerRuche().

448 {
449  qDebug() << Q_FUNC_INFO << "SeuilsAlertes " << typeAlerte;
450 
451  if(typeAlerte == tropHaut)
452  {
453  ui->labelAlertePressionAtmospherique->setText("<strong>Pression Atmospherique Elevée</strong>");
454  QPixmap imagePressionAtmospherique(":/images/images/pressionAlerte.png");
455  ui->labelAlerteImagePressionAtmospherique->setPixmap(imagePressionAtmospherique);
456  }
457  else if(typeAlerte == tropBas)
458  {
459  ui->labelAlertePressionAtmospherique->setText("<strong>Pression Atmospherique Basse</strong>");
460  QPixmap imagePressionAtmospherique(":/images/images/pressionAlerte.png");
461  ui->labelAlerteImagePressionAtmospherique->setPixmap(imagePressionAtmospherique);
462  }
463  else if(typeAlerte == bon)
464  {
465  ui->labelAlertePressionAtmospherique->setText("<strong>Pression Atmospherique Normale</strong>");
466  QPixmap imagePressionAtmospherique(":/images/images/pressionNormal.png");
467  ui->labelAlerteImagePressionAtmospherique->setPixmap(imagePressionAtmospherique);
468  }
469 }
Definition: parametres.h:59
Ui::RucheIhm * ui
agrégation de la partie graphique de l&#39;IHM
Definition: rucheIhm.h:51
Definition: parametres.h:57
Definition: parametres.h:58

◆ afficherAlertesTemperatureExterieur

void RucheIhm::afficherAlertesTemperatureExterieur ( SeuilsAlertes  typeAlerte)
slot

Références bon, tropBas, tropHaut, et ui.

Référencé par selectionnerRuche().

366 {
367  qDebug() << Q_FUNC_INFO << "SeuilsAlertes " << typeAlerte;
368 
369  QPalette paletteCouleur = ui->thermoTemperatureExterieur->palette();
370 
371  if(typeAlerte == tropHaut)
372  {
373  paletteCouleur.setColor(QPalette::ButtonText, QColor(255,0,0));
374  ui->thermoTemperatureExterieur->setPalette(paletteCouleur);
375  ui->labelAlerteTemperatureExterieur->setText("<strong>Température Ext. Elevée</strong>");
376  QPixmap imageTemperatureExterieur(":/images/images/temperatureHaute.png");
377  ui->labelImageTemperatureExterieur->setPixmap(imageTemperatureExterieur);
378  }
379  else if(typeAlerte == tropBas)
380  {
381  paletteCouleur.setColor(QPalette::ButtonText, QColor(135,206,250));
382  ui->thermoTemperatureExterieur->setPalette(paletteCouleur);
383  ui->labelAlerteTemperatureExterieur->setText("<strong>Température Ext. Basse</strong>");
384  QPixmap imageTemperatureExterieur(":/images/images/temperatureBasseAlerte.png");
385  ui->labelImageTemperatureExterieur->setPixmap(imageTemperatureExterieur);
386  }
387  else if(typeAlerte == bon)
388  {
389  paletteCouleur.setColor(QPalette::ButtonText, QColor(0,128,0));
390  ui->thermoTemperatureExterieur->setPalette(paletteCouleur);
391  ui->labelAlerteTemperatureExterieur->setText("<strong>Température Ext. Normale</strong>");
392  QPixmap imageTemperatureExterieur(":/images/images/temperatureNormal.png");
393  ui->labelImageTemperatureExterieur->setPixmap(imageTemperatureExterieur);
394  }
395 }
Definition: parametres.h:59
Ui::RucheIhm * ui
agrégation de la partie graphique de l&#39;IHM
Definition: rucheIhm.h:51
Definition: parametres.h:57
Definition: parametres.h:58

◆ afficherAlertesTemperatureInterieur

void RucheIhm::afficherAlertesTemperatureInterieur ( SeuilsAlertes  typeAlerte)
slot

Références bon, tropBas, tropHaut, et ui.

Référencé par selectionnerRuche().

331 {
332  qDebug() << Q_FUNC_INFO;
333 
334  QPalette paletteCouleur = ui->thermoTemperatureInterieur->palette();
335 
336  qDebug() << Q_FUNC_INFO << "SeuilsAlertes " << typeAlerte;
337 
338 
339  if(typeAlerte == tropHaut)
340  {
341  paletteCouleur.setColor(QPalette::ButtonText, QColor(255,0,0));
342  ui->thermoTemperatureInterieur->setPalette(paletteCouleur);
343  ui->labelAlerteTemperatureInterieur->setText("<strong>Température Int. Elevée</strong>");
344  QPixmap imageTemperatureInterieur(":/images/images/temperatureHaute.png");
345  ui->labelAlerteImageTemperature->setPixmap(imageTemperatureInterieur);
346  }
347  else if(typeAlerte == tropBas)
348  {
349  paletteCouleur.setColor(QPalette::ButtonText, QColor(135,206,250));
350  ui->thermoTemperatureInterieur->setPalette(paletteCouleur);
351  ui->labelAlerteTemperatureInterieur->setText("<strong>Température Int. Basse</strong>");
352  QPixmap imageTemperatureInterieur(":/images/images/temperatureBasseAlerte.png");
353  ui->labelAlerteImageTemperature->setPixmap(imageTemperatureInterieur);
354  }
355  else if(typeAlerte == bon)
356  {
357  paletteCouleur.setColor(QPalette::ButtonText, QColor(0,128,0));
358  ui->thermoTemperatureInterieur->setPalette(paletteCouleur);
359  ui->labelAlerteTemperatureInterieur->setText("<strong>Température Int. Normale</strong>");
360  QPixmap imageTemperatureInterieur(":/images/images/temperatureNormal.png");
361  ui->labelAlerteImageTemperature->setPixmap(imageTemperatureInterieur);
362  }
363 }
Definition: parametres.h:59
Ui::RucheIhm * ui
agrégation de la partie graphique de l&#39;IHM
Definition: rucheIhm.h:51
Definition: parametres.h:57
Definition: parametres.h:58

◆ afficherBatterie

void RucheIhm::afficherBatterie ( double  charge,
QString  horodatage 
)
slot

Références ui.

Référencé par selectionnerRuche().

258 {
259  qDebug() << Q_FUNC_INFO << "niveau de batterie = " << charge;
260  ui->lcdNumberBatterie->display(charge);
261  ui->groupBoxTemperatures->setTitle("Mesures : " + horodatage);
262 }
Ui::RucheIhm * ui
agrégation de la partie graphique de l&#39;IHM
Definition: rucheIhm.h:51

◆ afficherEnsoleillement

void RucheIhm::afficherEnsoleillement ( double  ensoleillement,
QString  horodatage 
)
slot
Paramètres
ensoleillementl'ensoleillement exterieur de la ruche

Références ui.

Référencé par selectionnerRuche().

324 {
325  qDebug() << Q_FUNC_INFO << "ensoleillement:" << ensoleillement;
326  ui->lcdNumberEnsoleillement->display(ensoleillement);
327  ui->groupBoxTemperatures->setTitle("Mesures : " + horodatage);
328 }
Ui::RucheIhm * ui
agrégation de la partie graphique de l&#39;IHM
Definition: rucheIhm.h:51

◆ afficherHumiditeExterieur

void RucheIhm::afficherHumiditeExterieur ( double  humiditeExterieur,
QString  horodatage 
)
slot
Paramètres
humiditeExterieurhumidite exterieur de la ruche

Références ui.

Référencé par selectionnerRuche().

295 {
296  ui->lcdNumberHumiditeExterieur->display(humiditeExterieur);
297  ui->groupBoxTemperatures->setTitle("Mesures : " + horodatage);
298 }
Ui::RucheIhm * ui
agrégation de la partie graphique de l&#39;IHM
Definition: rucheIhm.h:51

◆ afficherHumiditeInterieur

void RucheIhm::afficherHumiditeInterieur ( double  humiditeInterieur,
QString  horodatage 
)
slot
Paramètres
temperatureInterieurhumidite interieur de la ruche

Références ui.

Référencé par selectionnerRuche().

252 {
253  ui->lcdNumberHumiditeInterieur->display(humiditeInterieur);
254  ui->groupBoxTemperatures->setTitle("Mesures : " + horodatage);
255 }
Ui::RucheIhm * ui
agrégation de la partie graphique de l&#39;IHM
Definition: rucheIhm.h:51

◆ afficherMesuresJournalieresEnsoleillement

void RucheIhm::afficherMesuresJournalieresEnsoleillement ( )
slot

Références bdd, courbeEnsoleillement, mesRuches, BaseDeDonnees::recuperer(), et ui.

Référencé par selectionnerRuche().

973 {
974  QDate dateCourante = QDate::currentDate();
975  int positionDeLaRuche = ui->comboBoxChoixRuche->currentIndex()-1;
976  QVector<QStringList> mesuresJournalieresEnsoleillement;
977  QString requete = "SELECT Ensoleillement, HeureMesure FROM MesuresJournalieresEnsoleillement WHERE DateMesure = '" + dateCourante.toString("yyyy-MM-dd") + "' AND idRuche = '" + mesRuches[positionDeLaRuche].at(0) + "' ORDER BY HeureMesure ASC";
978  qDebug()<< Q_FUNC_INFO << requete;
979  bdd->recuperer(requete, mesuresJournalieresEnsoleillement);
980  qDebug()<< Q_FUNC_INFO << mesuresJournalieresEnsoleillement;
981 
982  if(mesuresJournalieresEnsoleillement.size() < 1)
983  return;
984 
985  QVector<double> ensoleillements;
986  QVector<double> heures;
987 
988  for(int i=0; i < mesuresJournalieresEnsoleillement.size(); i++)
989  {
990  ensoleillements.push_back(mesuresJournalieresEnsoleillement.at(i).at(0).toDouble());
991  QString heure = mesuresJournalieresEnsoleillement.at(i).at(1);
992  QTime heureMesure = QTime::fromString(heure, "HH:mm:ss");
993  heures.push_back(heureMesure.hour());
994  }
995  courbeEnsoleillement->setSamples(heures, ensoleillements);
996  ui->qwtPlotEnsoleillement->replot();
997 }
QVector< QStringList > mesRuches
Definition: rucheIhm.h:56
Ui::RucheIhm * ui
agrégation de la partie graphique de l&#39;IHM
Definition: rucheIhm.h:51
bool recuperer(QString requete, QString &donnees)
Definition: baseDeDonnees.cpp:188
QwtPlotCurve * courbeEnsoleillement
Definition: rucheIhm.h:62
BaseDeDonnees * bdd
agrégation de l&#39;objet BaseDeDonnees
Definition: rucheIhm.h:53

◆ afficherMesuresJournalieresEnvironement

void RucheIhm::afficherMesuresJournalieresEnvironement ( )
slot

Références bdd, courbeHumiditeExterieur, courbePressionAtmospherique, courbeTemperatureExterieur, mesRuches, BaseDeDonnees::recuperer(), et ui.

Référencé par selectionnerRuche().

938 {
939  QDate dateCourante = QDate::currentDate();
940  int positionDeLaRuche = ui->comboBoxChoixRuche->currentIndex()-1;
941  QVector<QStringList> mesuresJournalieresEnvironement;
942  QString requete = "SELECT Temperature, Humidite, Pression, HeureMesure FROM MesuresJournalieresEnvironnement WHERE DateMesure = '" + dateCourante.toString("yyyy-MM-dd") + "' AND idRuche = '" + mesRuches[positionDeLaRuche].at(0) + "' ORDER BY HeureMesure ASC";
943  qDebug()<< Q_FUNC_INFO << requete;
944  bdd->recuperer(requete, mesuresJournalieresEnvironement);
945  qDebug()<< Q_FUNC_INFO << mesuresJournalieresEnvironement;
946 
947  if(mesuresJournalieresEnvironement.size() < 1)
948  return;
949 
950  QVector<double> temperatures;
951  QVector<double> humidites;
952  QVector<double> pression;
953  QVector<double> heures;
954 
955  for(int i=0; i < mesuresJournalieresEnvironement.size(); i++)
956  {
957  temperatures.push_back(mesuresJournalieresEnvironement.at(i).at(0).toDouble());
958  humidites.push_back(mesuresJournalieresEnvironement.at(i).at(1).toDouble());
959  pression.push_back(mesuresJournalieresEnvironement.at(i).at(2).toDouble());
960  QString heure = mesuresJournalieresEnvironement.at(i).at(3);
961  QTime heureMesure = QTime::fromString(heure, "HH:mm:ss");
962  heures.push_back(heureMesure.hour());
963  }
964  courbeTemperatureExterieur->setSamples(heures, temperatures);
965  ui->qwtPlotTemperature->replot();
966  courbeHumiditeExterieur->setSamples(heures, humidites);
967  ui->qwtPlotHumidite->replot();
968  courbePressionAtmospherique->setSamples(heures, pression);
969  ui->qwtPlotPressionAtmospherique->replot();
970 }
QVector< QStringList > mesRuches
Definition: rucheIhm.h:56
QwtPlotCurve * courbeHumiditeExterieur
Definition: rucheIhm.h:60
QwtPlotCurve * courbePressionAtmospherique
Definition: rucheIhm.h:61
Ui::RucheIhm * ui
agrégation de la partie graphique de l&#39;IHM
Definition: rucheIhm.h:51
bool recuperer(QString requete, QString &donnees)
Definition: baseDeDonnees.cpp:188
QwtPlotCurve * courbeTemperatureExterieur
Definition: rucheIhm.h:58
BaseDeDonnees * bdd
agrégation de l&#39;objet BaseDeDonnees
Definition: rucheIhm.h:53

◆ afficherMesuresJournalieresRuche

void RucheIhm::afficherMesuresJournalieresRuche ( )
slot

Références bdd, courbeHumiditeInterieur, courbeTemperatureInterieur, mesRuches, BaseDeDonnees::recuperer(), et ui.

Référencé par selectionnerRuche().

906 {
907  QDate dateCourante = QDate::currentDate();
908  int positionDeLaRuche = ui->comboBoxChoixRuche->currentIndex()-1;
909  QVector<QStringList> mesuresJournalieresRuche;
910  QString requete = "SELECT Temperature, Humidite, HeureMesure FROM MesuresJournalieresRuche WHERE DateMesure = '" + dateCourante.toString("yyyy-MM-dd") + "' AND idRuche = '" + mesRuches[positionDeLaRuche].at(0) + "' ORDER BY HeureMesure ASC";
911  qDebug()<< Q_FUNC_INFO << requete;
912  bdd->recuperer(requete, mesuresJournalieresRuche);
913  qDebug()<< Q_FUNC_INFO << mesuresJournalieresRuche;
914 
915  if(mesuresJournalieresRuche.size() < 1)
916  return;
917 
918  QVector<double> temperatures;
919  QVector<double> humidites;
920  QVector<double> heures;
921 
922  for(int i=0; i < mesuresJournalieresRuche.size(); i++)
923  {
924  temperatures.push_back(mesuresJournalieresRuche.at(i).at(0).toDouble());
925  humidites.push_back(mesuresJournalieresRuche.at(i).at(1).toDouble());
926  QString heure = mesuresJournalieresRuche.at(i).at(2);
927  QTime heureMesure = QTime::fromString(heure, "HH:mm:ss");
928  heures.push_back(heureMesure.hour());
929  }
930 
931  courbeTemperatureInterieur->setSamples(heures, temperatures);
932  ui->qwtPlotTemperature->replot();
933  courbeHumiditeInterieur->setSamples(heures, humidites);
934  ui->qwtPlotHumidite->replot();
935 }
QVector< QStringList > mesRuches
Definition: rucheIhm.h:56
Ui::RucheIhm * ui
agrégation de la partie graphique de l&#39;IHM
Definition: rucheIhm.h:51
QwtPlotCurve * courbeTemperatureInterieur
Definition: rucheIhm.h:57
bool recuperer(QString requete, QString &donnees)
Definition: baseDeDonnees.cpp:188
BaseDeDonnees * bdd
agrégation de l&#39;objet BaseDeDonnees
Definition: rucheIhm.h:53
QwtPlotCurve * courbeHumiditeInterieur
Definition: rucheIhm.h:59

◆ afficherPoids

void RucheIhm::afficherPoids ( double  poids,
QString  horodatage 
)
slot

Références ui.

Référencé par selectionnerRuche().

265 {
266  qDebug() << Q_FUNC_INFO << "poids = " << poids;
267  ui->lcdNumberPoids->display(poids);
268  ui->groupBoxTemperatures->setTitle("Mesures : " + horodatage);
269 }
Ui::RucheIhm * ui
agrégation de la partie graphique de l&#39;IHM
Definition: rucheIhm.h:51

◆ afficherPressionAtmospherique

void RucheIhm::afficherPressionAtmospherique ( double  pressionAtmospherique,
QString  horodatage 
)
slot
Paramètres
pressionAtmospheriquepression atmospherique exterieur de la ruche

Références ui.

Référencé par selectionnerRuche().

309 {
310  qDebug() << Q_FUNC_INFO << "pressionAtmospherique:" << pressionAtmospherique;
311  ui->lcdNumberPressionAtmospherique->display(pressionAtmospherique);
312  ui->groupBoxTemperatures->setTitle("Mesures : " + horodatage);
313 }
Ui::RucheIhm * ui
agrégation de la partie graphique de l&#39;IHM
Definition: rucheIhm.h:51

◆ afficherTemperatureExterieur

void RucheIhm::afficherTemperatureExterieur ( double  temperatureExterieur,
QString  horodatage 
)
slot
Paramètres
temperatureExterieurtemperature exterieur de la ruche

Références ui.

Référencé par selectionnerRuche().

280 {
281  ui->thermoTemperatureExterieur->setValue(temperatureExterieur);
282  ui->lcdNumberTemperatureExterieur->display(temperatureExterieur);
283  ui->groupBoxTemperatures->setTitle("Mesures : " + horodatage);
284 }
Ui::RucheIhm * ui
agrégation de la partie graphique de l&#39;IHM
Definition: rucheIhm.h:51

◆ afficherTemperatureInterieur

void RucheIhm::afficherTemperatureInterieur ( double  temperatureInterieur,
QString  horodatage 
)
slot
Paramètres
temperatureInterieurdouble la température dans la ruche

Références ui.

Référencé par selectionnerRuche().

236 {
237  qDebug() << Q_FUNC_INFO << "temperatureInterieur=" << temperatureInterieur;
238  ui->lcdNumberTemperatureInterieur->display(temperatureInterieur);
239  ui->thermoTemperatureInterieur->setValue(temperatureInterieur);
240  ui->groupBoxTemperatures->setTitle("Mesures : " + horodatage);
241 }
Ui::RucheIhm * ui
agrégation de la partie graphique de l&#39;IHM
Definition: rucheIhm.h:51

◆ creerNouvelleRuche

void RucheIhm::creerNouvelleRuche ( )
privateslot

Références mettreAjourListeRuches(), et nouvelleRuche.

Référencé par RucheIhm().

197 {
198  int retour = nouvelleRuche->exec();
199  if(retour == QDialog::Accepted)
200  {
202  }
203  //QDialog::Rejected
204 }
void mettreAjourListeRuches()
Definition: rucheIhm.cpp:558
NouvelleRucheIhm * nouvelleRuche
Definition: rucheIhm.h:54

◆ initialiserEnsoleillementCourbe()

void RucheIhm::initialiserEnsoleillementCourbe ( )
private

Références courbeEnsoleillement, et ui.

Référencé par inititialiserCourbes().

886 {
887  ui->qwtPlotEnsoleillement->insertLegend(new QwtLegend(),QwtPlot::BottomLegend);
888  courbeEnsoleillement = new QwtPlotCurve("Ensoleillement");
889  courbeEnsoleillement->setLegendAttribute(QwtPlotCurve::LegendShowLine, true);
890  courbeEnsoleillement->setPen(QPen(Qt::blue));
891  courbeEnsoleillement->setCurveAttribute(QwtPlotCurve::Fitted); // courbe
892  courbeEnsoleillement->setRenderHint(QwtPlotItem::RenderAntialiased);
893  courbeEnsoleillement->setSymbol(new QwtSymbol(QwtSymbol::Cross, Qt::blue, QPen(Qt::black), QSize(5, 5)));
894  courbeEnsoleillement->attach(ui->qwtPlotEnsoleillement);
895 
896  QwtPlotMarker *SeuilEnsoleillement = new QwtPlotMarker();
897  SeuilEnsoleillement->setLabelAlignment(Qt::AlignRight|Qt::AlignTop);
898  SeuilEnsoleillement->setLineStyle(QwtPlotMarker::HLine);
899  SeuilEnsoleillement->setLinePen(QPen(Qt::red));
900  //SeuilEnsoleillement->setYValue(maRuche->getAlertes()->getSeuilEnsoleillement());
901  SeuilEnsoleillement->attach(ui->qwtPlotEnsoleillement);
902 }
Ui::RucheIhm * ui
agrégation de la partie graphique de l&#39;IHM
Definition: rucheIhm.h:51
QwtPlotCurve * courbeEnsoleillement
Definition: rucheIhm.h:62

◆ initialiserHumiditeExterieurCourbe()

void RucheIhm::initialiserHumiditeExterieurCourbe ( )
private

Références courbeHumiditeExterieur, et ui.

Référencé par inititialiserCourbes().

840 {
841  ui->qwtPlotHumidite->insertLegend(new QwtLegend(),QwtPlot::BottomLegend);
842  courbeHumiditeExterieur = new QwtPlotCurve("humidite exterieur");
843  courbeHumiditeExterieur->setLegendAttribute(QwtPlotCurve::LegendShowLine, true);
844  courbeHumiditeExterieur->setPen(QPen(Qt::green));
845  courbeHumiditeExterieur->setCurveAttribute(QwtPlotCurve::Fitted); // courbe
846  courbeHumiditeExterieur->setRenderHint(QwtPlotItem::RenderAntialiased);
847  courbeHumiditeExterieur->attach(ui->qwtPlotHumidite);
848 
849  QwtPlotMarker *seuilMin = new QwtPlotMarker();
850  //seuilMin->setLabel(QString::fromUtf8("Seuil minimum humidite interieur"));
851  //seuilMin->setLabelAlignment(Qt::AlignRight|Qt::AlignTop);
852  seuilMin->setLineStyle(QwtPlotMarker::HLine);
853  seuilMin->setLinePen(QPen(Qt::red));
854  //seuilMin->setYValue(maRuche->getAlertes()->getSeuilHumiditeExterieurMin());
855  seuilMin->attach(ui->qwtPlotHumidite);
856 
857  QwtPlotMarker *seuilMax = new QwtPlotMarker();
858  //seuilMax->setLabel(QString::fromUtf8("Seuil maximum humidite exterieur "));
859  //seuilMax->setLabelAlignment(Qt::AlignRight|Qt::AlignTop);
860  seuilMax->setLineStyle(QwtPlotMarker::HLine);
861  seuilMax->setLinePen(QPen(Qt::red));
862  //seuilMax->setYValue(maRuche->getAlertes()->getSeuilHumiditeExterieurMax());
863  seuilMax->attach(ui->qwtPlotHumidite);
864 }
QwtPlotCurve * courbeHumiditeExterieur
Definition: rucheIhm.h:60
Ui::RucheIhm * ui
agrégation de la partie graphique de l&#39;IHM
Definition: rucheIhm.h:51

◆ initialiserHumiditeInterieurCourbe()

void RucheIhm::initialiserHumiditeInterieurCourbe ( )
private

Références courbeHumiditeInterieur, et ui.

Référencé par inititialiserCourbes().

813 {
814  courbeHumiditeInterieur = new QwtPlotCurve("Humidite interieur");
815  courbeHumiditeInterieur->setLegendAttribute(QwtPlotCurve::LegendShowLine, true);
816  courbeHumiditeInterieur->setPen(QPen(Qt::blue));
817  courbeHumiditeInterieur->setCurveAttribute(QwtPlotCurve::Fitted); // courbe
818  courbeHumiditeInterieur->setRenderHint(QwtPlotItem::RenderAntialiased);
819  courbeHumiditeInterieur->attach(ui->qwtPlotHumidite);
820 
821  QwtPlotMarker *SeuilMin = new QwtPlotMarker();
822  //SeuilMin->setLabel(QString::fromUtf8("Seuil minimum humidite interieur"));
823  //SeuilMin->setLabelAlignment(Qt::AlignRight|Qt::AlignTop);
824  SeuilMin->setLineStyle(QwtPlotMarker::HLine);
825  SeuilMin->setLinePen(QPen(Qt::red));
826  //SeuilMin->setYValue(maRuche->getAlertes()->getSeuilHumiditeInterieurMin());
827  SeuilMin->attach(ui->qwtPlotHumidite);
828 
829  QwtPlotMarker *SeuilMax = new QwtPlotMarker();
830  //SeuilMax->setLabel(QString::fromUtf8("Seuil maximum humidite interieur "));
831  //SeuilMax->setLabelAlignment(Qt::AlignRight|Qt::AlignTop);
832  SeuilMax->setLineStyle(QwtPlotMarker::HLine);
833  SeuilMax->setLinePen(QPen(Qt::red, 1.0, Qt::DashLine));
834  SeuilMax->setYValue(75.);
835  //SeuilMax->setYValue(maRuche->getAlertes()->getSeuilHumiditeInterieurMax());
836  SeuilMax->attach(ui->qwtPlotHumidite);
837 }
Ui::RucheIhm * ui
agrégation de la partie graphique de l&#39;IHM
Definition: rucheIhm.h:51
QwtPlotCurve * courbeHumiditeInterieur
Definition: rucheIhm.h:59

◆ initialiserPressionAtmospheriqueCourbe()

void RucheIhm::initialiserPressionAtmospheriqueCourbe ( )
private

Références courbePressionAtmospherique, et ui.

Référencé par inititialiserCourbes().

867 {
868  ui->qwtPlotPressionAtmospherique->insertLegend(new QwtLegend(),QwtPlot::BottomLegend);
869  courbePressionAtmospherique = new QwtPlotCurve("Pression atmospherique");
870  courbePressionAtmospherique->setLegendAttribute(QwtPlotCurve::LegendShowLine, true);
871  courbePressionAtmospherique->setPen(QPen(Qt::blue));
872  courbePressionAtmospherique->setCurveAttribute(QwtPlotCurve::Fitted); // courbe
873  courbePressionAtmospherique->setRenderHint(QwtPlotItem::RenderAntialiased);
874  courbePressionAtmospherique->attach(ui->qwtPlotPressionAtmospherique);
875 
876  QwtPlotMarker *seuilPressionAtmospherique = new QwtPlotMarker();
877  seuilPressionAtmospherique->setLabel(QString::fromUtf8("Seuil pression atmospherique"));
878  seuilPressionAtmospherique->setLabelAlignment(Qt::AlignRight|Qt::AlignTop);
879  seuilPressionAtmospherique->setLineStyle(QwtPlotMarker::HLine);
880  seuilPressionAtmospherique->setLinePen(QPen(Qt::red));
881  //seuilPressionAtmospherique->setYValue(maRuche->getAlertes()->getSeuilPressionAtmospherique());
882  seuilPressionAtmospherique->attach(ui->qwtPlotPressionAtmospherique);
883 }
QwtPlotCurve * courbePressionAtmospherique
Definition: rucheIhm.h:61
Ui::RucheIhm * ui
agrégation de la partie graphique de l&#39;IHM
Definition: rucheIhm.h:51

◆ initialiserTemperatureExterieurCourbe()

void RucheIhm::initialiserTemperatureExterieurCourbe ( )
private

Références courbeTemperatureExterieur, et ui.

Référencé par inititialiserCourbes().

784 {
785  qDebug() << Q_FUNC_INFO << "COURBE Temperature Exterieur";
786  ui->qwtPlotTemperature->insertLegend(new QwtLegend(),QwtPlot::BottomLegend);
787  courbeTemperatureExterieur = new QwtPlotCurve("Temperature Exterieur");
788  courbeTemperatureExterieur->setLegendAttribute(QwtPlotCurve::LegendShowLine, true);
789  courbeTemperatureExterieur->setPen(QPen(Qt::green));
790  courbeTemperatureExterieur->setCurveAttribute(QwtPlotCurve::Fitted); // courbe
791  courbeTemperatureExterieur->setRenderHint(QwtPlotItem::RenderAntialiased);
792  //courbeTemperatureExterieur->setSymbol(new QwtSymbol(QwtSymbol::Cross, Qt::red, QPen(Qt::black), QSize(5,5)));
793 
794  // on trace les points x,y
795  courbeTemperatureExterieur->attach(ui->qwtPlotTemperature);
796 
797  QwtPlotMarker *seuilMin = new QwtPlotMarker();
798  seuilMin->setLabelAlignment(Qt::AlignRight|Qt::AlignTop);
799  seuilMin->setLineStyle(QwtPlotMarker::HLine);
800  seuilMin->setLinePen(QPen(Qt::red));
801  //seuilMin->setYValue(maRuche->getAlertes()->getSeuilTemperatureExterieurMin());
802  seuilMin->attach(ui->qwtPlotTemperature);
803 
804  QwtPlotMarker *seuilMax = new QwtPlotMarker();
805  seuilMax->setLabelAlignment(Qt::AlignRight|Qt::AlignTop);
806  seuilMax->setLineStyle(QwtPlotMarker::HLine);
807  seuilMax->setLinePen(QPen(Qt::red));
808  //seuilMax->setYValue(maRuche->getAlertes()->getSeuilTemperatureExterieurMax());
809  seuilMax->attach(ui->qwtPlotTemperature);
810 }
Ui::RucheIhm * ui
agrégation de la partie graphique de l&#39;IHM
Definition: rucheIhm.h:51
QwtPlotCurve * courbeTemperatureExterieur
Definition: rucheIhm.h:58

◆ initialiserTemperatureInterieurCourbe()

void RucheIhm::initialiserTemperatureInterieurCourbe ( )
private

Références courbeTemperatureInterieur, et ui.

Référencé par inititialiserCourbes().

747 {
748  qDebug() << Q_FUNC_INFO << "COURBE Temperature Interieur";
749 
750  // Courbes
751  courbeTemperatureInterieur = new QwtPlotCurve("Temperature interieur");
752 
753  // Ajout de la courbe a la legende
754  courbeTemperatureInterieur->setLegendAttribute(QwtPlotCurve::LegendShowLine, true);
755 
756  //couleur de la courbe
757  courbeTemperatureInterieur->setPen(QPen(Qt::blue));
758  courbeTemperatureInterieur->setCurveAttribute(QwtPlotCurve::Fitted); // courbe
759  courbeTemperatureInterieur->setRenderHint(QwtPlotItem::RenderAntialiased);
760 
761  //type de tracé
762  //courbeTemperatureInterieur->setSymbol(new QwtSymbol(QwtSymbol::Ellipse, Qt::yellow, QPen(Qt::black), QSize(5, 5)));
763 
764  //atachement de la courbe a son repere
765  courbeTemperatureInterieur->attach(ui->qwtPlotTemperature);
766 
767  // Marqueurs Alertes
768  QwtPlotMarker *seuilMin = new QwtPlotMarker();
769  seuilMin->setLabelAlignment(Qt::AlignRight|Qt::AlignTop);
770  seuilMin->setLineStyle(QwtPlotMarker::HLine);
771  seuilMin->setLinePen(QPen(Qt::red));
772  //seuilMin->setYValue(maRuche->getAlertes()->getSeuilTemperatureInterieurMin());
773  seuilMin->attach(ui->qwtPlotTemperature);
774 
775  QwtPlotMarker *seuilMax = new QwtPlotMarker();
776  seuilMax->setLabelAlignment(Qt::AlignRight|Qt::AlignTop);
777  seuilMax->setLineStyle(QwtPlotMarker::HLine);
778  seuilMax->setLinePen(QPen(Qt::red));
779  //seuilMax->setYValue(maRuche->getAlertes()->getSeuilTemperatureInterieurMax());
780  seuilMax->attach(ui->qwtPlotTemperature);
781 }
Ui::RucheIhm * ui
agrégation de la partie graphique de l&#39;IHM
Definition: rucheIhm.h:51
QwtPlotCurve * courbeTemperatureInterieur
Definition: rucheIhm.h:57

◆ initialiserThermometre()

void RucheIhm::initialiserThermometre ( ) const
private

Références ui.

Référencé par initialiserWidgets().

111 {
112  ui->thermoTemperatureInterieur->setUpperBound(50);
113  ui->thermoTemperatureInterieur->setLowerBound(-10);
114  ui->thermoTemperatureInterieur->setScaleStepSize(5);
115  ui->thermoTemperatureInterieur->setPipeWidth(30);
116  ui->thermoTemperatureInterieur->alarmEnabled();
117 
118  ui->thermoTemperatureExterieur->setUpperBound(50);
119  ui->thermoTemperatureExterieur->setLowerBound(-10);
120  ui->thermoTemperatureExterieur->setScaleStepSize(5);
121  ui->thermoTemperatureExterieur->setPipeWidth(30);
122  ui->thermoTemperatureExterieur->alarmEnabled();
123 
124  // Initialisations Couleurs
125  QPalette paletteCouleur = ui->thermoTemperatureInterieur->palette();
126  paletteCouleur.setColor(QPalette::ButtonText, QColor(0,128,0));
127  ui->thermoTemperatureInterieur->setPalette(paletteCouleur);
128  ui->thermoTemperatureExterieur->setPalette(paletteCouleur);
129 }
Ui::RucheIhm * ui
agrégation de la partie graphique de l&#39;IHM
Definition: rucheIhm.h:51

◆ initialiserWidgets()

void RucheIhm::initialiserWidgets ( )
private

Références initialiserThermometre(), reinititialiserCourbes(), et ui.

Référencé par recevoirEtatClientConnexion(), et RucheIhm().

584 {
585  ui->groupBoxTemperatures->setTitle("Mesures");
586  ui->lcdNumberHumiditeInterieur->display("--");
587  ui->lcdNumberHumiditeExterieur->display("--");
588  ui->lcdNumberTemperatureInterieur->display("--");
589  ui->lcdNumberTemperatureExterieur->display("--");
590  ui->lcdNumberPressionAtmospherique->display("--");
591  ui->lcdNumberEnsoleillement->display("--");
592  ui->lcdNumberBatterie->display("--");
593  ui->lcdNumberPoids->display("--");
594  ui->labelRuche->setText("");
596  ui->QTabOnglet->setCurrentIndex(0); //Onglet Mesure == 0
597 
598  ui->labelAlerteHumiditeExterieur->setText("<strong>Humidité Ext. Normale</strong>");
599  QPixmap imageHumiditeExterieur(":/images/images/humiditeNormal.png");
600  ui->labelAlerteImageHumiditeInterieur->setPixmap(imageHumiditeExterieur);
601 
602  ui->labelAlerteHumiditeInterieur->setText("<strong>Humidité Int. Normale</strong>");
603  QPixmap imageHumiditeInterieur(":/images/images/humiditeNormal.png");
604  ui->labelAlerteImageHumiditeInterieur->setPixmap(imageHumiditeInterieur);
605 
606  ui->labelAlerteTemperatureExterieur->setText("<strong>Température Ext. Normale</strong>");
607  QPixmap imageTemperatureExterieur(":/images/images/temperatureNormal.png");
608  ui->labelAlerteImageTemperature->setPixmap(imageTemperatureExterieur);
609 
610  ui->labelAlerteTemperatureInterieur->setText("<strong>Température Int. Normale</strong>");
611  QPixmap imageTemperatureInterieur(":/images/images/temperatureNormal.png");
612  ui->labelAlerteImageTemperature->setPixmap(imageTemperatureInterieur);
613 
614  ui->labelAlerteBatterie->setText("<strong>Niveau de batterie correct</strong>");
615  QPixmap imageBatterie(":/images/images/batteryChargeMax.png");
616  ui->labelAlerteImageBatterie->setPixmap(imageBatterie);
617 
618  ui->labelAlertePoids->setText("<strong>Poids Normal</strong>");
619  QPixmap imagePoids(":/images/images/poidsnormal.png");
620  ui->labelAlerteImagePoids->setPixmap(imagePoids);
621 
622  ui->labelAlerteEnsoleillement->setText("<strong>Ensoleillement Normal</strong>");
623 
624  ui->labelAlertePressionAtmospherique->setText("<strong>Pression Atmospherique Normale</strong>");
625 
627 }
void reinititialiserCourbes()
Definition: rucheIhm.cpp:726
Ui::RucheIhm * ui
agrégation de la partie graphique de l&#39;IHM
Definition: rucheIhm.h:51
void initialiserThermometre() const
initialise les thermometres
Definition: rucheIhm.cpp:110

◆ inititialiserCourbes()

void RucheIhm::inititialiserCourbes ( )
private

Références initialiserEnsoleillementCourbe(), initialiserHumiditeExterieurCourbe(), initialiserHumiditeInterieurCourbe(), initialiserPressionAtmospheriqueCourbe(), initialiserTemperatureExterieurCourbe(), initialiserTemperatureInterieurCourbe(), et ui.

Référencé par RucheIhm().

651 {
652  //initialisation Titre
653  ui->qwtPlotHumidite->setTitle(QString::fromUtf8("Humidité"));
654  ui->qwtPlotPressionAtmospherique->setTitle(QString::fromUtf8("Pression atmosphérique"));
655  ui->qwtPlotTemperature->setTitle(QString::fromUtf8("Température"));
656  ui->qwtPlotPoids->setTitle(QString::fromUtf8("Poids"));
657  ui->qwtPlotEnsoleillement->setTitle(QString::fromUtf8("Ensoleillement"));
658  ui->qwtPlotCharge->setTitle(QString::fromUtf8("Charge"));
659 
660  // une légende à droite
661  ui->qwtPlotPoids->insertLegend(new QwtLegend(),QwtPlot::RightLegend);
662  ui->qwtPlotCharge->insertLegend(new QwtLegend(),QwtPlot::RightLegend);
663 
664  // cadrillage
665  QwtPlotGrid *cadrillageHumidite = new QwtPlotGrid ;;
666  QwtPlotGrid *cadrillagePressionAtmospherique = new QwtPlotGrid ;;
667  QwtPlotGrid *cadrillageTemperature = new QwtPlotGrid ;;
668  QwtPlotGrid *cadrillagePoids = new QwtPlotGrid ;;
669  QwtPlotGrid *cadrillageEnsoleillement = new QwtPlotGrid ;;
670  QwtPlotGrid *cadrillageCharge = new QwtPlotGrid ;
671 
672  cadrillageHumidite->setMajorPen(QPen(Qt::black, 0, Qt::DotLine));
673  cadrillagePressionAtmospherique->setMajorPen(QPen(Qt::black, 0, Qt::DotLine));
674  cadrillageTemperature->setMajorPen(QPen(Qt::black, 0, Qt::DotLine));
675  cadrillagePoids->setMajorPen(QPen(Qt::black, 0, Qt::DotLine));
676  cadrillageEnsoleillement->setMajorPen(QPen(Qt::black, 0, Qt::DotLine));
677  cadrillageCharge->setMajorPen(QPen(Qt::black, 0, Qt::DotLine));
678 
679 
680  cadrillageHumidite->attach(ui->qwtPlotHumidite);
681  cadrillagePressionAtmospherique->attach(ui->qwtPlotPressionAtmospherique);
682  cadrillageTemperature->attach(ui->qwtPlotTemperature);
683  cadrillagePoids->attach(ui->qwtPlotPoids);
684  cadrillageEnsoleillement->attach(ui->qwtPlotEnsoleillement);
685  cadrillageCharge->attach(ui->qwtPlotCharge);
686 
687  //configuration des axes
688  ui->qwtPlotHumidite->setAxisTitle(QwtPlot::xBottom,QString::fromUtf8("minutes -->")); // nom de l'axe x
689  ui->qwtPlotHumidite->setAxisTitle(QwtPlot::yLeft,QString::fromUtf8("% -->")); // nom de l'Axe y
690  ui->qwtPlotHumidite->setAxisScale(QwtPlot::xBottom, 0.0, 24.0,0); // scale de l'axe x
691  ui->qwtPlotHumidite->setAxisScale(QwtPlot::yLeft, 0.0, 100.0); // scale de l'axe y
692 
693  ui->qwtPlotPressionAtmospherique->setAxisTitle(QwtPlot::xBottom,QString::fromUtf8("minutes -->")); // nom de l'axe x
694  ui->qwtPlotPressionAtmospherique->setAxisTitle(QwtPlot::yLeft,QString::fromUtf8("HPa -->")); // nom de l'Axe y
695  ui->qwtPlotPressionAtmospherique->setAxisScale(QwtPlot::xBottom, 0.0, 24.0, 0); // scale de l'axe x
696  ui->qwtPlotPressionAtmospherique->setAxisScale(QwtPlot::yLeft, 0.0, 1300.0); // scale de l'axe y
697 
698  ui->qwtPlotTemperature->setAxisTitle(QwtPlot::xBottom,QString::fromUtf8("minutes -->")); // nom de l'axe x
699  ui->qwtPlotTemperature->setAxisTitle(QwtPlot::yLeft,QString::fromUtf8("°C -->")); // nom de l'Axe y
700  ui->qwtPlotTemperature->setAxisScale(QwtPlot::xBottom, 0.0, 24.0, 0); // scale de l'axe x
701  ui->qwtPlotTemperature->setAxisScale(QwtPlot::yLeft, 0.0, 55.0); // scale de l'axe y
702 
703  ui->qwtPlotPoids->setAxisTitle(QwtPlot::xBottom,QString::fromUtf8("minutes -->")); // nom de l'axe x
704  ui->qwtPlotPoids->setAxisTitle(QwtPlot::yLeft,QString::fromUtf8("Kg -->")); // nom de l'Axe y
705  ui->qwtPlotPoids->setAxisScale(QwtPlot::xBottom, 0.0, 24.0, 0); // scale de l'axe x
706  ui->qwtPlotPoids->setAxisScale(QwtPlot::yLeft, 0.0, 100.0); // scale de l'axe y
707 
708  ui->qwtPlotEnsoleillement->setAxisTitle(QwtPlot::xBottom,QString::fromUtf8("minutes -->")); // nom de l'axe x
709  ui->qwtPlotEnsoleillement->setAxisTitle(QwtPlot::yLeft,QString::fromUtf8("W/M² -->")); // nom de l'Axe y
710  ui->qwtPlotEnsoleillement->setAxisScale(QwtPlot::xBottom, 0.0, 24.0, 0); // scale de l'axe x
711  ui->qwtPlotEnsoleillement->setAxisScale(QwtPlot::yLeft, 0.0, 1500); // scale de l'axe y
712 
713  ui->qwtPlotCharge->setAxisTitle(QwtPlot::xBottom,QString::fromUtf8("minutes -->")); // nom de l'axe x
714  ui->qwtPlotCharge->setAxisTitle(QwtPlot::yLeft,QString::fromUtf8("% -->")); // nom de l'Axe y
715  ui->qwtPlotCharge->setAxisScale(QwtPlot::xBottom, 0.0, 24.0, 0); // scale de l'axe x
716  ui->qwtPlotCharge->setAxisScale(QwtPlot::yLeft, 0.0, 100); // scale de l'axe y
717 
724 }
void initialiserHumiditeInterieurCourbe()
Definition: rucheIhm.cpp:812
Ui::RucheIhm * ui
agrégation de la partie graphique de l&#39;IHM
Definition: rucheIhm.h:51
void initialiserTemperatureInterieurCourbe()
Definition: rucheIhm.cpp:746
void initialiserTemperatureExterieurCourbe()
Definition: rucheIhm.cpp:783
void initialiserHumiditeExterieurCourbe()
Definition: rucheIhm.cpp:839
void initialiserPressionAtmospheriqueCourbe()
Definition: rucheIhm.cpp:866
void initialiserEnsoleillementCourbe()
Definition: rucheIhm.cpp:885

◆ mettreAjourListeRuches

void RucheIhm::mettreAjourListeRuches ( )
privateslot

Références bdd, maRuche, mesRuches, BaseDeDonnees::recuperer(), et ui.

Référencé par creerNouvelleRuche(), et RucheIhm().

559 {
560  mesRuches.clear();
561  ui->comboBoxChoixRuche->clear();
562  QString requete = "SELECT Ruche.idRuche, Ruche.Nom, Ruche.DeviceID, TTN.idTTN, TTN.Hostname, TTN.Port, TTN.Username, TTN.Password, TTN.ApplicationID, Ruche.Adresse, Ruche.DateMiseEnService, Ruche.Longitude, Ruche.Latitude FROM Ruche INNER JOIN TTN ON Ruche.idTTN = TTN.idTTN ";
563  qDebug()<< Q_FUNC_INFO << requete;
564  bdd->recuperer(requete, mesRuches);
565  qDebug()<< Q_FUNC_INFO << mesRuches;
566  if(mesRuches.size() == 0)
567  ui->comboBoxChoixRuche->addItem("Aucune ruche");
568  else
569  ui->comboBoxChoixRuche->addItem("Choix d'une ruche");
570  for(int i=0;i<mesRuches.size();i++)
571  {
572  QStringList maRuche = mesRuches.at(i);
573  ui->comboBoxChoixRuche->addItem(maRuche.at(1));
574  }
575 }
QVector< QStringList > mesRuches
Definition: rucheIhm.h:56
Ui::RucheIhm * ui
agrégation de la partie graphique de l&#39;IHM
Definition: rucheIhm.h:51
bool recuperer(QString requete, QString &donnees)
Definition: baseDeDonnees.cpp:188
Ruche * maRuche
association de l&#39;objet Ruche
Definition: rucheIhm.h:52
BaseDeDonnees * bdd
agrégation de l&#39;objet BaseDeDonnees
Definition: rucheIhm.h:53

◆ nouvelleDonnesRuche

void RucheIhm::nouvelleDonnesRuche ( QString  nom,
QString  prenom,
QString  email,
QString  nomTopic 
)
signal

◆ ouvrirReglagesAlertes

void RucheIhm::ouvrirReglagesAlertes ( )
privateslot

Références APP_TITRE, reglagesAlertesIhm, et ui.

Référencé par RucheIhm().

207 {
208  if(ui->comboBoxChoixRuche->currentIndex() == 0)
209  {
210  QMessageBox::critical(0, QString::fromUtf8(APP_TITRE), QString::fromUtf8("Aucune ruche selectionnée !"));
211  return;
212  }
213  reglagesAlertesIhm->exec();
214 }
#define APP_TITRE
Definition: parametres.h:17
ReglagesAlertesIhm * reglagesAlertesIhm
Definition: rucheIhm.h:55
Ui::RucheIhm * ui
agrégation de la partie graphique de l&#39;IHM
Definition: rucheIhm.h:51

◆ quitter

void RucheIhm::quitter ( )
slot

Référencé par RucheIhm().

98 {
99  // Fermeture de la fenêtre
100  close();
101 }

◆ recevoirEtatClientConnexion

void RucheIhm::recevoirEtatClientConnexion ( bool  etat)
slot

Références initialiserWidgets(), et ui.

Référencé par selectionnerRuche().

217 {
218  if(etat)
219  ui->labelEtatConnexionRuche->setText(QString::fromUtf8("Connectée"));
220  else
221  {
222  ui->labelEtatConnexionRuche->setText(QString::fromUtf8("Déconnectée"));
224  }
225 }
void initialiserWidgets()
Definition: rucheIhm.cpp:583
Ui::RucheIhm * ui
agrégation de la partie graphique de l&#39;IHM
Definition: rucheIhm.h:51

◆ reinititialiserCourbes()

void RucheIhm::reinititialiserCourbes ( )
private

Références courbeEnsoleillement, courbeHumiditeExterieur, courbeHumiditeInterieur, courbePressionAtmospherique, courbeTemperatureExterieur, courbeTemperatureInterieur, et ui.

Référencé par initialiserWidgets().

727 {
728  QVector<double> temperatures;
729  QVector<double> humidites;
730  QVector<double> pression;
731  QVector<double> ensoleillements;
732  QVector<double> heures;
733 
734  courbeTemperatureInterieur->setSamples(heures, temperatures);
735  courbeTemperatureExterieur->setSamples(heures, temperatures);
736  ui->qwtPlotTemperature->replot();
737  courbeHumiditeInterieur->setSamples(heures, humidites);
738  courbeHumiditeExterieur->setSamples(heures, humidites);
739  ui->qwtPlotHumidite->replot();
740  courbePressionAtmospherique->setSamples(heures, pression);
741  ui->qwtPlotPressionAtmospherique->replot();
742  courbeEnsoleillement->setSamples(heures, ensoleillements);
743  ui->qwtPlotEnsoleillement->replot();
744 }
QwtPlotCurve * courbeHumiditeExterieur
Definition: rucheIhm.h:60
QwtPlotCurve * courbePressionAtmospherique
Definition: rucheIhm.h:61
Ui::RucheIhm * ui
agrégation de la partie graphique de l&#39;IHM
Definition: rucheIhm.h:51
QwtPlotCurve * courbeTemperatureInterieur
Definition: rucheIhm.h:57
QwtPlotCurve * courbeEnsoleillement
Definition: rucheIhm.h:62
QwtPlotCurve * courbeTemperatureExterieur
Definition: rucheIhm.h:58
QwtPlotCurve * courbeHumiditeInterieur
Definition: rucheIhm.h:59

◆ selectionnerRuche

void RucheIhm::selectionnerRuche ( int  numeroRuche)
privateslot

numeroRuche int le numéro de la ruche dans la liste déroulante

Références afficherAlertesBatterie(), afficherAlertesEnsoleillement(), afficherAlertesHumiditeExterieur(), afficherAlertesHumiditeInterieur(), afficherAlertesPoids(), afficherAlertesPressionAtmospherique(), afficherAlertesTemperatureExterieur(), afficherAlertesTemperatureInterieur(), afficherBatterie(), afficherEnsoleillement(), afficherHumiditeExterieur(), afficherHumiditeInterieur(), afficherMesuresJournalieresEnsoleillement(), afficherMesuresJournalieresEnvironement(), afficherMesuresJournalieresRuche(), afficherPoids(), afficherPressionAtmospherique(), afficherTemperatureExterieur(), afficherTemperatureInterieur(), Ruche::getAlertes(), maRuche, mesRuches, recevoirEtatClientConnexion(), reglagesAlertesIhm, ReglagesAlertesIhm::setAlertes(), et ui.

Référencé par RucheIhm().

139 {
140  if(mesRuches.size() == 0)
141  return;
142  numeroRuche -= 1;
143  qDebug() << Q_FUNC_INFO << "numeroRuche" << numeroRuche << "nb ruches" << mesRuches.size();
144  if(maRuche != 0)
145  {
146  delete maRuche;
147  maRuche = 0;
148  }
149  if(maRuche == 0 && numeroRuche >= 0)
150  {
151  QDate date = QDate::fromString(mesRuches.at(numeroRuche).at(10),Qt::ISODate);
152  ui->labelRuche->setText(mesRuches.at(numeroRuche).at(1) + " : " + mesRuches.at(numeroRuche).at(9) + " mise en service le " + date.toString("dd/MM/yyyy") + " [" + mesRuches.at(numeroRuche).at(12) + " " + mesRuches.at(numeroRuche).at(11) + "]");
153  maRuche = new Ruche(mesRuches.at(numeroRuche), this);
155  connect(maRuche,SIGNAL(etatClientConnexion(bool)),this,SLOT(recevoirEtatClientConnexion(bool)));
156  /**********************************************SLOT AFFICHAGE MESURE**********************************************************************/
157  connect(maRuche,SIGNAL(nouvelleMesureTemperatureInterieurTraite(double,QString)),this,SLOT(afficherTemperatureInterieur(double,QString)));
158  connect(maRuche,SIGNAL(nouvelleMesureHumiditeInterieurTraite(double,QString)),this,SLOT(afficherHumiditeInterieur(double,QString)));
159  connect(maRuche,SIGNAL(nouvelleMesureTemperatureExterieurTraite(double,QString)),this,SLOT(afficherTemperatureExterieur(double,QString)));
160  connect(maRuche,SIGNAL(nouvelleMesureHumiditeExterieurTraite(double,QString)),this,SLOT(afficherHumiditeExterieur(double,QString)));
161  connect(maRuche,SIGNAL(nouvellePressionAtmospheriqueTraite(double,QString)),this,SLOT(afficherPressionAtmospherique(double,QString)));
162  connect(maRuche,SIGNAL(nouvelleMesureEnsoleillementTraite(double,QString)),this,SLOT(afficherEnsoleillement(double,QString)));
163  connect(maRuche, SIGNAL(nouvelleMesureCharge(double, QString)),this, SLOT(afficherBatterie(double, QString)));
164  connect(maRuche, SIGNAL(nouvelleMesurePoids(double, QString)), this, SLOT(afficherPoids(double, QString)));
165  /**********************************************SLOT AFFICHAGE Alertes*********************************************************************/
166  connect(maRuche,SIGNAL(envoiAlertesTemperatureInterieur(SeuilsAlertes)),this,SLOT(afficherAlertesTemperatureInterieur(SeuilsAlertes)));
167  connect(maRuche,SIGNAL(envoiAlertesTemperatureExterieur(SeuilsAlertes)),this,SLOT(afficherAlertesTemperatureExterieur(SeuilsAlertes)));
168  connect(maRuche,SIGNAL(envoiAlertesHumiditeInterieur(SeuilsAlertes)),this,SLOT(afficherAlertesHumiditeInterieur(SeuilsAlertes)));
169  connect(maRuche,SIGNAL(envoiAlertesHumiditeExterieur(SeuilsAlertes)),this,SLOT(afficherAlertesHumiditeExterieur(SeuilsAlertes)));
170  connect(maRuche,SIGNAL(envoiAlertesPressionAtmospherique(SeuilsAlertes)),this,SLOT(afficherAlertesPressionAtmospherique(SeuilsAlertes)));
171  connect(maRuche, SIGNAL(envoiAlertesPoids(SeuilsAlertes)),this, SLOT(afficherAlertesPoids(SeuilsAlertes)));
172  connect(maRuche, SIGNAL(envoiAlertesEnsoleillement(SeuilsAlertes,double)),this,SLOT(afficherAlertesEnsoleillement(SeuilsAlertes, double)));
173  connect(maRuche, SIGNAL(envoiAlertesBatterie(SeuilsAlertes, double)),this, SLOT(afficherAlertesBatterie(SeuilsAlertes,double)));
174  /**********************************SLOT Courbes*********************************/
175  connect(maRuche, SIGNAL(nouvelleMesureTemperatureInterieurTraiteParHeure()),this,SLOT(afficherMesuresJournalieresRuche()));
176  connect(maRuche, SIGNAL(nouvelleMesureTemperatureExterieurTraiteParHeure()), this, SLOT(afficherTemperatureExterieurCourbe()));
177  connect(maRuche, SIGNAL(nouvelleMesureHumiditeInterieurTraiteParHeure()), this, SLOT(afficherMesuresJournalieresRuche()));
178  connect(maRuche, SIGNAL(nouvelleMesureHumiditeExterieurTraiteParHeure()), this, SLOT(afficherHumiditeExterieurCourbe()));
179  connect(maRuche, SIGNAL(nouvelleMesurePressionAtmospheriqueTraiteParHeure()), this, SLOT(afficherPressionAtmospheriqueCourbe()));
180  connect(maRuche, SIGNAL(nouvelleMesureEnsoleillementTraiteParHeure()),this,SLOT(afficherEnsoleillementCourbe()));
181 
182  //initialiserSeuilsCourbe();
186  }
187 }
void afficherAlertesTemperatureExterieur(SeuilsAlertes typeAlerte)
Definition: rucheIhm.cpp:365
void setAlertes(Alertes *alertes)
setter de l&#39;objet alertes
Definition: reglagesAlertesIhm.cpp:56
void afficherAlertesPressionAtmospherique(SeuilsAlertes typeAlerte)
Definition: rucheIhm.cpp:447
void afficherTemperatureExterieur(double temperatureExterieur, QString horodatage)
affiche temperature exterieur à l&#39;aide de widget graphique
Definition: rucheIhm.cpp:279
La classe Ruche.
Definition: ruche.h:115
void afficherMesuresJournalieresEnvironement()
Definition: rucheIhm.cpp:937
void afficherMesuresJournalieresRuche()
Definition: rucheIhm.cpp:905
QVector< QStringList > mesRuches
Definition: rucheIhm.h:56
void recevoirEtatClientConnexion(bool etat)
Definition: rucheIhm.cpp:216
void afficherEnsoleillement(double ensoleillement, QString horodatage)
affiche l&#39;ensoleillement à l&#39;aide de widget graphique
Definition: rucheIhm.cpp:323
Alertes * getAlertes()
Definition: ruche.cpp:94
void afficherAlertesHumiditeExterieur(SeuilsAlertes typeAlerte)
Definition: rucheIhm.cpp:421
ReglagesAlertesIhm * reglagesAlertesIhm
Definition: rucheIhm.h:55
SeuilsAlertes
Definition: parametres.h:55
Ui::RucheIhm * ui
agrégation de la partie graphique de l&#39;IHM
Definition: rucheIhm.h:51
void afficherHumiditeExterieur(double humiditeExterieur, QString horodatage)
affiche humidite exterieur à l&#39;aide de widget graphique
Definition: rucheIhm.cpp:294
Ruche * maRuche
association de l&#39;objet Ruche
Definition: rucheIhm.h:52
void afficherAlertesTemperatureInterieur(SeuilsAlertes typeAlerte)
Definition: rucheIhm.cpp:330
void afficherAlertesEnsoleillement(SeuilsAlertes typeAlerte, double mesure)
Definition: rucheIhm.cpp:493
void afficherAlertesPoids(SeuilsAlertes typeAlerte)
Definition: rucheIhm.cpp:471
void afficherHumiditeInterieur(double humiditeInterieur, QString horodatage)
affiche humidite interieur à l&#39;aide de widget graphique
Definition: rucheIhm.cpp:251
void afficherAlertesHumiditeInterieur(SeuilsAlertes typeAlerte)
Definition: rucheIhm.cpp:397
void afficherMesuresJournalieresEnsoleillement()
Definition: rucheIhm.cpp:972
void afficherBatterie(double charge, QString horodatage)
Definition: rucheIhm.cpp:257
void afficherAlertesBatterie(SeuilsAlertes typeAlerte, double mesure)
Definition: rucheIhm.cpp:525
void afficherPoids(double poids, QString horodatage)
Definition: rucheIhm.cpp:264
void afficherPressionAtmospherique(double pressionAtmospherique, QString horodatage)
affiche pression atmospherique à l&#39;aide de widget graphique
Definition: rucheIhm.cpp:308
void afficherTemperatureInterieur(double temperatureInterieur, QString horodatage)
affiche temperature interieur à l&#39;aide de widget graphique
Definition: rucheIhm.cpp:235

◆ supprimerRuche

void RucheIhm::supprimerRuche ( )
privateslot

Références APP_TITRE, bdd, BaseDeDonnees::executer(), mesRuches, et ui.

Référencé par RucheIhm().

630 {
631  if(ui->comboBoxChoixRuche->currentIndex() == 0)
632  {
633  QMessageBox::critical(0, QString::fromUtf8(APP_TITRE), QString::fromUtf8("Supression impossible ! Aucune ruche selectionnée !"));
634  return;
635  }
636  int positionDeLaRuche = ui->comboBoxChoixRuche->currentIndex()-1;
637  QString requete = "DELETE FROM Ruche WHERE Ruche.DeviceID ='" + mesRuches[positionDeLaRuche].at(2) + "'";
638  bool etatRequete = bdd->executer(requete);
639  if(etatRequete == true)
640  {
641  ui->comboBoxChoixRuche->removeItem(ui->comboBoxChoixRuche->currentIndex());
642  ui->comboBoxChoixRuche->setCurrentIndex(0);
643  }
644  else
645  {
646  QMessageBox::critical(0, QString::fromUtf8(APP_TITRE), QString::fromUtf8("Impossible de suprimmer la ruche"));
647  }
648 }
#define APP_TITRE
Definition: parametres.h:17
QVector< QStringList > mesRuches
Definition: rucheIhm.h:56
Ui::RucheIhm * ui
agrégation de la partie graphique de l&#39;IHM
Definition: rucheIhm.h:51
bool executer(QString requete)
Definition: baseDeDonnees.cpp:150
BaseDeDonnees * bdd
agrégation de l&#39;objet BaseDeDonnees
Definition: rucheIhm.h:53

Documentation des données membres

◆ bdd

BaseDeDonnees* RucheIhm::bdd
private

◆ courbeEnsoleillement

QwtPlotCurve* RucheIhm::courbeEnsoleillement
private

◆ courbeHumiditeExterieur

QwtPlotCurve* RucheIhm::courbeHumiditeExterieur
private

◆ courbeHumiditeInterieur

QwtPlotCurve* RucheIhm::courbeHumiditeInterieur
private

◆ courbePressionAtmospherique

QwtPlotCurve* RucheIhm::courbePressionAtmospherique
private

◆ courbeTemperatureExterieur

QwtPlotCurve* RucheIhm::courbeTemperatureExterieur
private

◆ courbeTemperatureInterieur

QwtPlotCurve* RucheIhm::courbeTemperatureInterieur
private

◆ maRuche

Ruche* RucheIhm::maRuche
private

◆ mesRuches

QVector<QStringList> RucheIhm::mesRuches
private

◆ nouvelleRuche

NouvelleRucheIhm* RucheIhm::nouvelleRuche
private

Référencé par creerNouvelleRuche(), et RucheIhm().

◆ reglagesAlertesIhm

ReglagesAlertesIhm* RucheIhm::reglagesAlertesIhm
private

◆ ui

Ui::RucheIhm* RucheIhm::ui
private

La documentation de cette classe a été générée à partir des fichiers suivants :