summaryrefslogtreecommitdiffstats
path: root/kdeui/kpassdlg.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'kdeui/kpassdlg.cpp')
-rw-r--r--kdeui/kpassdlg.cpp721
1 files changed, 721 insertions, 0 deletions
diff --git a/kdeui/kpassdlg.cpp b/kdeui/kpassdlg.cpp
new file mode 100644
index 000000000..6ca6cc6ea
--- /dev/null
+++ b/kdeui/kpassdlg.cpp
@@ -0,0 +1,721 @@
+// vi: ts=8 sts=4 sw=4
+/* This file is part of the KDE libraries
+ Copyright (C) 1998 Pietro Iglio <iglio@fub.it>
+ Copyright (C) 1999,2000 Geert Jansen <jansen@kde.org>
+ Copyright (C) 2004,2005 Andrew Coles <andrew_coles@yahoo.co.uk>
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Library General Public
+ License version 2 as published by the Free Software Foundation.
+
+ This library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Library General Public License for more details.
+
+ You should have received a copy of the GNU Library General Public License
+ along with this library; see the file COPYING.LIB. If not, write to
+ the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ Boston, MA 02110-1301, USA.
+*/
+#include <unistd.h>
+
+#include <qwidget.h>
+#include <qlineedit.h>
+#include <qlabel.h>
+#include <qlayout.h>
+#include <qsize.h>
+#include <qevent.h>
+#include <qkeycode.h>
+#include <qcheckbox.h>
+#include <qregexp.h>
+#include <qhbox.h>
+#include <qwhatsthis.h>
+#include <qptrdict.h>
+
+#include <kglobal.h>
+#include <kdebug.h>
+#include <kapplication.h>
+#include <klocale.h>
+#include <kiconloader.h>
+#include <kmessagebox.h>
+#include <kaboutdialog.h>
+#include <kconfig.h>
+#include <kstandarddirs.h>
+#include <kprogress.h>
+
+#include <sys/time.h>
+#include <sys/resource.h>
+
+#include "kpassdlg.h"
+
+/*
+ * Password line editor.
+ */
+
+// BCI: Add a real d-pointer and put the int into that
+
+static QPtrDict<int>* d_ptr = 0;
+
+static void cleanup_d_ptr() {
+ delete d_ptr;
+}
+
+static int * ourMaxLength( const KPasswordEdit* const e ) {
+ if ( !d_ptr ) {
+ d_ptr = new QPtrDict<int>;
+ d_ptr->setAutoDelete(true);
+ qAddPostRoutine( cleanup_d_ptr );
+ }
+ int* ret = d_ptr->find( (void*) e );
+ if ( ! ret ) {
+ ret = new int;
+ d_ptr->replace( (void*) e, ret );
+ }
+ return ret;
+}
+
+static void delete_d( const KPasswordEdit* const e ) {
+ if ( d_ptr )
+ d_ptr->remove( (void*) e );
+}
+
+const int KPasswordEdit::PassLen = 200;
+
+class KPasswordDialog::KPasswordDialogPrivate
+{
+ public:
+ KPasswordDialogPrivate()
+ : m_MatchLabel( 0 ), iconName( 0 ), allowEmptyPasswords( false ),
+ minimumPasswordLength(0), maximumPasswordLength(KPasswordEdit::PassLen - 1),
+ passwordStrengthWarningLevel(1), m_strengthBar(0),
+ reasonablePasswordLength(8)
+ {}
+ QLabel *m_MatchLabel;
+ QString iconName;
+ bool allowEmptyPasswords;
+ int minimumPasswordLength;
+ int maximumPasswordLength;
+ int passwordStrengthWarningLevel;
+ KProgress* m_strengthBar;
+ int reasonablePasswordLength;
+};
+
+
+KPasswordEdit::KPasswordEdit(QWidget *parent, const char *name)
+ : QLineEdit(parent, name)
+{
+ init();
+
+ KConfig* const cfg = KGlobal::config();
+ KConfigGroupSaver saver(cfg, "Passwords");
+
+ const QString val = cfg->readEntry("EchoMode", "OneStar");
+ if (val == "ThreeStars")
+ m_EchoMode = ThreeStars;
+ else if (val == "NoEcho")
+ m_EchoMode = NoEcho;
+ else
+ m_EchoMode = OneStar;
+
+ setInputMethodEnabled( true );
+}
+
+KPasswordEdit::KPasswordEdit(QWidget *parent, const char *name, int echoMode)
+ : QLineEdit(parent, name), m_EchoMode(echoMode)
+{
+ init();
+}
+
+KPasswordEdit::KPasswordEdit(EchoModes echoMode, QWidget *parent, const char *name)
+ : QLineEdit(parent, name), m_EchoMode(echoMode)
+{
+ init();
+}
+
+KPasswordEdit::KPasswordEdit(EchoMode echoMode, QWidget *parent, const char *name)
+ : QLineEdit(parent, name)
+ , m_EchoMode( echoMode == QLineEdit::NoEcho ? NoEcho : OneStar )
+{
+ init();
+}
+
+void KPasswordEdit::init()
+{
+ setEchoMode(QLineEdit::Password); // Just in case
+ setAcceptDrops(false);
+ int* t = ourMaxLength(this);
+ *t = (PassLen - 1); // the internal max length
+ m_Password = new char[PassLen];
+ m_Password[0] = '\000';
+ m_Length = 0;
+}
+
+KPasswordEdit::~KPasswordEdit()
+{
+ memset(m_Password, 0, PassLen * sizeof(char));
+ delete[] m_Password;
+ delete_d(this);
+}
+
+void KPasswordEdit::insert(const QString &txt)
+{
+ const QCString localTxt = txt.local8Bit();
+ const unsigned int lim = localTxt.length();
+ const int m_MaxLength = maxPasswordLength();
+ for(unsigned int i=0; i < lim; ++i)
+ {
+ const unsigned char ke = localTxt[i];
+ if (m_Length < m_MaxLength)
+ {
+ m_Password[m_Length] = ke;
+ m_Password[++m_Length] = '\000';
+ }
+ }
+ showPass();
+}
+
+void KPasswordEdit::erase()
+{
+ m_Length = 0;
+ memset(m_Password, 0, PassLen * sizeof(char));
+ setText("");
+}
+
+void KPasswordEdit::focusInEvent(QFocusEvent *e)
+{
+ const QString txt = text();
+ setUpdatesEnabled(false);
+ QLineEdit::focusInEvent(e);
+ setUpdatesEnabled(true);
+ setText(txt);
+}
+
+
+void KPasswordEdit::keyPressEvent(QKeyEvent *e)
+{
+ switch (e->key()) {
+ case Key_Return:
+ case Key_Enter:
+ case Key_Escape:
+ e->ignore();
+ break;
+ case Key_Backspace:
+ case Key_Delete:
+ case 0x7f: // Delete
+ if (e->state() & (ControlButton | AltButton))
+ e->ignore();
+ else if (m_Length) {
+ m_Password[--m_Length] = '\000';
+ showPass();
+ }
+ break;
+ default:
+ const unsigned char ke = e->text().local8Bit()[0];
+ if (ke >= 32) {
+ insert(e->text());
+ } else
+ e->ignore();
+ break;
+ }
+}
+
+bool KPasswordEdit::event(QEvent *e) {
+ switch(e->type()) {
+
+ case QEvent::MouseButtonPress:
+ case QEvent::MouseButtonRelease:
+ case QEvent::MouseButtonDblClick:
+ case QEvent::MouseMove:
+ case QEvent::IMStart:
+ case QEvent::IMCompose:
+ return true; //Ignore
+
+ case QEvent::IMEnd:
+ {
+ QIMEvent* const ie = (QIMEvent*) e;
+ if (!ie->text().isEmpty())
+ insert( ie->text() );
+ return true;
+ }
+
+ case QEvent::AccelOverride:
+ {
+ QKeyEvent* const k = (QKeyEvent*) e;
+ switch (k->key()) {
+ case Key_U:
+ if (k->state() & ControlButton) {
+ m_Length = 0;
+ m_Password[m_Length] = '\000';
+ showPass();
+ }
+ }
+ return true; // stop bubbling
+ }
+
+ default:
+ // Do nothing
+ break;
+ }
+ return QLineEdit::event(e);
+}
+
+void KPasswordEdit::showPass()
+{
+ QString tmp;
+
+ switch (m_EchoMode) {
+ case OneStar:
+ tmp.fill('*', m_Length);
+ setText(tmp);
+ break;
+ case ThreeStars:
+ tmp.fill('*', m_Length*3);
+ setText(tmp);
+ break;
+ case NoEcho: default:
+ emit textChanged(QString::null); //To update the password comparison if need be.
+ break;
+ }
+}
+
+void KPasswordEdit::setMaxPasswordLength(int newLength)
+{
+ if (newLength >= PassLen) newLength = PassLen - 1; // belt and braces
+ if (newLength < 0) newLength = 0;
+ int* t = ourMaxLength(this);
+ *t = newLength;
+ while (m_Length > newLength) {
+ m_Password[m_Length] = '\000';
+ --m_Length;
+ }
+ showPass();
+}
+
+int KPasswordEdit::maxPasswordLength() const
+{
+ return *(ourMaxLength(this));
+}
+/*
+ * Password dialog.
+ */
+
+KPasswordDialog::KPasswordDialog(Types type, bool enableKeep, int extraBttn,
+ QWidget *parent, const char *name)
+ : KDialogBase(parent, name, true, "", Ok|Cancel|extraBttn,
+ Ok, true), m_Keep(enableKeep? 1 : 0), m_Type(type), d(new KPasswordDialogPrivate)
+{
+ d->iconName = "password";
+ init();
+}
+
+KPasswordDialog::KPasswordDialog(Types type, bool enableKeep, int extraBttn, const QString& icon,
+ QWidget *parent, const char *name )
+ : KDialogBase(parent, name, true, "", Ok|Cancel|extraBttn,
+ Ok, true), m_Keep(enableKeep? 1 : 0), m_Type(type), d(new KPasswordDialogPrivate)
+{
+ if ( icon.stripWhiteSpace().isEmpty() )
+ d->iconName = "password";
+ else
+ d->iconName = icon;
+ init();
+}
+
+KPasswordDialog::KPasswordDialog(int type, QString prompt, bool enableKeep,
+ int extraBttn)
+ : KDialogBase(0L, "Password Dialog", true, "", Ok|Cancel|extraBttn,
+ Ok, true), m_Keep(enableKeep? 1 : 0), m_Type(type), d(new KPasswordDialogPrivate)
+{
+ d->iconName = "password";
+ init();
+ setPrompt(prompt);
+}
+
+void KPasswordDialog::init()
+{
+ m_Row = 0;
+
+ KConfig* const cfg = KGlobal::config();
+ const KConfigGroupSaver saver(cfg, "Passwords");
+ if (m_Keep && cfg->readBoolEntry("Keep", false))
+ ++m_Keep;
+
+ m_pMain = new QWidget(this);
+ setMainWidget(m_pMain);
+ m_pGrid = new QGridLayout(m_pMain, 10, 3, 0, 0);
+ m_pGrid->addColSpacing(1, 10);
+
+ // Row 1: pixmap + prompt
+ QLabel *lbl;
+ const QPixmap pix( KGlobal::iconLoader()->loadIcon( d->iconName, KIcon::NoGroup, KIcon::SizeHuge, 0, 0, true));
+ if (!pix.isNull()) {
+ lbl = new QLabel(m_pMain);
+ lbl->setPixmap(pix);
+ lbl->setAlignment(AlignHCenter|AlignVCenter);
+ lbl->setFixedSize(lbl->sizeHint());
+ m_pGrid->addWidget(lbl, 0, 0, AlignCenter);
+ }
+
+ m_pHelpLbl = new QLabel(m_pMain);
+ m_pHelpLbl->setAlignment(AlignLeft|AlignVCenter|WordBreak);
+ m_pGrid->addWidget(m_pHelpLbl, 0, 2, AlignLeft);
+ m_pGrid->addRowSpacing(1, 10);
+ m_pGrid->setRowStretch(1, 12);
+
+ // Row 2+: space for 4 extra info lines
+ m_pGrid->addRowSpacing(6, 5);
+ m_pGrid->setRowStretch(6, 12);
+
+ // Row 3: Password editor #1
+ lbl = new QLabel(m_pMain);
+ lbl->setAlignment(AlignLeft|AlignVCenter);
+ lbl->setText(i18n("&Password:"));
+ lbl->setFixedSize(lbl->sizeHint());
+ m_pGrid->addWidget(lbl, 7, 0, AlignLeft);
+
+ QHBoxLayout *h_lay = new QHBoxLayout();
+ m_pGrid->addLayout(h_lay, 7, 2);
+ m_pEdit = new KPasswordEdit(m_pMain);
+ m_pEdit2 = 0;
+ lbl->setBuddy(m_pEdit);
+ QSize size = m_pEdit->sizeHint();
+ m_pEdit->setFixedHeight(size.height());
+ m_pEdit->setMinimumWidth(size.width());
+ h_lay->addWidget(m_pEdit);
+
+ // Row 4: Password editor #2 or keep password checkbox
+
+ if ((m_Type == Password) && m_Keep) {
+ m_pGrid->addRowSpacing(8, 10);
+ m_pGrid->setRowStretch(8, 12);
+ QCheckBox* const cb = new QCheckBox(i18n("&Keep password"), m_pMain);
+ cb->setFixedSize(cb->sizeHint());
+ if (m_Keep > 1)
+ cb->setChecked(true);
+ else
+ m_Keep = 0;
+ connect(cb, SIGNAL(toggled(bool)), SLOT(slotKeep(bool)));
+ m_pGrid->addWidget(cb, 9, 2, AlignLeft|AlignVCenter);
+ } else if (m_Type == NewPassword) {
+ m_pGrid->addRowSpacing(8, 10);
+ lbl = new QLabel(m_pMain);
+ lbl->setAlignment(AlignLeft|AlignVCenter);
+ lbl->setText(i18n("&Verify:"));
+ lbl->setFixedSize(lbl->sizeHint());
+ m_pGrid->addWidget(lbl, 9, 0, AlignLeft);
+
+ h_lay = new QHBoxLayout();
+ m_pGrid->addLayout(h_lay, 9, 2);
+ m_pEdit2 = new KPasswordEdit(m_pMain);
+ lbl->setBuddy(m_pEdit2);
+ size = m_pEdit2->sizeHint();
+ m_pEdit2->setFixedHeight(size.height());
+ m_pEdit2->setMinimumWidth(size.width());
+ h_lay->addWidget(m_pEdit2);
+
+ // Row 6: Password strength meter
+ m_pGrid->addRowSpacing(10, 10);
+ m_pGrid->setRowStretch(10, 12);
+
+ QHBox* const strengthBox = new QHBox(m_pMain);
+ strengthBox->setSpacing(10);
+ m_pGrid->addMultiCellWidget(strengthBox, 11, 11, 0, 2);
+ QLabel* const passStrengthLabel = new QLabel(strengthBox);
+ passStrengthLabel->setAlignment(AlignLeft|AlignVCenter);
+ passStrengthLabel->setText(i18n("Password strength meter:"));
+ d->m_strengthBar = new KProgress(100, strengthBox, "PasswordStrengthMeter");
+ d->m_strengthBar->setPercentageVisible(false);
+
+ const QString strengthBarWhatsThis(i18n("The password strength meter gives an indication of the security "
+ "of the password you have entered. To improve the strength of "
+ "the password, try:\n"
+ " - using a longer password;\n"
+ " - using a mixture of upper- and lower-case letters;\n"
+ " - using numbers or symbols, such as #, as well as letters."));
+ QWhatsThis::add(passStrengthLabel, strengthBarWhatsThis);
+ QWhatsThis::add(d->m_strengthBar, strengthBarWhatsThis);
+
+ // Row 6: Label saying whether the passwords match
+ m_pGrid->addRowSpacing(12, 10);
+ m_pGrid->setRowStretch(12, 12);
+
+ d->m_MatchLabel = new QLabel(m_pMain);
+ d->m_MatchLabel->setAlignment(AlignLeft|AlignVCenter|WordBreak);
+ m_pGrid->addMultiCellWidget(d->m_MatchLabel, 13, 13, 0, 2);
+ d->m_MatchLabel->setText(i18n("Passwords do not match"));
+
+
+ connect( m_pEdit, SIGNAL(textChanged(const QString&)), SLOT(enableOkBtn()) );
+ connect( m_pEdit2, SIGNAL(textChanged(const QString&)), SLOT(enableOkBtn()) );
+ enableOkBtn();
+ }
+
+ erase();
+}
+
+
+KPasswordDialog::~KPasswordDialog()
+{
+ delete d;
+}
+
+
+void KPasswordDialog::clearPassword()
+{
+ m_pEdit->erase();
+}
+
+/* KDE 4: Make it const QString & */
+void KPasswordDialog::setPrompt(QString prompt)
+{
+ m_pHelpLbl->setText(prompt);
+ m_pHelpLbl->setFixedSize(275, m_pHelpLbl->heightForWidth(275));
+}
+
+
+QString KPasswordDialog::prompt() const
+
+{
+ return m_pHelpLbl->text();
+}
+
+
+/* KDE 4: Make them const QString & */
+void KPasswordDialog::addLine(QString key, QString value)
+{
+ if (m_Row > 3)
+ return;
+
+ QLabel *lbl = new QLabel(key, m_pMain);
+ lbl->setAlignment(AlignLeft|AlignTop);
+ lbl->setFixedSize(lbl->sizeHint());
+ m_pGrid->addWidget(lbl, m_Row+2, 0, AlignLeft);
+
+ lbl = new QLabel(value, m_pMain);
+ lbl->setAlignment(AlignTop|WordBreak);
+ lbl->setFixedSize(275, lbl->heightForWidth(275));
+ m_pGrid->addWidget(lbl, m_Row+2, 2, AlignLeft);
+ ++m_Row;
+}
+
+
+void KPasswordDialog::erase()
+{
+ m_pEdit->erase();
+ m_pEdit->setFocus();
+ if (m_Type == NewPassword)
+ m_pEdit2->erase();
+}
+
+
+void KPasswordDialog::slotOk()
+{
+ if (m_Type == NewPassword) {
+ if (strcmp(m_pEdit->password(), m_pEdit2->password())) {
+ KMessageBox::sorry(this, i18n("You entered two different "
+ "passwords. Please try again."));
+ erase();
+ return;
+ }
+ if (d->m_strengthBar && d->m_strengthBar->progress() < d->passwordStrengthWarningLevel) {
+ int retVal = KMessageBox::warningContinueCancel(this,
+ i18n( "The password you have entered has a low strength. "
+ "To improve the strength of "
+ "the password, try:\n"
+ " - using a longer password;\n"
+ " - using a mixture of upper- and lower-case letters;\n"
+ " - using numbers or symbols as well as letters.\n"
+ "\n"
+ "Would you like to use this password anyway?"),
+ i18n("Low Password Strength"));
+ if (retVal == KMessageBox::Cancel) return;
+ }
+ }
+ if (!checkPassword(m_pEdit->password())) {
+ erase();
+ return;
+ }
+ accept();
+}
+
+
+void KPasswordDialog::slotCancel()
+{
+ reject();
+}
+
+
+void KPasswordDialog::slotKeep(bool keep)
+{
+ m_Keep = keep;
+}
+
+
+// static . antlarr: KDE 4: Make it const QString & prompt
+int KPasswordDialog::getPassword(QCString &password, QString prompt,
+ int *keep)
+{
+ const bool enableKeep = (keep && *keep);
+ KPasswordDialog* const dlg = new KPasswordDialog(int(Password), prompt, enableKeep);
+ const int ret = dlg->exec();
+ if (ret == Accepted) {
+ password = dlg->password();
+ if (enableKeep)
+ *keep = dlg->keep();
+ }
+ delete dlg;
+ return ret;
+}
+
+
+// static . antlarr: KDE 4: Make it const QString & prompt
+int KPasswordDialog::getNewPassword(QCString &password, QString prompt)
+{
+ KPasswordDialog* const dlg = new KPasswordDialog(NewPassword, prompt);
+ const int ret = dlg->exec();
+ if (ret == Accepted)
+ password = dlg->password();
+ delete dlg;
+ return ret;
+}
+
+
+// static
+void KPasswordDialog::disableCoreDumps()
+{
+ struct rlimit rlim;
+ rlim.rlim_cur = rlim.rlim_max = 0;
+ setrlimit(RLIMIT_CORE, &rlim);
+}
+
+void KPasswordDialog::virtual_hook( int id, void* data )
+{ KDialogBase::virtual_hook( id, data ); }
+
+void KPasswordDialog::enableOkBtn()
+{
+ if (m_Type == NewPassword) {
+ const bool match = strcmp(m_pEdit->password(), m_pEdit2->password()) == 0
+ && (d->allowEmptyPasswords || m_pEdit->password()[0]);
+
+ const QString pass(m_pEdit->password());
+
+ const int minPasswordLength = minimumPasswordLength();
+
+ if ((int) pass.length() < minPasswordLength) {
+ enableButtonOK(false);
+ } else {
+ enableButtonOK( match );
+ }
+
+ if ( match && d->allowEmptyPasswords && m_pEdit->password()[0] == 0 ) {
+ d->m_MatchLabel->setText( i18n("Password is empty") );
+ } else {
+ if ((int) pass.length() < minPasswordLength) {
+ d->m_MatchLabel->setText(i18n("Password must be at least 1 character long", "Password must be at least %n characters long", minPasswordLength));
+ } else {
+ d->m_MatchLabel->setText( match? i18n("Passwords match")
+ :i18n("Passwords do not match") );
+ }
+ }
+
+ // Password strength calculator
+ // Based on code in the Master Password dialog in Firefox
+ // (pref-masterpass.js)
+ // Original code triple-licensed under the MPL, GPL, and LGPL
+ // so is license-compatible with this file
+
+ const double lengthFactor = d->reasonablePasswordLength / 8.0;
+
+
+ int pwlength = (int) (pass.length() / lengthFactor);
+ if (pwlength > 5) pwlength = 5;
+
+ const QRegExp numRxp("[0-9]", true, false);
+ int numeric = (int) (pass.contains(numRxp) / lengthFactor);
+ if (numeric > 3) numeric = 3;
+
+ const QRegExp symbRxp("\\W", false, false);
+ int numsymbols = (int) (pass.contains(symbRxp) / lengthFactor);
+ if (numsymbols > 3) numsymbols = 3;
+
+ const QRegExp upperRxp("[A-Z]", true, false);
+ int upper = (int) (pass.contains(upperRxp) / lengthFactor);
+ if (upper > 3) upper = 3;
+
+ int pwstrength=((pwlength*10)-20) + (numeric*10) + (numsymbols*15) + (upper*10);
+
+ if ( pwstrength < 0 ) {
+ pwstrength = 0;
+ }
+
+ if ( pwstrength > 100 ) {
+ pwstrength = 100;
+ }
+ d->m_strengthBar->setProgress(pwstrength);
+
+ }
+}
+
+
+void KPasswordDialog::setAllowEmptyPasswords(bool allowed) {
+ d->allowEmptyPasswords = allowed;
+ enableOkBtn();
+}
+
+
+bool KPasswordDialog::allowEmptyPasswords() const {
+ return d->allowEmptyPasswords;
+}
+
+void KPasswordDialog::setMinimumPasswordLength(int minLength) {
+ d->minimumPasswordLength = minLength;
+ enableOkBtn();
+}
+
+int KPasswordDialog::minimumPasswordLength() const {
+ return d->minimumPasswordLength;
+}
+
+void KPasswordDialog::setMaximumPasswordLength(int maxLength) {
+
+ if (maxLength < 0) maxLength = 0;
+ if (maxLength >= KPasswordEdit::PassLen) maxLength = KPasswordEdit::PassLen - 1;
+
+ d->maximumPasswordLength = maxLength;
+
+ m_pEdit->setMaxPasswordLength(maxLength);
+ if (m_pEdit2) m_pEdit2->setMaxPasswordLength(maxLength);
+
+}
+
+int KPasswordDialog::maximumPasswordLength() const {
+ return d->maximumPasswordLength;
+}
+
+// reasonable password length code contributed by Steffen Mthing
+
+void KPasswordDialog::setReasonablePasswordLength(int reasonableLength) {
+
+ if (reasonableLength < 1) reasonableLength = 1;
+ if (reasonableLength >= maximumPasswordLength()) reasonableLength = maximumPasswordLength();
+
+ d->reasonablePasswordLength = reasonableLength;
+
+}
+
+int KPasswordDialog::reasonablePasswordLength() const {
+ return d->reasonablePasswordLength;
+}
+
+
+void KPasswordDialog::setPasswordStrengthWarningLevel(int warningLevel) {
+ if (warningLevel < 0) warningLevel = 0;
+ if (warningLevel > 99) warningLevel = 99;
+ d->passwordStrengthWarningLevel = warningLevel;
+}
+
+int KPasswordDialog::passwordStrengthWarningLevel() const {
+ return d->passwordStrengthWarningLevel;
+}
+
+#include "kpassdlg.moc"