Einstellungsdialog

Hallo,

ich habe einen Dialog gestaltet, in dem ich Einstellungen vornehmen kann(ComboBox). Die Einstellungen würde ich mit QSettings speichern. Nun weiß ich noch nciht, wie ich das ganze gestalten soll. Im Dialog habe ich einen Übernehmen Button.

Ich habe mir das Konzept jetzt so überlegt. In der HauptFenster Klasse habe ich die Einstellungen als private. Der Dialog wird über Die Menüleiste aufgerufen. Im Konstruktor des Dialogs werden die aktuellen Einstellungen eingelesen. Nur wenn der Dialog wieder geschlossen wird. Was gibt es da für eine Möglichkeit, das beim erneuten Aufrufen die Comboboxes richtig gesetzt sind? Ebenso im Hauptfenster Konstruktor. Wenn ich aus Übernehmen gehe werden die Einstellungen gespeichert. Nur wie synchronisiere ich jetzt am besten mit dem Hauptfenster? Ich könnte beim clicken des übernehmen Buttons ein SIGNAL aussenden. Und auf das SIgnal im Hauptfenster wieder die Einstellungen mittels QSettings auslesen. Aber ist das gut so? Oder sollte ich lieber die geänderten Werte direkt mit einem Signal übergeben?

Gibt es ansonsten noch Kritik an dem Konzept?
Viele Grüße

l'abra d'or

Grob skizziert KÖNNTE das so aussehen:

class SettingsDlg : public QDialog
{
    // initialisiert die ganzen ComboBoxen und LineEdits
    void readSettings( const QSettings& settings );

    // schreibt die ganzen Werte in das QSettings-Objekt
    void writeSettings( QSettings& settings );
};

void MainWindow::on_settingsAction_toggled()
{
    SettingsDlg dlg;
    dlg.readSettings( this->settings );
    if( dlg.exec() == QDialog::Accepted ) {
        dlg.writeSettings( this->settings );
    }
}

Du kannst natürlich alle Werte des Dialogs auch mit gettern/settern verfügbar machen (ui würde ich kapseln um keinen Unfug zuzulassen), und das setup des Dialogs und Auslesen der Werte um es in das settings-Objekt einzufügen im MainWindow erledigen.

class SettingsDlg : public QDialog {
    QString lastModifiedName() { return ui->lastModifiedName_LineEdit->text(); }
    // usw
};

Aber das ist Geschmackssache.

So recht sehe ich noch nciht durch. Ich hatte mir eigentlich gedacht die Settings in Strings, ints etc zu speichern, und dann über das Settingsobjekt mit setValue, und .value in die Datei zu Schreiben, bzw. aus der Datei in die Settings einzulesen. Das wird ja jetzt so gar nciht gemacht, oder?

l'abra d'or

Qt Beginner schrieb:

So recht sehe ich noch nciht durch. Ich hatte mir eigentlich gedacht die Settings in Strings, ints etc zu speichern, und dann über das Settingsobjekt mit setValue, und .value in die Datei zu Schreiben, bzw. aus der Datei in die Settings einzulesen. Das wird ja jetzt so gar nciht gemacht, oder?

Doch, in readSettings und writeSettings!
readSettings(const QSettings& settings) liest aus dem übergebenen settings-Objekt mittels value() die einzelnen Optionen ein und setzt die Werte in die ui-Elemente des Dialogs.

void SettingsDlg::readSettings( const QSettings& settings ) {
  ui->nameEdit->setText(settings.value("Person/Name").toString());
  // usw.
}

Umgekehrt schreibt writeSettings auf die Selbe Art die im Dialog gesetzten Werte in das settings-Objekt zurück:

void SettingsDlg::writeSettings( QSettings& settings ) const {
  settings.setValue("Person/Name", ui->nameEdit->text());
  // usw.
}

Ich hoffe das ist jetzt klarer.

Aber wie gesagt, das ist nur EINE Möglichkeit. Ich find sie recht schön.

Ja das klappt ja auch alles Wunderbar. Ich meinte im HauptFenster brauche ich ja die Werte.

Also wenn ich da habe:

private:
QString Name;

QSettings settings;

Da muss ich ja jetzt noch aus dem SettingsObjekt in den Namen einlesen. Oder sollte man lieber gleich mit dem Settingsobjekt arbeiten und Name weg lassen?

l'abra d'or

Ich würde nicht beides speichern! Entweder settings-Objekt oder Variablen.
Ich denk es ist performanter, das settings-Objekt erst in der MainWindow::showConfigDlg() zu erstellen, und nach dem Schließen des dlg alles neu einzustellen (name setzen, Werte in grafischen Elementen ändern, usw).
Aber ich will da nichts pauschales sagen, denn das kommt einfach auf den Anwendungsfall an.

Ich würde aber nicht zu lange an der wie-Frage rumdoktern. Ich kenn das nur zu gut - man will es im ersten Anlauf perfekt machen, Ergebnis ist dass man es gar nie macht und das Projekt irgendwann sausen lässt

Also so:

void MainWindow::on_settingsAction_toggled()
{
    QSettings settings("Firma","Produkt");
    SettingsDlg dlg;
    dlg.readSettings( this->settings );
    if( dlg.exec() == QDialog::Accepted ) {
        dlg.writeSettings( this->settings );
        //Werte in QString etc. einlesen
    }
}

l'abra d'or

Genau, so in etwa hab ich mir das gedacht
Wenn es so funktioniert sollte ja alles bestens sein.

Ah danke. Und das gleiche brauche ich ja auch im MainWindow Konstruktor. Also am besten gleich in eine Methode packen.

l'abra d'or

Qt Beginner schrieb:

Ah danke. Und das gleiche brauche ich ja auch im MainWindow Konstruktor. Also am besten gleich in eine Methode packen.

Exakt :)=-

Macht man solche Kleinigkeiten lieber durch eine Methode, oder mit einem Slot? Also an der genannten Stelle ein Signal senden? Methode dürfte eig effizienter sein, oder?