Qt wiki will be updated on October 12th 2023 starting at 11:30 AM (EEST) and the maintenance will last around 2-3 hours. During the maintenance the site will be unavailable.

DatabaseConnectionDialog/de

From Qt Wiki
< DatabaseConnectionDialog
Revision as of 17:02, 12 March 2015 by AutoSpider (talk | contribs) (Decode HTML entity names)
Jump to navigation Jump to search
This article may require cleanup to meet the Qt Wiki's quality standards. Reason: Auto-imported from ExpressionEngine.
Please improve this article if you can. Remove the {{cleanup}} tag and add this page to Updated pages list after it's clean.

Deutsch | English

Allgemeiner Datenbank-Verbindungs-Dialog

Dieser etwas längere Code-Schnipsel zeigt, wie man einen allgemeinen Datenbank-Verbindungs-Dialog implementiert, der den Benutzer zur Eingabe von allgemeinen Datenbank-Verbindung-Eigenschaften (Benutzername, Passwort, Hostname, etc) auffordert und eine Combo-Box mit allen verfügbaren Datenbanktreibern zeigt. Der Dialog stellt auch ein Signal mit der Datenbankverbindung (sofern sie hergestellt werden konnte) zur Verfügung, so dass die Verbindung von weiteren Komponenten genutzt werden kann.

Benutzung

Der Dialog wird wie folgt genutzt: 

DatabaseConnectionDialog* dialog = new DatabaseConnectionDialog(this);

// optional: set the data that will be presented to the user as auto-filled form
 dialog->setDatabaseName( "mydb" );
 dialog->setDatabasePortNumber( 1234 );
 dialog->setDatabaseHostName( "localhost" );
 dialog->setDatabaseUsername( "luca" );
 dialog->setDatabaseDriverName( "QPSQL" );
 dialog->setDatabasePassword( "pwd" );

// enable the connect button if all the data is correct
 dialog->checkFormData();
 // connect the dialog signal to a slot where I will use the connection
 connect( dialog,
 SIGNAL (databaseConnect(QSqlDatabase&)),
 this,
 SLOT (slotHandleNewDatabaseConnection(QSqlDatabase&)));

// show the dialog (without auto-connection)
 dialog->run( false );

Die Felder des Dialogs können vor dem Anzeigen initialisiert werden. Darüber hinaus gibt es einen Automatik-Verbindungs-Modus (Auto-Connect-Modus), so dass die Verbindung automatisch hergestellt wird, sobald alle notwendigen Daten verfügbar sind.

Der hier gezeigte Dialog ist natürlich noch lange nicht perfekt. Es gibt noch viel Spielraum für Verbbesserungen, aber es ist eine gute Vorlage, um loszulegen.

Auto-Connect-Modus

Beim Aufruf der 

run()

-Methode kann als Argument ein Boolean-Wert übergeben werden. Dabei steht true für den Auto-Connect-Modus. In diesem Modus wird die Verbindung automatisch hergestellt, sobald alle nötigen Verbindungsdaten vorliegen. Wenn das zusammen mit den Initialisierungsdaten erfolgreich war, wird der Dialog gar nicht erst angezeigt, stattdessen wird sofort das o.g. Signal ausgesendet. Wenn es aber nicht erfolgreich war, entweder weil die Formulardaten unvollständig waren oder weil die Verbindung nicht hergestellt werden konnte, wird der Dialog doch angezeigt. Wenn 

run()

mit false aufgerufen wird, ist der Auto-Connect-Modus deaktiviert und der Dialog wird in jedem Fall angezeigt.

Quelltext

Dies ist die Header-Datei: 

/*!
 * databasedialog.h
 */
#ifndef DATABASEDIALOG_H
#define DATABASEDIALOG_H

#include <QDialog>
#include <QLabel>
#include <QLineEdit>
#include <QComboBox>
#include <QSpinBox>
#include <QDialogButtonBox>
#include <QHBoxLayout>
#include <QVBoxLayout>
#include <QGridLayout>
#include <QSqlDatabase>
#include <QString>
#include <QMessageBox>
#include <QDebug>
#include <QSqlError>
#include <QPushButton>
#include <QGroupBox>

class DatabaseConnectionDialog : public QDialog
{
 Q_OBJECT

private:

 /*!
 * The display label for the database driver name.
 */
 QLabel''' labelDatabaseDriverName;

 /*!
 * The display label for the TCP/IP port the database
 * is listening for connections.
 */
 QLabel''' labelDatabasePort;

