kpassdlg.cpp
// 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"
KPasswordDialog::setAllowEmptyPasswords
void setAllowEmptyPasswords(bool allowed)
Allow empty passwords? - Default: false.
Definition: kpassdlg.cpp:660
KPasswordDialog::setPasswordStrengthWarningLevel
void setPasswordStrengthWarningLevel(int warningLevel)
Set the password strength level below which a warning is given Value is in the range 0 to 99...
Definition: kpassdlg.cpp:711
KPasswordDialog::prompt
QString prompt() const
Returns the password prompt.
Definition: kpassdlg.cpp:476
KPasswordDialog::NewPassword
The user is asked to enter a password and to confirm it a second time.
Definition: kpassdlg.h:186
KPasswordDialog::passwordStrengthWarningLevel
int passwordStrengthWarningLevel() const
Password strength level below which a warning is given.
Definition: kpassdlg.cpp:717
KPasswordDialog::~KPasswordDialog
virtual ~KPasswordDialog()
Destructs the password dialog.
Definition: kpassdlg.cpp:457
KIcon::NoGroup
KPasswordEdit::setMaxPasswordLength
void setMaxPasswordLength(int newLength)
Set the current maximum password length.
Definition: kpassdlg.cpp:282
KPasswordEdit
A safe password input widget.
Definition: kpassdlg.h:39
KPasswordDialog::setPrompt
void setPrompt(QString prompt)
Sets the password prompt.
Definition: kpassdlg.cpp:469
KPasswordEdit::password
const char * password() const
Returns the password.
Definition: kpassdlg.h:82
KDialogBase::enableButtonOK
void enableButtonOK(bool state)
Enable or disable (gray out) the OK button.
Definition: kdialogbase.cpp:848
KProgress
A progress indicator widget.
Definition: kprogress.h:46
KPasswordDialog::clearPassword
void clearPassword()
Clears the password input field.
Definition: kpassdlg.cpp:463
KGlobal::iconLoader
static KIconLoader * iconLoader()
KPasswordDialog::reasonablePasswordLength
int reasonablePasswordLength() const
Password length that is expected to be reasonably safe.
Definition: kpassdlg.cpp:706
KPasswordDialog::disableCoreDumps
static void disableCoreDumps()
Static helper function that disables core dumps.
Definition: kpassdlg.cpp:584
KPasswordDialog::setMinimumPasswordLength
void setMinimumPasswordLength(int minLength)
Minimum acceptable password length.
Definition: kpassdlg.cpp:670
KPasswordDialog::password
const char * password() const
Returns the password entered.
Definition: kpassdlg.h:334
klocale.h
KPasswordDialog::setReasonablePasswordLength
void setReasonablePasswordLength(int reasonableLength)
Password length that is expected to be reasonably safe.
Definition: kpassdlg.cpp:697
KDialogBase
A dialog base class with standard buttons and predefined layouts.
Definition: kdialogbase.h:191
KPasswordDialog::keep
bool keep() const
Returns true if the user wants to keep the password.
Definition: kpassdlg.h:346
KMessageBox::sorry
static void sorry(QWidget *parent, const QString &text, const QString &caption=QString::null, int options=Notify)
Display an "Sorry" dialog.
Definition: kmessagebox.cpp:825
KPasswordDialog::minimumPasswordLength
int minimumPasswordLength() const
Minimum acceptable password length.
Definition: kpassdlg.cpp:675
KPasswordEdit::maxPasswordLength
int maxPasswordLength() const
Returns the current maximum password length.
Definition: kpassdlg.cpp:295
KPasswordDialog::getNewPassword
static int getNewPassword(QCString &password, QString prompt)
Pops up the dialog, asks the user for a password and returns it.
Definition: kpassdlg.cpp:572
KPasswordEdit::erase
void erase()
Erases the current password.
Definition: kpassdlg.cpp:178
KIcon::SizeHuge
KConfigGroupSaver
KMessageBox::warningContinueCancel
static int warningContinueCancel(QWidget *parent, const QString &text, const QString &caption=QString::null, const KGuiItem &buttonContinue=KStdGuiItem::cont(), const QString &dontAskAgainName=QString::null, int options=Notify)
Display a "warning" dialog.
Definition: kmessagebox.cpp:585
KPasswordDialog::Password
The user is asked to enter a password.
Definition: kpassdlg.h:179
KPasswordDialog::KPasswordDialog
KPasswordDialog(Types type, bool enableKeep, int extraBttn, QWidget *parent=0, const char *name=0)
Constructs a password dialog.
Definition: kpassdlg.cpp:303
KPasswordDialog::allowEmptyPasswords
bool allowEmptyPasswords() const
Allow empty passwords?
Definition: kpassdlg.cpp:666
KPasswordDialog
A password input dialog.
Definition: kpassdlg.h:166
KPasswordEdit::~KPasswordEdit
~KPasswordEdit()
Destructs the widget.
Definition: kpassdlg.cpp:154
KConfig
KConfig::readEntry
QString readEntry(const QString &pKey, const QString &aDefault=QString::null) const
KDialogBase::setMainWidget
void setMainWidget(QWidget *widget)
Sets the main user definable widget.
Definition: kdialogbase.cpp:1431
KConfig::readBoolEntry
bool readBoolEntry(const QString &pKey, bool bDefault=false) const
KPasswordDialog::addLine
void addLine(QString key, QString value)
Adds a line of information to the dialog.
Definition: kpassdlg.cpp:484
KPasswordEdit::insert
virtual void insert(const QString &)
Reimplementation.
Definition: kpassdlg.cpp:161
KPasswordDialog::setMaximumPasswordLength
void setMaximumPasswordLength(int maxLength)
Maximum acceptable password length.
Definition: kpassdlg.cpp:679
KPasswordDialog::getPassword
static int getPassword(QCString &password, QString prompt, int *keep=0L)
Pops up the dialog, asks the user for a password, and returns it.
Definition: kpassdlg.cpp:555
KPasswordEdit::KPasswordEdit
KPasswordEdit(QWidget *parent=0, const char *name=0)
Constructs a password input widget using the user's global "echo mode" setting.
Definition: kpassdlg.cpp:105
KGlobal::config
static KConfig * config()
KPasswordDialog::checkPassword
virtual bool checkPassword(const char *)
Virtual function that can be overridden to provide password checking in derived classes.
Definition: kpassdlg.h:391
KPasswordDialog::maximumPasswordLength
int maximumPasswordLength() const
Maximum acceptable password length.
Definition: kpassdlg.cpp:691
KPasswordDialog::Types
Types
This enum distinguishes the two operation modes of this dialog:
Definition: kpassdlg.h:175

KDE Home | KDE Accessibility Home | Description of Access Keys