Harness::Harness(QObject *parent) : QObject(parent)
{
	settingsManager.loadSavedSettings();

	gui = new MainWindow;
	serialManager = new SerialManager;
	packetReceiver = new PacketReceiver;
	windDataAnalyzer = new WindDataAnalyzer;
	dataLogger = new DataLogger;
	systemTimer = new QTimer;
	batteryChargeCalculator = new BatteryChargeCalculator;
	loggingData = false;

	connect(serialManager, SIGNAL(onNewDataReady(QByteArray)), packetReceiver, SLOT(onNewDataReceived(QByteArray)));
	connect(serialManager, SIGNAL(serialPortError(QString)), this, SLOT(onSerialPortError(QString)));
	connect(packetReceiver, SIGNAL(validPacketReceived()), this, SLOT(onValidPacketReceived()));
	connect(packetReceiver, SIGNAL(invalidPacketReceived()), this, SLOT(onInvalidPacketReceived()));
	connect(gui, SIGNAL(connectSerialButtonClicked(QString)), this, SLOT(onConnectSerialButtonClicked(QString)));
	connect(gui, SIGNAL(saveDataLogButtonClicked()), this, SLOT(onSaveDataLogButtonClicked()));
	connect(gui, SIGNAL(startLoggingButtonClicked()), this, SLOT(onStartLoggingButtonClicked()));
	connect(gui, SIGNAL(clearLogButtonClicked()), this, SLOT(onClearLogButtonClicked()));
	connect(gui, SIGNAL(settingsChanged()), this, SLOT(onSettingsChanged()));
	connect(systemTimer, SIGNAL(timeout()), this, SLOT(onSystemTimerTimeout()));

	compassOffset = settingsManager.getSettings().compassOffset;
	loadGUIDefaultValues();
	gui->show();
	systemTimer->start(SYSTEM_TIMER_INTERVAL_MS);
}
void Harness::onSettingsChanged()
{
	qDebug() << "Harness::onSettingsChanged()";
	settingsManager.updateSettings(gui->getSettingsWidget());
	settingsManager.saveSettings();
	windDataAnalyzer->setAverageSpeedCalculationTimeRange(settingsManager.getSettings().averageSpeedCalculationTimeRange);
	windDataAnalyzer->setGustSpeedCalculationTimeRange(settingsManager.getSettings().gustSpeedCalculationTimeRange);
	dataLogger->enableAutomaticSaving(settingsManager.getSettings().automaticLogSavingEnabled);
	dataLogger->setAutomaticSavingInterval(settingsManager.getSettings().automaticLogSavingIntervalS);
	dataLogger->setAutomaticSavingFolderPath(settingsManager.getSettings().automaticLogSavingFolderPath);
	compassOffset = settingsManager.getSettings().compassOffset;
}
示例#3
0
//Fonction qui traite les <span> (styles internes aux paragraphes)
bool OpenDocument::traite_span(QTextCharFormat format, QTextCursor &curseur, QDomElement e, bool puces, bool tableau){

    SettingsManager settings;
    ErrorManager instance_erreur;
    QTextCharFormat format_span;
    if(e.tagName() == "text:span"){
        QString nom_format = e.attribute("text:style-name");
        format_span = cree_bloc_format(nom_format);
        //On merge le format
        format.merge(format_span);
        if(!format.hasProperty(QTextFormat::FontPointSize)){
            format.setFontPointSize(settings.getSettings(Taille).toInt());
        }
    }
    else{
        instance_erreur.Erreur_msg(tr("ODT : <span> invalide"), QMessageBox::Ignore);
    }

    //Maintenant on lit les <span>
    QDomNode enfants = e.firstChild();

    while(!enfants.isNull()){
        QDomNode sous_enfants = enfants.firstChild();

        //Détection d'éventuels sous-nœuds
        if(!sous_enfants.isNull() && sous_enfants.isElement()){
            //Si c'est une note, on se défausse
            if(sous_enfants.toElement().tagName() == "text:note-citation"){
                //On ne fait rien, les notes de bas de page ne sont pas encore gérées.
            }
            else{
                //Quoi que ce soit, ce n'est pas un <p>, on le rebalance à la fonction
                traite_span(format, curseur, e);
            }
        }

        //Type d'élément
        if(enfants.isElement()){
            QDomElement elem = enfants.toElement();

            if(elem.tagName() == "text:line-break"){
                curseur.insertText(QString(QChar::LineSeparator));
            }
            else if(elem.tagName() == "text:span"){
                traite_span(format, curseur, e, puces, tableau);
            }
            else if(elem.tagName() == "draw:frame"){

            }
            else if(elem.tagName() == "text:s"){
                curseur.insertText(QString(" "));
            }
            else if(elem.tagName() == "text:a"){
                traite_lien(curseur, elem, format);
            }
            else if(elem.tagName() == "text:tab"){
                curseur.insertText(QString("    "));
            }
            else{
                instance_erreur.Erreur_msg(tr("ODT : type de <span> non détecté"), QMessageBox::Ignore);
            }
        }
        else if(enfants.isText()){
            //On gére le texte
            QStringList contenu = enfants.nodeValue().split("\n");
            for(int i=0; i<contenu.size(); i++){
                if(puces){
                    //On récupère le style par défaut
                    QTextDocument *temp = new QTextDocument;
                    QTextCursor curseur2(temp);
                    curseur2.insertText(contenu.at(i), format);
                    contenu_puce.append(nettoye_code(temp->toHtml()));
                    delete temp;
                }
                else if(tableau){
                    QTextDocument *temp = new QTextDocument;
                    QTextCursor curseur2(temp);
                    curseur2.insertText(contenu.at(i), format);
                    case_tableau.append(nettoye_code(temp->toHtml()));
                }
                else{
                    curseur.insertText(contenu.at(i), format);
                }
            }
        }
        enfants = enfants.nextSibling();
    }
    return true;
}
示例#4
0
//Création du format
QTextCharFormat OpenDocument::cree_bloc_format(QString nom){
    ErrorManager instance_erreur;
    SettingsManager settings;
    QTextCharFormat format;
    int id_style = -1;

    for(int i=0; i<styles.size(); i++){
        //On parcourt les styles
        if(id_style >= 0){
            break;
        }
        for(int j=0; j<styles.at(i).size(); j++){
            //On rentre dans le QMultiMap
            if(styles.at(i).value("name") == nom){
                id_style = i;
                //On sort de la boucle
                break;
            }
        }
    }

    if(id_style < 0){
        //On a pas trouvé de style -> on applique le style par défaut
        QString font_temp = settings.getSettings(Police).toString();
        int taille_temp = settings.getSettings(Taille).toInt();
        QFont police_default(font_temp);
        format.setFont(police_default);
        format.setFontPointSize(taille_temp);
        instance_erreur.Erreur_msg(tr("ODT : format non trouvé : application du style par défaut"), QMessageBox::Ignore);
    }
    else{
        //On applique le style trouvé
        //Police
        if(styles.at(id_style).contains("font-name")){
            QFont police(styles.at(id_style).value("font-name"));
            format.setFont(police);
        }
        //Taille
        if(styles.at(id_style).contains("font-size")){
            QString taille = styles.at(id_style).value("font-size");
            taille = taille.remove("pt");
            qreal taille_num = taille.toInt();
            format.setFontPointSize(taille_num);
        }
        else{
            //On indique la taille par défaut sinon il y a des bugs
            //format.setFontPointSize(settings.getSettings(Taille).toInt());
        }
        //Gras
        if(styles.at(id_style).contains("font-weight")){
            QString gras = styles.at(id_style).value("font-weight");
            if(gras == "bold"){
                format.setFontWeight(QFont::Bold);
            }
            else if(gras == "normal"){
                format.setFontWeight(QFont::Normal);
            }
            else{
                instance_erreur.Erreur_msg(tr("ODT : Type de graisse non supporté"), QMessageBox::Ignore);
                format.setFontWeight(QFont::Normal);
            }
        }
        //Style
        if(styles.at(id_style).contains("font-style")){
            QString italique = styles.at(id_style).value("font-style");
            if(italique == "italic"){
                format.setFontItalic(true);
            }
            else if(italique == "normal"){
                format.setFontItalic(false);
            }
            else{
                instance_erreur.Erreur_msg(tr("ODT : erreur lors de la réception de l'italique"), QMessageBox::Ignore);
                //On désactive l'italique par défaut
                format.setFontItalic(false);
            }
        }
        //Souligne
        if(styles.at(id_style).contains("text-underline-style")){
            if(styles.at(id_style).value("text-underline-style") == "solid"){
                format.setFontUnderline(true);
            }
            else if(styles.at(id_style).value("text-underline-style") == "none"){
                format.setFontUnderline(false);
            }
            else{
                instance_erreur.Erreur_msg(tr("Type de soulignement non pris en charge -> désactivation"), QMessageBox::Ignore);
                format.setFontUnderline(false);
            }
        }
        //Surlignage
        if(styles.at(id_style).contains("background-color")){
            QString test_couleur = styles.at(id_style).value("background-color");
            if(test_couleur != "transparent"){ //Si la valeur est "transparent", on ne fait rien, c'est déjà la couleur par défaut.
                format.setBackground(QBrush(QColor(styles.at(id_style).value("background-color"))));
            }
        }
        //Couleur de texte
        if(styles.at(id_style).contains("color")){
            format.setForeground(QBrush(QColor(styles.at(id_style).value("color"))));
        }
    }

    return format;
}