 /*!
 * The label for the database name.
 */
 QLabel''' labelDatabaseName;

 /*!
 * The label for the database host name.
 */
 QLabel''' labelDatabaseHostName;

 /*!
 * The label for the database username.
 */
 QLabel''' labelDatabaseUsername;

 /*!
 * The label for the database password.
 */
 QLabel''' labelDatabasePassword;

 /*!
 * A label to display the summary database URL
 * connection string.
 */
 QLabel''' labelDatabaseURL;


 /*!
 * The editable name of the database to which the user
 * wants to connect to.
 */
 QLineEdit''' editDatabaseName;

 /*!
 * The editable name of the database name to which connect.
 */
 QLineEdit''' editDatabaseHostName;

 /*!
 * The database listening port.
 */
 QSpinBox''' spinBoxDatabasePort;

 /*!
 * The editable username to use for the connection.
 */
 QLineEdit''' editDatabaseUsername;

 /*!
 * The editable password to use for the connection.
 */
 QLineEdit''' editDatabasePassword;

 /*!
 * The combo from which the user can select the database
 * driver name and type
 */
 QComboBox''' comboDatabaseDriverName;


 /*!
 * A Dialog button box for displaying the
 * connect/cancel buttons.
 */
 QDialogButtonBox''' buttons;

 /*!
 * A method to create all the components of this dialog window
 * and lay out them correctly.
 */
 void setUpGUI();

 /*!
 * Searches for and populates the combo box with the
 * available database drivers.
 */
 void findAvailableDrivers();


 /*!
 * Performs the connection to the database
 * and emits the signal to pass the connection.
 */
 void doDatabaseConnection();

public:
 explicit DatabaseConnectionDialog(QWidget '''parent = 0);

 /*!
 * Sets the database name in the dialog.
 * dbName the name of the database
 */
 void setDatabaseName( const QString& dbName );

 /*!
 * Sets the port number for the database connection.
 * portNumber the port number the database is listening for
 * connections
 */
 void setDatabasePortNumber( int& portNumber );

 /*!
 * Sets the remote host name mnemonic name.
 * hostname the name of the host the database is running on
 */
 void setDatabaseHostName( const QString& hostname );

 /*!
 * Sets the username to use for the connection.
 * username the username to use for the connection
 */
 void setDatabaseUsername( const QString& username );

 /*!
 * Selects the driver name.
 * the driver name (therefore the database type) to
 * select in the combo box.
 */
 void setDatabaseDriverName( const QString& drvName );

 /*!
 * Sets the user password.
 * the password to use for the connection
 */
 void setDatabasePassword( const QString& pwd );


 /*!
 * Performs a check against the user data and enables/disables
 * the connect button depending on the form fill status.
 '''true if the data allows a database connection
*/
 bool checkFormData();

 /*!
 * Performs the database connection or prompt the user
 * showing this dialog in the case data is not completed
 * or should not perform the autoconnection.
 * autoConnect if set to true tries to perform an automatic
 * connection to the database, if the data is complete, or prompt the user
 * for missing data. If set to false, simply shows the dialog and waits.
 */
 void run( bool autoConnect );


signals:

 /*!
 * Passes the database connection in the case the connection
 * is succesful.
 * databaseConnection the connection object
 */
 void databaseConnect( QSqlDatabase& databaseConnection );

public slots:

 /*!
 * Checks if the user has entered enough data to
 * try a database connection.
 */
 bool slotCheckFormData();


 /*!
 * Performs the database connection.
 */
 void slotPerformConnection();

};

#endif // DATABASEDIALOG_H


Und hier folgt die Klassenimplementierung: 

#include "databasedialog.h"

DatabaseConnectionDialog::DatabaseConnectionDialog(QWidget '''parent) :
 QDialog(parent)
{
 // this dialog is modal
 setModal( true );
 // the title of this dialog
 setWindowTitle( tr("Database connection") );
 // place each GUI component
 setUpGUI();
 // load available drivers
 findAvailableDrivers();
}

void DatabaseConnectionDialog::setUpGUI()
{


 // create all gui components
 labelDatabaseDriverName = new QLabel( tr("Database Type (driver name)"), this );
 labelDatabasePort = new QLabel( tr("TCP/IP Port Number"), this );
 labelDatabaseName = new QLabel( tr("Database Name"), this );
 labelDatabaseHostName = new QLabel( tr("Host Name"), this );
 labelDatabaseUsername = new QLabel( tr("Username"), this );
 labelDatabasePassword = new QLabel( tr("Password"), this );
 labelDatabaseURL = new QLabel( this );
 labelDatabaseURL->setAlignment( Qt::AlignCenter );

 spinBoxDatabasePort = new QSpinBox( this );
 spinBoxDatabasePort->setMaximum( 9999 );
 spinBoxDatabasePort->setMinimum( 100 );
 spinBoxDatabasePort->setSingleStep( 1 );

 comboDatabaseDriverName = new QComboBox( this );
 comboDatabaseDriverName->setEditable( false );


 editDatabaseName = new QLineEdit( this );
 editDatabaseHostName = new QLineEdit( this );
 editDatabaseUsername = new QLineEdit( this );
 editDatabasePassword = new QLineEdit( this );
 editDatabasePassword->setEchoMode( QLineEdit::Password );
 connect( editDatabaseName,
 SIGNAL (editingFinished()),
 this,
 SLOT (slotCheckFormData()) );
 connect( editDatabaseHostName,
 SIGNAL (editingFinished()),
 this,
 SLOT (slotCheckFormData()) );
 connect( editDatabaseUsername,
 SIGNAL (editingFinished()),
 this,
 SLOT (slotCheckFormData()) );
 connect( editDatabasePassword,
 SIGNAL (editingFinished()),
 this,
 SLOT (slotCheckFormData()) );
 connect( editDatabasePassword,
 SIGNAL (returnPressed()),
 this,
 SLOT (slotCheckFormData()) );


 // create the button box
 buttons = new QDialogButtonBox( this );
 buttons->addButton( QDialogButtonBox::Ok );
 buttons->addButton( QDialogButtonBox::Cancel );
 QPushButton''' okButton = buttons->button( QDialogButtonBox::Ok );
 okButton->setText( tr( "Connect!" ) );
 okButton->setEnabled( false );
 connect( buttons,
 SIGNAL (accepted()),
 this,
 SLOT (slotPerformConnection()));
 connect( buttons,
 SIGNAL (rejected()),
 this,
 SLOT (close()));

// create a vertical layout to display components
 QVBoxLayout* verticalLayout = new QVBoxLayout( this );

// create a grid layout to add all the components
 QGridLayout* formGridLayout = new QGridLayout( this );
 QGroupBox* gridGroupBox = new QGroupBox( this );
 gridGroupBox->setTitle( tr("Database connection properties" ) );
 formGridLayout->addWidget( labelDatabaseDriverName, 0, 0 );
 formGridLayout->addWidget( comboDatabaseDriverName, 0, 1 );
 labelDatabaseDriverName->setBuddy( comboDatabaseDriverName );
 formGridLayout->addWidget( labelDatabaseHostName, 1, 0 );
 formGridLayout->addWidget( editDatabaseHostName, 1, 1);
 labelDatabaseHostName->setBuddy( editDatabaseHostName );
 formGridLayout->addWidget( labelDatabasePort, 2, 0 );
 formGridLayout->addWidget( spinBoxDatabasePort, 2, 1 );
 labelDatabasePort->setBuddy( spinBoxDatabasePort );
 formGridLayout->addWidget( labelDatabaseName, 3, 0 );
 formGridLayout->addWidget( editDatabaseName , 3, 1 );
 labelDatabaseName->setBuddy( editDatabaseName );
 formGridLayout->addWidget( labelDatabaseUsername, 4, 0 );
 formGridLayout->addWidget( editDatabaseUsername, 4, 1 );
 labelDatabaseUsername->setBuddy( editDatabaseUsername );
 formGridLayout->addWidget( labelDatabasePassword, 5, 0 );
 formGridLayout->addWidget( editDatabasePassword, 5, 1 );
 labelDatabasePassword->setBuddy( editDatabasePassword );
 // add all the elements to groupbox
 gridGroupBox->setLayout( formGridLayout );

// place a new groupbox to contain the database connection URL
 QGroupBox* urlGroupBox = new QGroupBox( this );
 urlGroupBox->setTitle( tr( "Database URL" ) );
 QHBoxLayout* urlLayout = new QHBoxLayout( this );
 urlLayout->addWidget( labelDatabaseURL );
 urlGroupBox->setLayout( urlLayout );

// nest all layouts together
 verticalLayout->addWidget( gridGroupBox );
 verticalLayout->addStretch();
 verticalLayout->addWidget( urlGroupBox );
 verticalLayout->addWidget( buttons );

comboDatabaseDriverName->setFocus();
}

void DatabaseConnectionDialog::findAvailableDrivers()
{
 // remove all items
 comboDatabaseDriverName->clear();

// populate the combo box with all available drivers
 foreach( QString driverName, QSqlDatabase::drivers() )
 comboDatabaseDriverName->addItem( driverName );
}

bool DatabaseConnectionDialog::slotCheckFormData()
{
 return checkFormData();
}

bool DatabaseConnectionDialog::checkFormData(){
 if( editDatabaseName->text().isEmpty()
 || editDatabaseHostName->text().isEmpty()
 || editDatabaseUsername->text().isEmpty()
 || editDatabasePassword->text().isEmpty() )
 buttons->button( QDialogButtonBox::Ok )->setEnabled( false );
 else{
 // enable the connect button and give focus
 buttons->button( QDialogButtonBox::Ok )->setEnabled( true );
 buttons->button( QDialogButtonBox::Ok )->setFocus();
 }


 // if the connection can be established (or at least tried)
 // display the URL
 if( buttons->button( QDialogButtonBox::Ok )->isEnabled() )
 labelDatabaseURL->setText( comboDatabaseDriverName->currentText()
 + "://"
 + editDatabaseUsername->text()
 + "@"
 + editDatabaseHostName->text()
 + "/"
 + editDatabaseName->text() );
 else
 labelDatabaseURL->setText( "" );

return buttons->button( QDialogButtonBox::Ok )->isEnabled();
}

void DatabaseConnectionDialog::doDatabaseConnection()
{
 // check the database driver is really available
 // (should never happen)
 if( ! QSqlDatabase::isDriverAvailable( comboDatabaseDriverName->currentText() ) ){
 QMessageBox::critical( this,
 tr("Database Connection Error"),
 tr("Database driver not available!")
 );

return;
 }

qDebug() << "Performing the database driver setup..";

// set database driver properties
 QSqlDatabase databaseConnection = QSqlDatabase::addDatabase( comboDatabaseDriverName->currentText() );
 databaseConnection.setDatabaseName( editDatabaseName->text() );
 databaseConnection.setUserName( editDatabaseUsername->text() );
 databaseConnection.setHostName( editDatabaseHostName->text() );
 databaseConnection.setPassword( editDatabasePassword->text() );
 databaseConnection.setPort( spinBoxDatabasePort->text().toInt() );

if( ! databaseConnection.open() ){
 QMessageBox::critical( this,
 tr("Database Connection Error"),
 databaseConnection.lastError().text()
 );

// disable the connect button and set the focus again
 // on the first field
 buttons->button( QDialogButtonBox::Ok )->setEnabled( false );
 editDatabaseHostName->setFocus();
 }
 else{
 // hide the dialog
 this->hide();

// emit the signal
 qDebug() << "Emitting signal since the database is connected!";
 emit databaseConnect( databaseConnection );
 }
}

void DatabaseConnectionDialog::slotPerformConnection()
{
 // perform another check against the user data
 if( slotCheckFormData() )
 doDatabaseConnection();

}

void DatabaseConnectionDialog::setDatabaseName(const QString &dbName)
{
 editDatabaseName->setText( dbName );
}

void DatabaseConnectionDialog::setDatabasePortNumber(int &portNumber)
{
 spinBoxDatabasePort->setValue( portNumber );
}

void DatabaseConnectionDialog::setDatabaseHostName(const QString &hostname)
{
 editDatabaseHostName->setText( hostname );
}

void DatabaseConnectionDialog::setDatabaseUsername(const QString &username)
{
 editDatabaseUsername->setText( username );
}

void DatabaseConnectionDialog::setDatabaseDriverName(const QString &drvName)
{
 int index = comboDatabaseDriverName->findText( drvName );
 if( index >= 0 )
 comboDatabaseDriverName->setCurrentIndex( index );
}

void DatabaseConnectionDialog::setDatabasePassword(const QString &pwd)
{
 editDatabasePassword->setText( pwd );
}

void DatabaseConnectionDialog::run(bool autoConnect)
{
 bool statusOk = checkFormData();
 if( ! autoConnect || ! statusOk )
 exec();
 else
 doDatabaseConnection();
}
Retrieved from "https://wiki-qt-io-staging.herokuapp.com/index.php?title=DatabaseConnectionDialog/de&oldid=13207"