summaryrefslogtreecommitdiffabout
Side-by-side diff
Diffstat (more/less context) (show whitespace changes)
-rw-r--r--pwmanager/pwmanager/addentrywnd_emb.cpp20
-rw-r--r--pwmanager/pwmanager/addentrywnd_emb.h5
-rw-r--r--pwmanager/pwmanager/addentrywndimpl.cpp22
-rw-r--r--pwmanager/pwmanager/addentrywndimpl.h2
-rw-r--r--pwmanager/pwmanager/commentbox.cpp87
-rw-r--r--pwmanager/pwmanager/commentbox.h38
-rw-r--r--pwmanager/pwmanager/pwmanagerE.pro3
-rw-r--r--pwmanager/pwmanager/pwmdoc.cpp4
-rw-r--r--pwmanager/pwmanager/pwmprefs.cpp3
-rw-r--r--pwmanager/pwmanager/pwmprefs.h1
-rw-r--r--pwmanager/pwmanager/pwmviewstyle.cpp4
-rw-r--r--pwmanager/pwmanager/pwmviewstyle_1.cpp6
12 files changed, 131 insertions, 64 deletions
diff --git a/pwmanager/pwmanager/addentrywnd_emb.cpp b/pwmanager/pwmanager/addentrywnd_emb.cpp
index ed02e6d..dd09d13 100644
--- a/pwmanager/pwmanager/addentrywnd_emb.cpp
+++ b/pwmanager/pwmanager/addentrywnd_emb.cpp
@@ -1,213 +1,199 @@
/*
This file is part of PwManager/Platform independent.
Copyright (c) 2004 Ulf Schenk
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program 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 General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
As a special exception, permission is given to link this program
with any edition of Qt, and distribute the resulting executable,
without including the source code for Qt in the source distribution.
$Id$
*/
#include "addentrywnd_emb.h"
#include <qlayout.h>
#include <qlabel.h>
#include <qtabwidget.h>
#include <qgroupbox.h>
#include <klocale.h>
#include <kcombobox.h>
#include <klineedit.h>
#include <qpushbutton.h>
+#include <qmultilineedit.h>
/*
* Constructs a addEntryWnd as a child of 'parent', with the
* name 'name' and widget flags set to 'f'.
*
* The dialog will by default be modeless, unless you set 'modal' to
* TRUE to construct a modal dialog.
*/
addEntryWnd::addEntryWnd( QWidget* parent, const char* name)
: KDialogBase( KDialogBase::Plain, i18n( "edit/add a password entry" ),
KDialogBase::Ok | KDialogBase::Cancel,
KDialogBase::Ok, parent, name, true )
{
QWidget *page = plainPage();
QVBoxLayout *pageLayout = new QVBoxLayout( page );
QTabWidget* mTabWidget = new QTabWidget( page );
pageLayout->addWidget( mTabWidget );
////////////////////////////////////////////////////////////////////
// This is the Password tab
QWidget *tab1 = new QWidget( mTabWidget );
QGridLayout *layout = new QGridLayout( tab1, 3, 1 );
layout->setMargin( KDialogBase::marginHint() );
layout->setSpacing( KDialogBase::spacingHint() );
int i = 0;
descLineEdit = new KLineEdit( tab1, "descLineEdit" );
QLabel* label = new QLabel( descLineEdit, i18n("Description:"), tab1 );
layout->addWidget( label, i, 0 );
layout->addWidget( descLineEdit, i, 1 );
i++;
categoryComboBox = new KComboBox( tab1 );
label = new QLabel( categoryComboBox, i18n("Category:"), tab1 );
layout->addWidget( label, i, 0 );
layout->addWidget( categoryComboBox, i, 1 );
i++;
categoryComboBox->setEditable( TRUE );
categoryComboBox->setSizeLimit( 100 );
categoryComboBox->setAutoCompletion( TRUE );
categoryComboBox->setDuplicatesEnabled( FALSE );
usernameLineEdit = new KLineEdit( tab1, "usernameLineEdit" );
label = new QLabel( usernameLineEdit, i18n("Username:"), tab1 );
layout->addWidget( label, i, 0 );
layout->addWidget( usernameLineEdit, i, 1 );
i++;
pwLineEdit = new KLineEdit( tab1, "pwLineEdit" );
pwLineEdit->setEchoMode( QLineEdit::Password );
label = new QLabel( pwLineEdit, i18n("Password:"), tab1 );
layout->addWidget( label, i, 0 );
layout->addWidget( pwLineEdit, i, 1 );
i++;
revealButton = new QPushButton( i18n("&Reveal"), tab1, "revealButton" );
revealButton->setToggleButton( TRUE );
layout->addWidget( revealButton, i, 0 );
generateButton = new QPushButton( i18n("&Generate"), tab1, "generateButton" );
layout->addWidget( generateButton, i, 1 );
i++;
urlLineEdit = new KLineEdit( tab1, "urlLineEdit" );
label = new QLabel( urlLineEdit, i18n("URL:"), tab1 );
layout->addWidget( label, i, 0 );
layout->addWidget( urlLineEdit, i, 1 );
i++;
mTabWidget->addTab( tab1, i18n( "&Password" ) );
////////////////////////////////////////////////////////////////////
// This is the Comment tab
QWidget *tab2 = new QWidget( mTabWidget );
layout = new QGridLayout( tab2, 3, 1 );
layout->setMargin( KDialogBase::marginHintSmall() );
layout->setSpacing( KDialogBase::spacingHintSmall() );
i = 0;
-
-
- groupBox1 = new QGroupBox( tab2, "groupBox1" );
- commentDummy = new QLabel( groupBox1, "commentDummy" );
- commentDummy->setText( QString::null );
-
- groupBox1->setTitle( i18n( "Comment:" ) );
-
- layout->addMultiCellWidget( groupBox1, i, i, 0, 1 );
- i++;
-
-
- advancedCommentButton = new QPushButton( i18n("advanced comment"), groupBox1, "advancedCommentButton" );
- advancedCommentButton->setToggleButton( FALSE );
- layout->addMultiCellWidget( advancedCommentButton, i, i, 0, 1 );
+ commentTextEdit = new QMultiLineEdit(tab2);
+ layout->addMultiCellWidget( commentTextEdit, i, i, 0, 0 );
i++;
mTabWidget->addTab( tab2, i18n( "&Comments" ) );
////////////////////////////////////////////////////////////////////
// This is the Launcher tab
QWidget *tab3 = new QWidget( mTabWidget );
layout = new QGridLayout( tab3, 3, 1 );
layout->setMargin( KDialogBase::marginHintSmall() );
layout->setSpacing( KDialogBase::spacingHintSmall() );
i = 0;
launcherLineEdit = new KLineEdit( tab3, "launcherLineEdit" );
label = new QLabel( launcherLineEdit, i18n("Launcher:"), tab3 );
QLabel* label1 = new QLabel( launcherLineEdit, i18n("$d = Description"), tab3 );
QLabel* label2 = new QLabel( launcherLineEdit, i18n("$n = Username"), tab3 );
QLabel* label3 = new QLabel( launcherLineEdit, i18n("$c = Comment"), tab3 );
QLabel* label4 = new QLabel( launcherLineEdit, i18n("$u = URL"), tab3 );
QLabel* label5 = new QLabel( launcherLineEdit, i18n("$p = Password"), tab3 );
label = new QLabel( launcherLineEdit, i18n("Launcher:"), tab3 );
layout->addWidget( label1, i, 0 );
layout->addWidget( label2, i, 1 );
i++;
layout->addWidget( label3, i, 0 );
layout->addWidget( label4, i, 1 );
i++;
layout->addWidget( label5, i, 0 );
i++;
layout->addWidget( label, i, 0 );
layout->addWidget( launcherLineEdit, i, 1 );
i++;
mTabWidget->addTab( tab3, i18n( "&Launcher" ) );
// signals and slots connections
connect( generateButton, SIGNAL( clicked() ), this, SLOT( generateButton_slot() ) );
connect( revealButton, SIGNAL( toggled(bool) ), this, SLOT( revealButton_slot() ) );
- connect( advancedCommentButton, SIGNAL( toggled(bool) ), this, SLOT( advancedCommentButton_slot(bool) ) );
-
}
/*
* Destroys the object and frees any allocated resources
*/
addEntryWnd::~addEntryWnd()
{
// no need to delete child widgets, Qt does it all for us
}
void addEntryWnd::slotOk()
{
qWarning( "addEntryWnd::slotOk(): Not implemented yet" );
}
void addEntryWnd::revealButton_slot()
{
qWarning( "addEntryWnd::revealButton_slot(): Not implemented yet" );
}
void addEntryWnd::generateButton_slot()
{
qWarning( "addEntryWnd::generateButton_slot(): Not implemented yet" );
}
void addEntryWnd::advancedCommentButton_slot(bool)
{
qWarning( "addEntryWnd::advancedCommentButton_slot(bool): Not implemented yet" );
}
diff --git a/pwmanager/pwmanager/addentrywnd_emb.h b/pwmanager/pwmanager/addentrywnd_emb.h
index e368721..83761dc 100644
--- a/pwmanager/pwmanager/addentrywnd_emb.h
+++ b/pwmanager/pwmanager/addentrywnd_emb.h
@@ -1,73 +1,72 @@
/*
This file is part of PwManager/Platform independent.
Copyright (c) 2004 Ulf Schenk
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program 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 General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
As a special exception, permission is given to link this program
with any edition of Qt, and distribute the resulting executable,
without including the source code for Qt in the source distribution.
$Id$
*/
#ifndef ADDENTRYWND_EMB_H
#define ADDENTRYWND_EMB_H
#include <qvariant.h>
#include <kdialogbase.h>
class QVBoxLayout;
class QHBoxLayout;
class QGridLayout;
class QSpacerItem;
class KLineEdit;
class QPushButton;
class KComboBox;
class QLabel;
class QGroupBox;
+class QMultiLineEdit;
class addEntryWnd : public KDialogBase
{
Q_OBJECT
public:
addEntryWnd( QWidget* parent = 0, const char* name = 0);
~addEntryWnd();
KLineEdit* launcherLineEdit;
QPushButton* generateButton;
KLineEdit* descLineEdit;
KComboBox* categoryComboBox;
KLineEdit* usernameLineEdit;
KLineEdit* pwLineEdit;
KLineEdit* urlLineEdit;
QPushButton* revealButton;
- QGroupBox* groupBox1;
- QLabel* commentDummy;
- QPushButton* advancedCommentButton;
+ QMultiLineEdit* commentTextEdit;
public slots:
virtual void revealButton_slot();
virtual void generateButton_slot();
virtual void advancedCommentButton_slot(bool on);
protected slots:
virtual void slotOk();
};
#endif // ADDENTRYWND_H
diff --git a/pwmanager/pwmanager/addentrywndimpl.cpp b/pwmanager/pwmanager/addentrywndimpl.cpp
index ffd301f..d47f32c 100644
--- a/pwmanager/pwmanager/addentrywndimpl.cpp
+++ b/pwmanager/pwmanager/addentrywndimpl.cpp
@@ -1,203 +1,217 @@
/***************************************************************************
* *
* copyright (C) 2003, 2004 by Michael Buesch *
* email: mbuesch@freenet.de *
* *
* Many very good improvements and the original implementations of *
* them came from Matt Scifo <mscifo@o1.com> *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License version 2 *
* as published by the Free Software Foundation. *
* *
***************************************************************************/
/***************************************************************************
* copyright (C) 2004 by Ulf Schenk
* This file is originaly based on version 1.0.1 of pwmanager
* and was modified to run on embedded devices that run microkde
*
* $Id$
**************************************************************************/
#include "addentrywndimpl.h"
#include "pwmexception.h"
#include "pwgenwndimpl.h"
#ifndef PWM_EMBEDDED
#include "advcommeditimpl.h"
#endif
#include "htmlgen.h"
#include <kmessagebox.h>
#include <klocale.h>
#include <qpushbutton.h>
#include <qlabel.h>
+#include <qlayout.h>
+
#ifndef PWM_EMBEDDED
AddEntryWndImpl::AddEntryWndImpl()
: addEntryWnd( 0, "AddEntryWndImpl", TRUE)
#else
AddEntryWndImpl::AddEntryWndImpl( QWidget* parent, const char* name)
: addEntryWnd( parent, name)
#endif
{
+#ifndef PWM_EMBEDDED
editAdvCommentButton = 0;
commentTextEdit = 0;
+#endif
switchComment(false);
pwGen = new PwGenWndImpl(this);
}
AddEntryWndImpl::~AddEntryWndImpl()
{
+#ifndef PWM_EMBEDDED
delete_ifnot_null(editAdvCommentButton);
delete_ifnot_null(commentTextEdit);
+#endif
delete pwGen;
}
#ifdef PWM_EMBEDDED
void AddEntryWndImpl::slotOk()
{
slotApply();
if (pwLineEdit->text().isEmpty()) {
KMessageBox::error(this,
i18n("Sorry, you haven't set a password."),
i18n("no password"));
return;
}
if (descLineEdit->text().isEmpty()) {
KMessageBox::error(this,
i18n("You haven't set a \"Description\"."),
i18n("Description not set"));
return;
}
KDialogBase::slotOk();
}
#else
void AddEntryWndImpl::okButton_slot()
{
if (pwLineEdit->text().isEmpty()) {
KMessageBox::error(this,
i18n("Sorry, you haven't set a password."),
i18n("no password"));
return;
}
if (descLineEdit->text().isEmpty()) {
KMessageBox::error(this,
i18n
("You haven't set a \"Description\"."),
i18n("Description not set"));
return;
}
done(1);
}
void AddEntryWndImpl::cancelButton_slot()
{
done(2);
}
#endif
void AddEntryWndImpl::setCurrCategory(const QString &cat)
{
int i, count = categoryComboBox->count();
for (i = 0; i < count; ++i) {
if (categoryComboBox->text(i) == cat) {
categoryComboBox->setCurrentItem(i);
return;
}
}
BUG();
}
void AddEntryWndImpl::revealButton_slot()
{
if (revealButton->isOn()) {
pwLineEdit->setEchoMode(QLineEdit::Normal);
} else {
pwLineEdit->setEchoMode(QLineEdit::Password);
}
}
void AddEntryWndImpl::generateButton_slot()
{
if (!pwGen->exec())
return;
setPassword(pwGen->getPassword());
}
QString AddEntryWndImpl::getComment()
{
+#ifndef PWM_EMBEDDED
if (isAdvancedComment()) {
return advCommentDta;
}
+#endif
return commentTextEdit->text();
}
void AddEntryWndImpl::setComment(const QString &comm)
{
+#ifndef PWM_EMBEDDED
if (HtmlGen::isHtml(comm)) {
advancedCommentButton->setOn(true);
advCommentDta = comm;
} else {
advancedCommentButton->setOn(false);
commentTextEdit->setText(comm);
}
+#else
+ commentTextEdit->setText(comm);
+#endif
}
void AddEntryWndImpl::advancedCommentButton_slot(bool on)
{
+#ifndef PWM_EMBEDDED
switchComment(on);
+#endif
}
void AddEntryWndImpl::switchComment(bool toAdvanced)
{
+#ifndef PWM_EMBEDDED
+
useAdvComment = toAdvanced;
if (toAdvanced) {
if (commentTextEdit) {
savedCommentText = commentTextEdit->text();
delete_and_null(commentTextEdit);
}
if (editAdvCommentButton)
return;
editAdvCommentButton = new QPushButton(i18n("Edit advanced comment..."),
commentDummy);
editAdvCommentButton->resize(commentDummy->size().width(), 50);
connect(editAdvCommentButton, SIGNAL(clicked()),
this, SLOT(editAdvCommentButton_slot()));
editAdvCommentButton->show();
} else {
delete_ifnot_null(editAdvCommentButton);
if (commentTextEdit)
return;
-#ifndef PWM_EMBEDDED
+
commentTextEdit = new QTextEdit(commentDummy);
commentTextEdit->setTextFormat(Qt::PlainText);
-#else
- commentTextEdit = new QMultiLineEdit(commentDummy);
-#endif
commentTextEdit->resize(commentDummy->size());
commentTextEdit->setText(savedCommentText);
commentTextEdit->show();
}
+#endif
}
void AddEntryWndImpl::editAdvCommentButton_slot()
{
#ifndef PWM_EMBEDDED
AdvCommEditImpl editor(this);
editor.setHtmlDta(advCommentDta);
if (editor.exec())
return;
advCommentDta = editor.getHtmlDta();
#endif
}
#ifndef PWM_EMBEDDED
#include "addentrywndimpl.moc"
#endif
diff --git a/pwmanager/pwmanager/addentrywndimpl.h b/pwmanager/pwmanager/addentrywndimpl.h
index 622e9d2..ce9a594 100644
--- a/pwmanager/pwmanager/addentrywndimpl.h
+++ b/pwmanager/pwmanager/addentrywndimpl.h
@@ -1,127 +1,127 @@
/***************************************************************************
* *
* copyright (C) 2003, 2004 by Michael Buesch *
* email: mbuesch@freenet.de *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License version 2 *
* as published by the Free Software Foundation. *
* *
***************************************************************************/
/***************************************************************************
* copyright (C) 2004 by Ulf Schenk
* This file is originaly based on version 1.0.1 of pwmanager
* and was modified to run on embedded devices that run microkde
*
* $Id$
**************************************************************************/
#ifndef __ADDENTRYWNDIMPL_H
#define __ADDENTRYWNDIMPL_H
#ifndef PWM_EMBEDDED
#include <qlineedit.h>
#include <qtextedit.h>
#include <qcombobox.h>
#include "addentrywnd.h"
#else
#include <klineedit.h>
#include <kcombobox.h>
#include <qmultilineedit.h>
#include "addentrywnd_emb.h"
#endif
#include <qpushbutton.h>
class PwGenWndImpl;
/** "add/edit" Window */
class AddEntryWndImpl : public addEntryWnd
{
Q_OBJECT
public:
#ifndef PWM_EMBEDDED
AddEntryWndImpl();
#else
AddEntryWndImpl( QWidget* parent = 0, const char* name = 0);
#endif
~AddEntryWndImpl();
/* get... functions */
QString getDescription()
{ return descLineEdit->text(); }
QString getCategory()
{ return categoryComboBox->currentText(); }
QString getUsername()
{ return usernameLineEdit->text(); }
QString getPassword()
{ return pwLineEdit->text(); }
QString getUrl()
{ return urlLineEdit->text(); }
QString getLauncher()
{ return launcherLineEdit->text(); }
QString getComment();
/* set... functions */
void setDescription(const QString &desc)
{ descLineEdit->setText(desc); }
void setCurrCategory(const QString &cat);
void addCategory(const QString &cat)
{ categoryComboBox->insertItem(cat); }
void setUsername(const QString &name)
{ usernameLineEdit->setText(name); }
void setPassword(const QString &pw)
{ pwLineEdit->setText(pw); }
void setUrl(const QString &url)
{ urlLineEdit->setText(url); }
void setLauncher(const QString launcher)
{ launcherLineEdit->setText(launcher); }
void setComment(const QString &comm);
/** are we using an advanced comment */
bool isAdvancedComment()
{ return useAdvComment; }
public slots:
#ifndef PWM_EMBEDDED
//MOC_SKIP_BEGIN
/** OK button pressed */
void okButton_slot();
/** cancel button pressed */
void cancelButton_slot();
//MOC_SKIP_END
#else
virtual void slotOk();
#endif
/** Reveal button pressed */
void revealButton_slot();
/** Generate button pressed */
void generateButton_slot();
/** advanced comment button pressed */
void advancedCommentButton_slot(bool on);
/** edit advanced comment button pressed */
void editAdvCommentButton_slot();
protected:
void switchComment(bool toAdvanced);
protected:
QPushButton *editAdvCommentButton;
#ifndef PWM_EMBEDDED
QTextEdit *commentTextEdit;
#else
- QMultiLineEdit * commentTextEdit;
+ //nothing here
#endif
/** saved data from normal comment text edit box */
QString savedCommentText;
/** use an advanced comment? */
bool useAdvComment;
/** data of advanced comment (if available) */
QString advCommentDta;
/** password generation object */
PwGenWndImpl *pwGen;
};
#endif
diff --git a/pwmanager/pwmanager/commentbox.cpp b/pwmanager/pwmanager/commentbox.cpp
index 280b139..4a76f36 100644
--- a/pwmanager/pwmanager/commentbox.cpp
+++ b/pwmanager/pwmanager/commentbox.cpp
@@ -1,238 +1,281 @@
/***************************************************************************
* *
* copyright (C) 2004 by Michael Buesch *
* email: mbuesch@freenet.de *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License version 2 *
* as published by the Free Software Foundation. *
* *
***************************************************************************/
/***************************************************************************
* copyright (C) 2004 by Ulf Schenk
* This file is originaly based on version 1.0.1 of pwmanager
* and was modified to run on embedded devices that run microkde
*
* $Id$
**************************************************************************/
#include "commentbox.h"
#include "pwmexception.h"
#include "htmlgen.h"
#include <klocale.h>
#ifndef PWM_EMBEDDED
#include <khtml_part.h>
#include <khtmlview.h>
#include <qtextedit.h>
#else
#include <qmultilineedit.h>
#endif
+
+
+#ifndef PWM_EMBEDDED
CommentBox::CommentBox(QWidget *_parentWidget)
{
PWM_ASSERT(_parentWidget);
parentWidget = _parentWidget;
textDta = 0;
-#ifndef PWM_EMBEDDED
htmlDta = 0;
-#endif
mode = mode_notSet;
}
CommentBox::~CommentBox()
{
clearText();
clearHtml();
}
void CommentBox::clear()
{
clearText();
clearHtml();
mode = mode_notSet;
+ this->hide();
}
void CommentBox::clearText()
{
delete_ifnot_null(textDta);
}
void CommentBox::clearHtml()
{
-#ifndef PWM_EMBEDDED
delete_ifnot_null(htmlDta);
-#endif
}
void CommentBox::setText(const QString &text)
{
switchTo(mode_text);
PWM_ASSERT(textDta);
textDta->setText(i18n("Comment") + ": " + text);
if (!textDta->isVisible())
textDta->show();
}
bool CommentBox::getText(QString *text)
{
if (mode != mode_text)
return false;
PWM_ASSERT(text);
if (!textDta) {
*text = "";
return true;
}
*text = textDta->text();
return true;
}
void CommentBox::setHtml(QString code)
{
-#ifndef PWM_EMBEDDED
switchTo(mode_html);
PWM_ASSERT(htmlDta);
if (!HtmlGen::replaceSSDummy(&code))
printWarn("CommentBox::setHtml(): replaceSSDummy() failed!");
htmlDta->begin();
htmlDta->write(code);
htmlDta->end();
htmlDta->show();
-#endif
}
void CommentBox::setContent(const QString &dta)
{
// if there's no data, hide the comment-box
if (dta.isEmpty()) {
clear();
return;
}
-#ifndef PWM_EMBEDDED
if (HtmlGen::isHtml(dta)) {
setHtml(dta);
return;
}
-#endif
// we assume it's plain text
setText(dta);
}
void CommentBox::switchTo(commentBoxMode newMode)
{
if (newMode == mode)
return;
// cleanup old mode
switch (mode) {
case mode_text:
clearText();
break;
case mode_html:
clearHtml();
break;
default:
break;
}
// setup new mode
switch (newMode) {
case mode_text:
-#ifndef PWM_EMBEDDED
textDta = new QTextEdit(parentWidget);
textDta->setTextFormat(Qt::PlainText);
-#else
- textDta = new QMultiLineEdit(parentWidget);
-#endif
textDta->setReadOnly(true);
textDta->show();
break;
case mode_html:
-#ifndef PWM_EMBEDDED
htmlDta = new KHTMLPart(parentWidget, 0,
parentWidget);
htmlDta->show();
-#endif
break;
default:
BUG();
break;
}
mode = newMode;
}
void CommentBox::show()
{
switch (mode) {
case mode_text:
PWM_ASSERT(textDta);
textDta->show();
break;
case mode_html:
-#ifndef PWM_EMBEDDED
PWM_ASSERT(htmlDta);
htmlDta->show();
-#endif
break;
default:
break;
}
+
}
void CommentBox::hide()
{
switch (mode) {
case mode_text:
PWM_ASSERT(textDta);
textDta->hide();
break;
case mode_html:
-#ifndef PWM_EMBEDDED
PWM_ASSERT(htmlDta);
htmlDta->hide();
-#endif
break;
default:
break;
}
}
void CommentBox::resize(const QSize &size)
{
switch (mode) {
case mode_text:
PWM_ASSERT(textDta);
textDta->resize(size);
break;
case mode_html:
-#ifndef PWM_EMBEDDED
PWM_ASSERT(htmlDta);
htmlDta->view()->resize(size);
-#endif
break;
default:
break;
}
+
}
QSize CommentBox::size()
{
switch (mode) {
case mode_text:
PWM_ASSERT(textDta);
return textDta->size();
break;
case mode_html:
-#ifndef PWM_EMBEDDED
PWM_ASSERT(htmlDta);
return htmlDta->view()->size();
-#endif
break;
default:
break;
}
+
return QSize();
}
+
+
+////////////////////////////////////////////////////////////////////////
+
+#else
+
+CommentBox::CommentBox(QWidget *_parentWidget)
+ : QMultiLineEdit(_parentWidget)
+
+{
+ this->setReadOnly(true);
+}
+
+CommentBox::~CommentBox()
+{
+}
+
+void CommentBox::clear()
+{
+ this->hide();
+}
+
+
+void CommentBox::setText(const QString &text)
+{
+ QMultiLineEdit::setText(i18n("Comment") + ": " + text);
+ if (!this->isVisible())
+ this->show();
+}
+
+bool CommentBox::getText(QString *text)
+{
+ *text = this->text();
+ return true;
+}
+
+void CommentBox::setContent(const QString &dta)
+{
+ // if there's no data, hide the comment-box
+ if (dta.isEmpty()) {
+ clear();
+ return;
+ }
+
+ // we assume it's plain text
+ setText(dta);
+}
+
+#endif
+
+
+
+
+
+
+
+
+
diff --git a/pwmanager/pwmanager/commentbox.h b/pwmanager/pwmanager/commentbox.h
index a220acd..352867c 100644
--- a/pwmanager/pwmanager/commentbox.h
+++ b/pwmanager/pwmanager/commentbox.h
@@ -1,100 +1,124 @@
/***************************************************************************
* *
* copyright (C) 2004 by Michael Buesch *
* email: mbuesch@freenet.de *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License version 2 *
* as published by the Free Software Foundation. *
* *
***************************************************************************/
/***************************************************************************
* copyright (C) 2004 by Ulf Schenk
* This file is originaly based on version 1.0.1 of pwmanager
* and was modified to run on embedded devices that run microkde
*
* $Id$
**************************************************************************/
#ifndef COMMENTBOX_H
#define COMMENTBOX_H
#include <qstring.h>
#include <qsize.h>
-
class QWidget;
class QTextEdit;
-class QMultiLineEdit;
class KHTMLPart;
-/** Implementation of the advanced HTML comment box */
+#ifndef PWM_EMBEDDED
+
class CommentBox
{
protected:
enum commentBoxMode
{
mode_notSet = 0,
mode_text,
mode_html
};
public:
CommentBox(QWidget *_parentWidget);
~CommentBox();
/** clear all data in the comment box */
void clear();
/** show the comment box */
void show();
/** hide the comment box */
void hide();
/** resize the comment box */
void resize(const QSize &size);
void resize(int w, int h)
{ resize(QSize(w, h)); }
/** get the size of the comment box */
QSize size();
/** if neccessary switch to text-mode and
* insert this text into the comment box
*/
void setText(const QString &text);
/** get the text of the comment box.
* If it's not in text-mode it returns false
*/
bool getText(QString *text);
/** if neccessary switch to HTML-mode and
* insert this html code into the comment box
*/
void setHtml(QString code);
/** checks "dta" for its type, sets the correct
* mode and writes "dta" to the comment box
*/
void setContent(const QString &dta);
protected:
/** switch the current mode */
void switchTo(commentBoxMode newMode);
/** clear all text data */
void clearText();
/** clear all HTML data */
void clearHtml();
protected:
/** parent widget for this comment box */
QWidget *parentWidget;
/** current comment box usage type */
commentBoxMode mode;
-#ifndef PWM_EMBEDDED
/** if the comment box is a normal textbox, data is stored here */
QTextEdit *textDta;
/** if the comment box is a HTML box, data is stored here */
KHTMLPart *htmlDta;
+};
+
#else
- /** if the comment box is a normal textbox, data is stored here */
- QMultiLineEdit *textDta;
-#endif
+#include <qmultilineedit.h>
+/** Implementation of the advanced HTML comment box */
+//US ENH: CommentBox must be derived from QWidget, to allow the splitter to set a initial size
+// without conflicting with the two display modes
+
+class CommentBox : public QMultiLineEdit
+{
+public:
+ CommentBox(QWidget *_parentWidget);
+ ~CommentBox();
+
+ /** clear all data in the comment box */
+ void clear();
+ /** if neccessary switch to text-mode and
+ * insert this text into the comment box
+ */
+ void setText(const QString &text);
+ /** get the text of the comment box.
+ * If it's not in text-mode it returns false
+ */
+ bool getText(QString *text);
+ /** if neccessary switch to HTML-mode and
+ * insert this html code into the comment box
+ */
+ void setContent(const QString &dta);
};
+#endif
+
#endif
diff --git a/pwmanager/pwmanager/pwmanagerE.pro b/pwmanager/pwmanager/pwmanagerE.pro
index 3bcf679..4e482ca 100644
--- a/pwmanager/pwmanager/pwmanagerE.pro
+++ b/pwmanager/pwmanager/pwmanagerE.pro
@@ -1,153 +1,154 @@
TEMPLATE = app
CONFIG += qt warn_on
TARGET = pwmpi
OBJECTS_DIR = obj/$(PLATFORM)
MOC_DIR = moc/$(PLATFORM)
DESTDIR=$(QPEDIR)/bin
INCLUDEPATH += . ../../qtcompat ../../qtcompat/xml ../../libkdepim ../../microkde ../../microkde/kdecore ../../microkde/kdeui ../../microkde/kutils $(QPEDIR)/include
-DEFINES += PWM_EMBEDDED PWM_DEBUG
+DEFINES += PWM_EMBEDDED CONFIG_DEBUG
+
LIBS += -lmicrokde
LIBS += -lmicroqtcompat
LIBS += -lmicrokdepim
LIBS += -L$(QPEDIR)/lib
LIBS += -lqpe
LIBS += -lbz2
LIBS += $(QTOPIALIB)
#INTERFACES = \
#addentrywnd.ui \
#configwnd.ui \
#findwnd.ui \
#getmasterpwwnd.ui \
#pwgenwnd.ui \
#setmasterpwwnd.ui \
#subtbledit.ui
#INTERFACES = \
#subtbledit.ui \
#HEADERS = \
#configuration_31compat.h \
#configuration.h \
#configwnd.h \
#configwndimpl.h \
#selftest.h
#subtbledit.h \
#subtbleditimpl.h \
HEADERS = \
addentrywnd_emb.h \
addentrywndimpl.h \
base64.h \
binentrygen.h \
blowfish.h \
commentbox.h \
compiler.h \
compressbzip2.h \
compressgzip.h \
findwnd_emb.h \
findwndimpl.h \
genpasswd.h \
getkeycardwnd.h \
getmasterpwwnd_emb.h \
getmasterpwwndimpl.h \
globalstuff.h \
gpasmanfile.h \
htmlgen.h \
htmlparse.h \
ipc.h \
listobjselectwnd.h \
listviewpwm.h \
printtext.h \
pwgenwnd_emb.h \
pwgenwndimpl.h \
pwmdoc.h \
pwmdocui.h \
pwmexception.h \
pwm.h \
pwminit.h \
pwmprefs.h \
pwmprint.h \
pwmtray.h \
pwmview.h \
pwmviewstyle_0.h \
pwmviewstyle_1.h \
pwmviewstyle.h \
randomizer.h \
rc2.h \
rencatwnd.h \
serializer.h \
setmasterpwwnd_emb.h \
setmasterpwwndimpl.h \
sha1.h \
waitwnd.h \
kcmconfigs/kcmpwmconfig.h \
kcmconfigs/pwmconfigwidget.h \
#sources that need not be build
#SOURCES = \
#advcommeditimpl.cpp \
#configuration.cpp \
#configwnd.cpp \
#configwndimpl.cpp \
#configuration_31compat.cpp \
#htmlparse.cpp \
#printtext.cpp \
#selftest.cpp \
#pwmprint.cpp \
#spinforsignal.cpp
#subtbledit.cpp \
#subtbleditimpl.cpp \
SOURCES = \
addentrywnd_emb.cpp \
addentrywndimpl.cpp \
base64.cpp \
binentrygen.cpp \
blowfish.cpp \
commentbox.cpp \
compressbzip2.cpp \
compressgzip.cpp \
findwnd_emb.cpp \
findwndimpl.cpp \
genpasswd.cpp \
getkeycardwnd.cpp \
getmasterpwwnd_emb.cpp \
getmasterpwwndimpl.cpp \
globalstuff.cpp \
gpasmanfile.cpp \
htmlgen.cpp \
ipc.cpp \
listobjselectwnd.cpp \
listviewpwm.cpp \
main.cpp \
pwgenwnd_emb.cpp \
pwgenwndimpl.cpp \
pwm.cpp \
pwmdoc.cpp \
pwmdocui.cpp \
pwmexception.cpp \
pwminit.cpp \
pwmprefs.cpp \
pwmtray.cpp \
pwmview.cpp \
pwmviewstyle_0.cpp \
pwmviewstyle_1.cpp \
pwmviewstyle.cpp \
randomizer.cpp \
rc2.cpp \
rencatwnd.cpp \
serializer.cpp \
setmasterpwwnd_emb.cpp \
setmasterpwwndimpl.cpp \
sha1.cpp \
waitwnd.cpp \
kcmconfigs/kcmpwmconfig.cpp \
kcmconfigs/pwmconfigwidget.cpp \
diff --git a/pwmanager/pwmanager/pwmdoc.cpp b/pwmanager/pwmanager/pwmdoc.cpp
index c167c2c..1b6d36f 100644
--- a/pwmanager/pwmanager/pwmdoc.cpp
+++ b/pwmanager/pwmanager/pwmdoc.cpp
@@ -1,560 +1,558 @@
/***************************************************************************
* *
* copyright (C) 2003, 2004 by Michael Buesch *
* email: mbuesch@freenet.de *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License version 2 *
* as published by the Free Software Foundation. *
* *
***************************************************************************/
/***************************************************************************
* copyright (C) 2004 by Ulf Schenk
* This file is originaly based on version 2.0 of pwmanager
* and was modified to run on embedded devices that run microkde
*
* $Id$
**************************************************************************/
#include "pwmdoc.h"
#include "pwmview.h"
#include "blowfish.h"
#include "sha1.h"
#include "globalstuff.h"
#include "gpasmanfile.h"
#include "serializer.h"
#include "compressgzip.h"
#include "compressbzip2.h"
#include "randomizer.h"
#include "pwminit.h"
#ifndef PWM_EMBEDDED
//US #include "libgryptif.h"
#else
#include "pwmprefs.h"
#include "kglobal.h"
#endif
#ifdef CONFIG_KWALLETIF
# include "kwalletemu.h"
#endif // CONFIG_KWALLETIF
#include <qdatetime.h>
#include <qsize.h>
#include <qfileinfo.h>
#include <qfile.h>
-#define __USE_GNU
-#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <string.h>
//US#include <iostream>
#include <algorithm>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <stdint.h>
//TODO: reset to its normal value.
#define META_CHECK_TIMER_INTERVAL 10/*300*/ /* sek */
using namespace std;
void PwMDocList::add(PwMDoc *doc, const string &id)
{
#ifdef PWM_DEBUG
// check for existance of object in debug mode only.
vector<listItem>::iterator begin = docList.begin(),
end = docList.end(),
i = begin;
while (i != end) {
if (i->doc == doc) {
BUG();
return;
}
++i;
}
#endif
listItem newItem;
newItem.doc = doc;
newItem.docId = id;
docList.push_back(newItem);
}
void PwMDocList::edit(PwMDoc *doc, const string &newId)
{
vector<listItem>::iterator begin = docList.begin(),
end = docList.end(),
i = begin;
while (i != end) {
if (i->doc == doc) {
i->docId = newId;
return;
}
++i;
}
}
void PwMDocList::del(PwMDoc *doc)
{
vector<listItem>::iterator begin = docList.begin(),
end = docList.end(),
i = begin;
while (i != end) {
if (i->doc == doc) {
docList.erase(i);
return;
}
++i;
}
}
bool PwMDocList::find(const string &id, listItem *ret)
{
vector<listItem>::iterator begin = docList.begin(),
end = docList.end(),
i = begin;
while (i != end) {
if (i->docId == id) {
if (ret)
*ret = *i;
return true;
}
++i;
}
return false;
}
DocTimer::DocTimer(PwMDoc *_doc)
: doc (_doc)
, mpwLock (0)
, autoLockLock (0)
, metaCheckLock (0)
{
mpwTimer = new QTimer;
autoLockTimer = new QTimer;
metaCheckTimer = new QTimer;
connect(mpwTimer, SIGNAL(timeout()),
this, SLOT(mpwTimeout()));
connect(autoLockTimer, SIGNAL(timeout()),
this, SLOT(autoLockTimeout()));
connect(metaCheckTimer, SIGNAL(timeout()),
this, SLOT(metaCheckTimeout()));
}
DocTimer::~DocTimer()
{
delete mpwTimer;
delete autoLockTimer;
delete metaCheckTimer;
}
void DocTimer::start(TimerIDs timer)
{
switch (timer) {
case id_mpwTimer:
if (mpwTimer->isActive())
mpwTimer->stop();
doc->setDocStatFlag(DOC_STAT_UNLOCK_WITHOUT_PW);
mpwTimer->start(conf()->confGlobPwTimeout() * 1000, true);
break;
case id_autoLockTimer:
if (autoLockTimer->isActive())
autoLockTimer->stop();
if (conf()->confGlobLockTimeout() > 0)
autoLockTimer->start(conf()->confGlobLockTimeout() * 1000, true);
break;
case id_metaCheckTimer:
if (metaCheckTimer->isActive())
metaCheckTimer->stop();
metaCheckTimer->start(META_CHECK_TIMER_INTERVAL * 1000, true);
break;
}
}
void DocTimer::stop(TimerIDs timer)
{
switch (timer) {
case id_mpwTimer:
mpwTimer->stop();
break;
case id_autoLockTimer:
autoLockTimer->stop();
break;
case id_metaCheckTimer:
metaCheckTimer->stop();
break;
}
}
void DocTimer::getLock(TimerIDs timer)
{
switch (timer) {
case id_mpwTimer:
++mpwLock;
break;
case id_autoLockTimer:
++autoLockLock;
break;
case id_metaCheckTimer:
++metaCheckLock;
break;
}
}
void DocTimer::putLock(TimerIDs timer)
{
switch (timer) {
case id_mpwTimer:
if (mpwLock)
--mpwLock;
break;
case id_autoLockTimer:
if (autoLockLock)
--autoLockLock;
break;
case id_metaCheckTimer:
if (metaCheckLock)
--metaCheckLock;
break;
}
}
void DocTimer::mpwTimeout()
{
if (mpwLock) {
mpwTimer->start(1000, true);
return;
}
doc->unsetDocStatFlag(DOC_STAT_UNLOCK_WITHOUT_PW);
}
void DocTimer::autoLockTimeout()
{
if (autoLockLock) {
autoLockTimer->start(1000, true);
return;
}
if (conf()->confGlobAutoDeepLock() &&
doc->filename != QString::null &&
doc->filename != "") {
doc->deepLock(true);
} else {
doc->lockAll(true);
}
}
void DocTimer::metaCheckTimeout()
{
if (metaCheckLock) {
// check again in one second.
metaCheckTimer->start(1000, true);
return;
}
if (doc->isDeepLocked()) {
metaCheckTimer->start(META_CHECK_TIMER_INTERVAL * 1000, true);
return;
}
if (doc->isDocEmpty()) {
metaCheckTimer->start(META_CHECK_TIMER_INTERVAL * 1000, true);
return;
}
#ifdef CONFIG_KWALLETIF
KWalletEmu *kwlEmu = doc->init->kwalletEmu();
if (kwlEmu)
kwlEmu->suspendDocSignals();
#endif // CONFIG_KWALLETIF
/* We simply trigger all views to update their
* displayed values. This way they have a chance
* to get notified when some meta changes over time.
* (for example an entry expired).
* The _view_ is responsive for not updating its
* contents if nothing really changed!
*/
emit doc->dataChanged(doc);
#ifdef CONFIG_KWALLETIF
if (kwlEmu)
kwlEmu->resumeDocSignals();
#endif // CONFIG_KWALLETIF
metaCheckTimer->start(META_CHECK_TIMER_INTERVAL * 1000, true);
}
PwMDocList PwMDoc::openDocList;
unsigned int PwMDocList::unnamedDocCnt = 1;
PwMDoc::PwMDoc(QObject *parent, const char *name)
: PwMDocUi(parent, name)
, dataChangedLock (0)
{
deleted = false;
unnamedNum = 0;
getOpenDocList()->add(this, getTitle().latin1());
curDocStat = 0;
setMaxNumEntries();
_timer = new DocTimer(this);
timer()->start(DocTimer::id_mpwTimer);
timer()->start(DocTimer::id_autoLockTimer);
timer()->start(DocTimer::id_metaCheckTimer);
addCategory(DEFAULT_CATEGORY, 0, false);
listView = 0;
emit docCreated(this);
}
PwMDoc::~PwMDoc()
{
emit docClosed(this);
getOpenDocList()->del(this);
delete _timer;
}
PwMerror PwMDoc::saveDoc(char compress, const QString *file)
{
PwMerror ret, e;
if (!file) {
if (filename == "")
return e_filename;
} else {
if (*file == "" && filename == "")
return e_filename;
if (*file != "")
filename = *file;
}
bool wasDeepLocked = isDeepLocked();
if (wasDeepLocked) {
if (deepLock(false) != e_success)
return e_noPw;
}
if (!isPwAvailable()) {
/* password is not available. This means, the
* document wasn't saved, yet.
*/
bool useChipcard = getDocStatFlag(DOC_STAT_USE_CHIPCARD);
QString pw(requestNewMpw(&useChipcard));
if (pw != "") {
currentPw = pw;
} else {
return e_noPw;
}
if (useChipcard) {
setDocStatFlag(DOC_STAT_USE_CHIPCARD);
} else {
unsetDocStatFlag(DOC_STAT_USE_CHIPCARD);
}
}
#ifndef PWM_EMBEDDED
int _cryptAlgo = conf()->confGlobCryptAlgo();
int _hashAlgo = conf()->confGlobHashAlgo();
#else
int _cryptAlgo = PWM_CRYPT_BLOWFISH;
int _hashAlgo = PWM_HASH_SHA1;
#endif
// sanity check for the selected algorithms
if (_cryptAlgo < PWM_CRYPT_BLOWFISH ||
_cryptAlgo > PWM_CRYPT_TWOFISH128) {
printWarn("Invalid Crypto-Algorithm selected! "
"Config-file seems to be corrupt. "
"Falling back to Blowfish.");
_cryptAlgo = PWM_CRYPT_BLOWFISH;
}
if (_hashAlgo < PWM_HASH_SHA1 ||
_hashAlgo > PWM_HASH_TIGER) {
printWarn("Invalid Hash-Algorithm selected! "
"Config-file seems to be corrupt. "
"Falling back to SHA1.");
_hashAlgo = PWM_HASH_SHA1;
}
char cryptAlgo = static_cast<char>(_cryptAlgo);
char hashAlgo = static_cast<char>(_hashAlgo);
if (conf()->confGlobMakeFileBackup()) {
if (!backupFile(filename))
return e_fileBackup;
}
QString tmpFileMoved(QString::null);
if (QFile::exists(filename)) {
/* Move the existing file to some tmp file.
* When saving file succeeds, delete tmp file. Otherwise
* move tmp file back. See below.
*/
Randomizer *rnd = Randomizer::obj();
char rnd_buf[5];
sprintf(rnd_buf, "%X%X%X%X", rnd->genRndChar() & 0xFF, rnd->genRndChar() & 0xFF,
rnd->genRndChar() & 0xFF, rnd->genRndChar() & 0xFF);
tmpFileMoved = filename + "." + rnd_buf + ".mv";
if (!copyFile(filename, tmpFileMoved))
return e_openFile;
if (!QFile::remove(filename)) {
printWarn(string("removing orig file ")
+ filename.latin1()
+ " failed!");
}
}
QFile f(filename);
string serialized;
if (!f.open(IO_ReadWrite)) {
ret = e_openFile;
goto out_moveback;
}
e = writeFileHeader(hashAlgo, hashAlgo,
cryptAlgo, compress,
&currentPw, &f);
if (e == e_hashNotImpl) {
printDebug("PwMDoc::saveDoc(): writeFileHeader() failed: e_hashNotImpl");
f.close();
ret = e_hashNotImpl;
goto out_moveback;
} else if (e != e_success) {
printDebug("PwMDoc::saveDoc(): writeFileHeader() failed");
f.close();
ret = e_writeHeader;
goto out_moveback;
}
if (!serializeDta(&serialized)) {
printDebug("PwMDoc::saveDoc(): serializeDta() failed");
f.close();
ret = e_serializeDta;
goto out_moveback;
}
e = writeDataHash(hashAlgo, &serialized, &f);
if (e == e_hashNotImpl) {
printDebug("PwMDoc::saveDoc(): writeDataHash() failed: e_hashNotImpl");
f.close();
ret = e_hashNotImpl;
goto out_moveback;
} else if (e != e_success) {
printDebug("PwMDoc::saveDoc(): writeDataHash() failed");
f.close();
ret = e_writeHeader;
goto out_moveback;
}
if (!compressDta(&serialized, compress)) {
printDebug("PwMDoc::saveDoc(): compressDta() failed");
f.close();
ret = e_enc;
goto out_moveback;
}
e = encrypt(&serialized, &currentPw, &f, cryptAlgo);
if (e == e_weakPw) {
printDebug("PwMDoc::saveDoc(): encrypt() failed: e_weakPw");
f.close();
ret = e_weakPw;
goto out_moveback;
} else if (e == e_cryptNotImpl) {
printDebug("PwMDoc::saveDoc(): encrypt() failed: e_cryptNotImpl");
f.close();
ret = e_cryptNotImpl;
goto out_moveback;
} else if (e != e_success) {
printDebug("PwMDoc::saveDoc(): encrypt() failed");
f.close();
ret = e_enc;
goto out_moveback;
}
unsetDocStatFlag(DOC_STAT_DISK_DIRTY);
f.close();
if (chmod(filename.latin1(),
conf()->confGlobFilePermissions())) {
printWarn(string("chmod failed: ") + strerror(errno));
}
openDocList.edit(this, getTitle().latin1());
if (wasDeepLocked)
deepLock(true);
if (tmpFileMoved != QString::null) {
// now remove the moved file.
if (!QFile::remove(tmpFileMoved)) {
printWarn(string("removing file ")
+ tmpFileMoved.latin1()
+ " failed!");
}
}
ret = e_success;
printDebug(string("writing file { compress: ")
+ tostr(static_cast<int>(compress)) + " cryptAlgo: "
+ tostr(static_cast<int>(cryptAlgo)) + " hashAlgo: "
+ tostr(static_cast<int>(hashAlgo))
+ " }");
goto out;
out_moveback:
if (tmpFileMoved != QString::null) {
if (copyFile(tmpFileMoved, filename)) {
if (!QFile::remove(tmpFileMoved)) {
printWarn(string("removing tmp file ")
+ filename.latin1()
+ " failed!");
}
} else {
printWarn(string("couldn't copy file ")
+ tmpFileMoved.latin1()
+ " back to "
+ filename.latin1());
}
}
out:
return ret;
}
PwMerror PwMDoc::openDoc(const QString *file, int openLocked)
{
PWM_ASSERT(file);
PWM_ASSERT(openLocked == 0 || openLocked == 1 || openLocked == 2);
string decrypted, dataHash;
PwMerror ret;
char cryptAlgo, dataHashType, compress;
unsigned int headerLen;
if (*file == "")
return e_readFile;
filename = *file;
/* check if this file is already open.
* This does not catch symlinks!
*/
if (!isDeepLocked()) {
if (getOpenDocList()->find(filename.latin1()))
return e_alreadyOpen;
}
QFile f(filename);
if (openLocked == 2) {
// open deep-locked
if (!QFile::exists(filename))
return e_openFile;
if (deepLock(true, false) != e_success)
return e_openFile;
goto out_success;
}
if (!f.open(IO_ReadOnly))
return e_openFile;
ret = checkHeader(&cryptAlgo, &currentPw, &compress, &headerLen,
&dataHashType, &dataHash, &f);
if (ret != e_success) {
printDebug("PwMDoc::openDoc(): checkHeader() failed");
f.close();
if (ret == e_wrongPw) {
wrongMpwMsgBox(getDocStatFlag(DOC_STAT_USE_CHIPCARD));
return ret;
} else if (ret == e_noPw ||
ret == e_fileVer ||
ret == e_fileFormat ||
ret == e_hashNotImpl) {
return ret;
} else
return e_readFile;
}
ret = decrypt(&decrypted, headerLen, &currentPw, cryptAlgo, &f);
if (ret == e_cryptNotImpl) {
printDebug("PwMDoc::openDoc(): decrypt() failed: e_cryptNotImpl");
f.close();
return e_cryptNotImpl;
} else if (ret != e_success) {
@@ -662,1026 +660,1024 @@ PwMerror PwMDoc::writeFileHeader(char keyHash, char dataHash, char crypt, char c
err = gc.hash(&buf,
&hashLen,
reinterpret_cast<const unsigned char *>(pw->latin1()),
pw->length(),
keyHash);
if (err != e_success)
return e_hashNotImpl;
if (f->writeBlock(reinterpret_cast<const char *>(buf), hashLen)
!= static_cast<Q_LONG>(hashLen)) {
delete [] buf;
return e_hashNotImpl;
}
delete [] buf;
break;
}
#endif
default: {
return e_hashNotImpl;
} }
return e_success;
}
PwMerror PwMDoc::checkHeader(char *cryptAlgo, QString *pw, char *compress,
unsigned int *headerLength, char *dataHashType,
string *dataHash, QFile *f)
{
PWM_ASSERT(cryptAlgo);
PWM_ASSERT(pw);
PWM_ASSERT(headerLength);
PWM_ASSERT(dataHashType);
PWM_ASSERT(dataHash);
PWM_ASSERT(f);
int tmpRet;
// check "magic" header
const char magicHdr[] = FILE_ID_HEADER;
const int hdrLen = array_size(magicHdr) - 1;
char tmp[hdrLen];
if (f->readBlock(tmp, hdrLen) != hdrLen)
return e_readFile;
if (memcmp(tmp, magicHdr, hdrLen) != 0)
return e_fileFormat;
// read and check file ver
int fileV = f->getch();
if (fileV == -1)
return e_fileFormat;
if (fileV != PWM_FILE_VER)
return e_fileVer;
// read hash hash type
int keyHash = f->getch();
if (keyHash == -1)
return e_fileFormat;
// read data hash type
tmpRet = f->getch();
if (tmpRet == -1)
return e_fileFormat;
*dataHashType = tmpRet;
// read crypt algo
tmpRet = f->getch();
if (tmpRet == -1)
return e_fileFormat;
*cryptAlgo = tmpRet;
// get compression-algo
tmpRet = f->getch();
if (tmpRet == -1)
return e_fileFormat;
*compress = tmpRet;
// get the MPW-flag
int mpw_flag = f->getch();
if (mpw_flag == -1)
return e_fileFormat;
if (mpw_flag == 0x01)
setDocStatFlag(DOC_STAT_USE_CHIPCARD);
else
unsetDocStatFlag(DOC_STAT_USE_CHIPCARD);
// skip the "RESERVED"-bytes
if (!(f->at(f->at() + 64)))
return e_fileFormat;
*pw = requestMpw(getDocStatFlag(DOC_STAT_USE_CHIPCARD));
if (*pw == "") {
/* the user didn't give a master-password
* or didn't insert a chipcard
*/
return e_noPw;
}
// verify key-hash
switch (keyHash) {
case PWM_HASH_SHA1: {
// read hash from header
const int hashLen = SHA1_HASH_LEN_BYTE;
string readHash;
int i;
for (i = 0; i < hashLen; ++i)
readHash.push_back(f->getch());
Sha1 hash;
hash.sha1_write(reinterpret_cast<const byte *>(pw->latin1()), pw->length());
string ret = hash.sha1_read();
if (ret != readHash)
return e_wrongPw; // hash doesn't match (wrong key)
break;
}
#ifndef PWM_EMBEDDED
case PWM_HASH_SHA256:
/*... fall through */
case PWM_HASH_SHA384:
case PWM_HASH_SHA512:
case PWM_HASH_MD5:
case PWM_HASH_RMD160:
case PWM_HASH_TIGER: {
if (!LibGCryptIf::available())
return e_hashNotImpl;
LibGCryptIf gc;
PwMerror err;
unsigned char *buf;
size_t hashLen;
err = gc.hash(&buf,
&hashLen,
reinterpret_cast<const unsigned char *>(pw->latin1()),
pw->length(),
keyHash);
if (err != e_success)
return e_hashNotImpl;
string calcHash(reinterpret_cast<const char *>(buf),
static_cast<string::size_type>(hashLen));
delete [] buf;
// read hash from header
string readHash;
size_t i;
for (i = 0; i < hashLen; ++i)
readHash.push_back(f->getch());
if (calcHash != readHash)
return e_wrongPw; // hash doesn't match (wrong key)
break;
}
#endif
default: {
return e_hashNotImpl;
} }
// read the data-hash from the file
unsigned int hashLen, i;
switch (*dataHashType) {
case PWM_HASH_SHA1:
hashLen = SHA1_HASH_LEN_BYTE;
break;
#ifndef PWM_EMBEDDED
case PWM_HASH_SHA256:
/*... fall through */
case PWM_HASH_SHA384:
case PWM_HASH_SHA512:
case PWM_HASH_MD5:
case PWM_HASH_RMD160:
case PWM_HASH_TIGER: {
if (!LibGCryptIf::available())
return e_hashNotImpl;
LibGCryptIf gc;
hashLen = gc.hashLength(*dataHashType);
if (hashLen == 0)
return e_hashNotImpl;
break;
}
#endif
default:
return e_hashNotImpl;
}
*dataHash = "";
for (i = 0; i < hashLen; ++i) {
tmpRet = f->getch();
if (tmpRet == -1)
return e_fileFormat;
dataHash->push_back(static_cast<char>(tmpRet));
}
*headerLength = f->at();
#ifndef PWM_EMBEDDED
printDebug(string("opening file { compress: ")
+ tostr(static_cast<int>(*compress)) + " cryptAlgo: "
+ tostr(static_cast<int>(*cryptAlgo)) + " keyHashAlgo: "
+ tostr(static_cast<int>(keyHash))
+ " }");
#else
printDebug(string("opening file { compress: ")
+ tostr((int)(*compress)) + " cryptAlgo: "
+ tostr((int)(*cryptAlgo)) + " keyHashAlgo: "
+ tostr((int)(keyHash))
+ " }");
#endif
return e_success;
}
PwMerror PwMDoc::writeDataHash(char dataHash, string *d, QFile *f)
{
PWM_ASSERT(d);
PWM_ASSERT(f);
switch (dataHash) {
case PWM_HASH_SHA1: {
const int hashLen = SHA1_HASH_LEN_BYTE;
Sha1 h;
h.sha1_write(reinterpret_cast<const byte *>(d->c_str()), d->size());
string hRet = h.sha1_read();
if (f->writeBlock(hRet.c_str(), hashLen) != hashLen)
return e_writeFile;
break;
}
#ifndef PWM_EMBEDDED
case PWM_HASH_SHA256:
/*... fall through */
case PWM_HASH_SHA384:
case PWM_HASH_SHA512:
case PWM_HASH_MD5:
case PWM_HASH_RMD160:
case PWM_HASH_TIGER: {
if (!LibGCryptIf::available())
return e_hashNotImpl;
LibGCryptIf gc;
PwMerror err;
unsigned char *buf;
size_t hashLen;
err = gc.hash(&buf,
&hashLen,
reinterpret_cast<const unsigned char *>(d->c_str()),
d->size(),
dataHash);
if (err != e_success)
return e_hashNotImpl;
if (f->writeBlock(reinterpret_cast<const char *>(buf), hashLen)
!= static_cast<Q_LONG>(hashLen)) {
delete [] buf;
return e_hashNotImpl;
}
delete [] buf;
break;
}
#endif
default: {
return e_hashNotImpl;
} }
return e_success;
}
bool PwMDoc::backupFile(const QString &filePath)
{
QFileInfo fi(filePath);
if (!fi.exists())
return true; // Yes, true is correct.
QString pathOnly(fi.dirPath(true));
QString nameOnly(fi.fileName());
QString backupPath = pathOnly
+ "/~"
+ nameOnly
+ ".backup";
return copyFile(filePath, backupPath);
}
bool PwMDoc::copyFile(const QString &src, const QString &dst)
{
QFileInfo fi(src);
if (!fi.exists())
return false;
if (QFile::exists(dst)) {
if (!QFile::remove(dst))
return false;
}
QFile srcFd(src);
if (!srcFd.open(IO_ReadOnly))
return false;
QFile dstFd(dst);
if (!dstFd.open(IO_ReadWrite)) {
srcFd.close();
return false;
}
const int tmpBuf_size = 512;
char tmpBuf[tmpBuf_size];
#ifndef PWM_EMBEDDED
Q_LONG bytesRead, bytesWritten;
#else
long bytesRead, bytesWritten;
#endif
while (!srcFd.atEnd()) {
#ifndef PWM_EMBEDDED
bytesRead = srcFd.readBlock(tmpBuf,
static_cast<Q_ULONG>(tmpBuf_size));
#else
bytesRead = srcFd.readBlock(tmpBuf,
(unsigned long)(tmpBuf_size));
#endif
if (bytesRead == -1) {
srcFd.close();
dstFd.close();
return false;
}
#ifndef PWM_EMBEDDED
bytesWritten = dstFd.writeBlock(tmpBuf,
static_cast<Q_ULONG>(bytesRead));
#else
bytesWritten = dstFd.writeBlock(tmpBuf,
(unsigned long)(bytesRead));
#endif
if (bytesWritten != bytesRead) {
srcFd.close();
dstFd.close();
return false;
}
}
srcFd.close();
dstFd.close();
return true;
}
PwMerror PwMDoc::addEntry(const QString &category, PwMDataItem *d,
bool dontFlagDirty, bool updateMeta)
{
PWM_ASSERT(d);
unsigned int cat = 0;
if (isDeepLocked()) {
PwMerror ret;
ret = deepLock(false);
if (ret != e_success)
return e_lock;
}
addCategory(category, &cat);
if (numEntries(category) >= maxEntries)
return e_maxAllowedEntr;
vector<unsigned int> foundPositions;
/* historically this was:
* const int searchIn = SEARCH_IN_DESC | SEARCH_IN_NAME |
* SEARCH_IN_URL | SEARCH_IN_LAUNCHER;
* But for now we only search in desc.
* That's a tweak to be KWallet compatible. But it should not add
* usability-drop onto PwManager, does it?
* (And yes, "int" was a bug. Correct is "unsigned int")
*/
const unsigned int searchIn = SEARCH_IN_DESC;
findEntry(cat, *d, searchIn, &foundPositions, true);
if (foundPositions.size()) {
// DOH! We found this entry.
return e_entryExists;
}
d->listViewPos = -1;
d->lockStat = conf()->confGlobNewEntrLockStat();
if (updateMeta) {
d->meta.create = QDateTime::currentDateTime();
d->meta.update = d->meta.create;
}
dta[cat].d.push_back(*d);
delAllEmptyCat(true);
if (!dontFlagDirty)
flagDirty();
return e_success;
}
PwMerror PwMDoc::addCategory(const QString &category, unsigned int *categoryIndex,
bool checkIfExist)
{
if (isDeepLocked()) {
PwMerror ret;
ret = deepLock(false);
if (ret != e_success)
return e_lock;
}
if (checkIfExist) {
if (findCategory(category, categoryIndex))
return e_categoryExists;
}
PwMCategoryItem item;
item.name = category.latin1();
dta.push_back(item);
if (categoryIndex)
*categoryIndex = dta.size() - 1;
return e_success;
}
bool PwMDoc::delEntry(const QString &category, unsigned int index, bool dontFlagDirty)
{
unsigned int cat = 0;
if (!findCategory(category, &cat)) {
BUG();
return false;
}
return delEntry(cat, index, dontFlagDirty);
}
bool PwMDoc::delEntry(unsigned int category, unsigned int index, bool dontFlagDirty)
{
if (isDeepLocked())
return false;
if (index > dta[category].d.size() - 1)
return false;
getDataChangedLock();
if (!lockAt(category, index, false)) {
putDataChangedLock();
return false;
}
putDataChangedLock();
int lvPos = dta[category].d[index].listViewPos;
// delete entry
dta[category].d.erase(dta[category].d.begin() + index);
unsigned int i, entries = numEntries(category);
if (!entries) {
// no more entries in this category, so
// we can delete it, too.
BUG_ON(!delCategory(category));
// delCategory() flags it dirty, so we need not to do so.
return true;
}
for (i = 0; i < entries; ++i) {
// decrement all listViewPositions that are greater than the deleted.
if (dta[category].d[i].listViewPos > lvPos)
--dta[category].d[i].listViewPos;
}
if (!dontFlagDirty)
flagDirty();
return true;
}
bool PwMDoc::editEntry(const QString &oldCategory, const QString &newCategory,
unsigned int index, PwMDataItem *d, bool updateMeta)
{
PWM_ASSERT(d);
unsigned int oldCat = 0;
if (!findCategory(oldCategory, &oldCat)) {
BUG();
return false;
}
return editEntry(oldCat, newCategory, index, d, updateMeta);
}
bool PwMDoc::editEntry(unsigned int oldCategory, const QString &newCategory,
unsigned int index, PwMDataItem *d, bool updateMeta)
{
if (isDeepLocked())
return false;
if (updateMeta) {
d->meta.update = QDateTime::currentDateTime();
if (d->meta.create.isNull()) {
d->meta.create = d->meta.update;
}
}
if (dta[oldCategory].name != newCategory.latin1()) {
// the user changed the category.
PwMerror ret;
d->rev = 0;
ret = addEntry(newCategory, d, true, false);
if (ret != e_success)
return false;
if (!delEntry(oldCategory, index, true))
return false;
} else {
d->rev = dta[oldCategory].d[index].rev + 1; // increment revision counter.
dta[oldCategory].d[index] = *d;
}
flagDirty();
return true;
}
unsigned int PwMDoc::numEntries(const QString &category)
{
unsigned int cat = 0;
if (!findCategory(category, &cat)) {
BUG();
return 0;
}
return numEntries(cat);
}
bool PwMDoc::serializeDta(string *d)
{
PWM_ASSERT(d);
Serializer ser;
if (!ser.serialize(dta))
return false;
d->assign(ser.getXml());
if (!d->size())
return false;
return true;
}
bool PwMDoc::deSerializeDta(const string *d, bool entriesLocked)
{
PWM_ASSERT(d);
#ifndef PWM_EMBEDDED
try {
Serializer ser(d->c_str());
ser.setDefaultLockStat(entriesLocked);
if (!ser.deSerialize(&dta))
return false;
} catch (PwMException) {
return false;
}
#else
Serializer ser(d->c_str());
ser.setDefaultLockStat(entriesLocked);
if (!ser.deSerialize(&dta))
return false;
- else
- return false;
#endif
emitDataChanged(this);
return true;
}
bool PwMDoc::getEntry(const QString &category, unsigned int index,
PwMDataItem * d, bool unlockIfLocked)
{
PWM_ASSERT(d);
unsigned int cat = 0;
if (!findCategory(category, &cat)) {
BUG();
return false;
}
return getEntry(cat, index, d, unlockIfLocked);
}
bool PwMDoc::getEntry(unsigned int category, unsigned int index,
PwMDataItem *d, bool unlockIfLocked)
{
if (index > dta[category].d.size() - 1)
return false;
bool locked = isLocked(category, index);
if (locked) {
/* this entry is locked. We don't return a password,
* until it's unlocked by the user by inserting
* chipcard or entering the mpw
*/
if (unlockIfLocked) {
if (!lockAt(category, index, false)) {
return false;
}
locked = false;
}
}
*d = dta[category].d[index];
if (locked)
d->pw = LOCKED_STRING.latin1();
return true;
}
PwMerror PwMDoc::getCommentByLvp(const QString &category, int listViewPos,
string *foundComment)
{
PWM_ASSERT(foundComment);
unsigned int cat = 0;
if (!findCategory(category, &cat))
return e_invalidArg;
unsigned int i, entries = numEntries(cat);
for (i = 0; i < entries; ++i) {
if (dta[cat].d[i].listViewPos == listViewPos) {
*foundComment = dta[cat].d[i].comment;
if (dta[cat].d[i].binary)
return e_binEntry;
return e_normalEntry;
}
}
BUG();
return e_generic;
}
bool PwMDoc::compressDta(string *d, char algo)
{
PWM_ASSERT(d);
switch (algo) {
case PWM_COMPRESS_GZIP: {
CompressGzip comp;
return comp.compress(d);
} case PWM_COMPRESS_BZIP2: {
CompressBzip2 comp;
return comp.compress(d);
} case PWM_COMPRESS_NONE: {
return true;
} default: {
BUG();
}
}
return false;
}
bool PwMDoc::decompressDta(string *d, char algo)
{
PWM_ASSERT(d);
switch (algo) {
case PWM_COMPRESS_GZIP: {
CompressGzip comp;
return comp.decompress(d);
} case PWM_COMPRESS_BZIP2: {
CompressBzip2 comp;
return comp.decompress(d);
} case PWM_COMPRESS_NONE: {
return true;
}
}
return false;
}
PwMerror PwMDoc::encrypt(string *d, const QString *pw, QFile *f, char algo)
{
PWM_ASSERT(d);
PWM_ASSERT(pw);
PWM_ASSERT(f);
size_t encSize;
byte *encrypted = 0;
switch (algo) {
case PWM_CRYPT_BLOWFISH: {
Blowfish::padNull(d);
encSize = d->length();
encrypted = new byte[encSize];
Blowfish bf;
if (bf.bf_setkey((byte *) pw->latin1(), pw->length())) {
delete [] encrypted;
return e_weakPw;
}
bf.bf_encrypt((byte *) encrypted, (byte *) d->c_str(), encSize);
break;
}
#ifndef PWM_EMBEDDED
case PWM_CRYPT_AES128:
/*... fall through */
case PWM_CRYPT_AES192:
case PWM_CRYPT_AES256:
case PWM_CRYPT_3DES:
case PWM_CRYPT_TWOFISH:
case PWM_CRYPT_TWOFISH128: {
if (!LibGCryptIf::available())
return e_cryptNotImpl;
LibGCryptIf gc;
PwMerror err;
unsigned char *plain = new unsigned char[d->length() + 1024];
memcpy(plain, d->c_str(), d->length());
err = gc.encrypt(&encrypted,
&encSize,
plain,
d->length(),
reinterpret_cast<const unsigned char *>(pw->latin1()),
pw->length(),
algo);
delete [] plain;
if (err != e_success)
return e_cryptNotImpl;
break;
}
#endif
default: {
delete_ifnot_null_array(encrypted);
return e_cryptNotImpl;
} }
// write encrypted data to file
#ifndef PWM_EMBEDDED
if (f->writeBlock(reinterpret_cast<const char *>(encrypted),
static_cast<Q_ULONG>(encSize))
!= static_cast<Q_LONG>(encSize)) {
delete_ifnot_null_array(encrypted);
return e_writeFile;
}
#else
if (f->writeBlock((const char *)(encrypted),
(unsigned long)(encSize))
!= (long)(encSize)) {
delete_ifnot_null_array(encrypted);
return e_writeFile;
}
#endif
delete_ifnot_null_array(encrypted);
return e_success;
}
PwMerror PwMDoc::decrypt(string *d, unsigned int pos, const QString *pw,
char algo, QFile *f)
{
PWM_ASSERT(d);
PWM_ASSERT(pw);
PWM_ASSERT(f);
unsigned int cryptLen = f->size() - pos;
byte *encrypted = new byte[cryptLen];
byte *decrypted = new byte[cryptLen];
f->at(pos);
#ifndef PWM_EMBEDDED
if (f->readBlock(reinterpret_cast<char *>(encrypted),
static_cast<Q_ULONG>(cryptLen))
!= static_cast<Q_LONG>(cryptLen)) {
delete [] encrypted;
delete [] decrypted;
return e_readFile;
}
#else
if (f->readBlock((char *)(encrypted),
(unsigned long)(cryptLen))
!= (long)(cryptLen)) {
delete [] encrypted;
delete [] decrypted;
return e_readFile;
}
#endif
switch (algo) {
case PWM_CRYPT_BLOWFISH: {
Blowfish bf;
bf.bf_setkey((byte *) pw->latin1(), pw->length());
bf.bf_decrypt(decrypted, encrypted, cryptLen);
break;
}
#ifndef PWM_EMBEDDED
case PWM_CRYPT_AES128:
/*... fall through */
case PWM_CRYPT_AES192:
case PWM_CRYPT_AES256:
case PWM_CRYPT_3DES:
case PWM_CRYPT_TWOFISH:
case PWM_CRYPT_TWOFISH128: {
if (!LibGCryptIf::available())
return e_cryptNotImpl;
LibGCryptIf gc;
PwMerror err;
err = gc.decrypt(&decrypted,
&cryptLen,
encrypted,
cryptLen,
reinterpret_cast<const unsigned char *>(pw->latin1()),
pw->length(),
algo);
if (err != e_success) {
delete [] encrypted;
delete [] decrypted;
return e_cryptNotImpl;
}
break;
}
#endif
default: {
delete [] encrypted;
delete [] decrypted;
return e_cryptNotImpl;
} }
delete [] encrypted;
#ifndef PWM_EMBEDDED
d->assign(reinterpret_cast<const char *>(decrypted),
static_cast<string::size_type>(cryptLen));
#else
d->assign((const char *)(decrypted),
(string::size_type)(cryptLen));
#endif
delete [] decrypted;
if (algo == PWM_CRYPT_BLOWFISH) {
if (!Blowfish::unpadNull(d)) {
BUG();
return e_readFile;
}
}
return e_success;
}
PwMerror PwMDoc::checkDataHash(char dataHashType, const string *dataHash,
const string *dataStream)
{
PWM_ASSERT(dataHash);
PWM_ASSERT(dataStream);
switch(dataHashType) {
case PWM_HASH_SHA1: {
Sha1 hash;
hash.sha1_write((byte*)dataStream->c_str(), dataStream->length());
string ret = hash.sha1_read();
if (ret != *dataHash)
return e_fileCorrupt;
break;
}
#ifndef PWM_EMBEDDED
case PWM_HASH_SHA256:
/*... fall through */
case PWM_HASH_SHA384:
case PWM_HASH_SHA512:
case PWM_HASH_MD5:
case PWM_HASH_RMD160:
case PWM_HASH_TIGER: {
if (!LibGCryptIf::available())
return e_hashNotImpl;
LibGCryptIf gc;
PwMerror err;
unsigned char *buf;
size_t hashLen;
err = gc.hash(&buf,
&hashLen,
reinterpret_cast<const unsigned char *>(dataStream->c_str()),
dataStream->length(),
dataHashType);
if (err != e_success)
return e_hashNotImpl;
string calcHash(reinterpret_cast<const char *>(buf),
static_cast<string::size_type>(hashLen));
delete [] buf;
if (calcHash != *dataHash)
return e_fileCorrupt;
break;
}
#endif
default:
return e_hashNotImpl;
}
return e_success;
}
bool PwMDoc::lockAt(unsigned int category, unsigned int index,
bool lock)
{
if (index >= numEntries(category)) {
BUG();
return false;
}
if (lock == dta[category].d[index].lockStat)
return true;
if (!lock && currentPw != "") {
// "unlocking" and "password is already set"
if (!getDocStatFlag(DOC_STAT_UNLOCK_WITHOUT_PW)) {
// unlocking without pw not allowed
QString pw;
pw = requestMpw(getDocStatFlag(DOC_STAT_USE_CHIPCARD));
if (pw != "") {
if (pw != currentPw) {
wrongMpwMsgBox(getDocStatFlag(DOC_STAT_USE_CHIPCARD));
return false;
} else {
timer()->start(DocTimer::id_mpwTimer);
}
} else {
return false;
}
} else {
timer()->start(DocTimer::id_mpwTimer);
}
}
dta[category].d[index].lockStat = lock;
dta[category].d[index].rev++; // increment revision counter.
emitDataChanged(this);
if (!lock)
timer()->start(DocTimer::id_autoLockTimer);
return true;
}
bool PwMDoc::lockAt(const QString &category,unsigned int index,
bool lock)
{
unsigned int cat = 0;
if (!findCategory(category, &cat)) {
BUG();
return false;
}
return lockAt(cat, index, lock);
}
bool PwMDoc::lockAll(bool lock)
{
if (!lock && isDeepLocked()) {
PwMerror ret;
ret = deepLock(false);
if (ret != e_success)
return false;
return true;
}
if (isDocEmpty()) {
return true;
}
if (!lock && currentPw != "") {
// unlocking and password is already set
if (!getDocStatFlag(DOC_STAT_UNLOCK_WITHOUT_PW)) {
// unlocking without pw not allowed
QString pw;
pw = requestMpw(getDocStatFlag(DOC_STAT_USE_CHIPCARD));
if (pw != "") {
if (pw != currentPw) {
wrongMpwMsgBox(getDocStatFlag(DOC_STAT_USE_CHIPCARD));
return false;
} else {
timer()->start(DocTimer::id_mpwTimer);
}
} else {
return false;
}
} else {
timer()->start(DocTimer::id_mpwTimer);
}
}
vector<PwMCategoryItem>::iterator catBegin = dta.begin(),
catEnd = dta.end(),
catI = catBegin;
vector<PwMDataItem>::iterator entrBegin, entrEnd, entrI;
while (catI != catEnd) {
entrBegin = catI->d.begin();
entrEnd = catI->d.end();
entrI = entrBegin;
while (entrI != entrEnd) {
entrI->lockStat = lock;
entrI->rev++; // increment revision counter.
++entrI;
}
++catI;
}
emitDataChanged(this);
if (lock)
timer()->stop(DocTimer::id_autoLockTimer);
else
timer()->start(DocTimer::id_autoLockTimer);
return true;
}
bool PwMDoc::isLocked(const QString &category, unsigned int index)
{
unsigned int cat = 0;
if (!findCategory(category, &cat)) {
BUG();
return false;
}
return isLocked(cat, index);
}
bool PwMDoc::unlockAll_tempoary(bool revert)
{
static vector< vector<bool> > *oldLockStates = 0;
static bool wasDeepLocked;
if (revert) { // revert the unlocking
if (oldLockStates) {
/* we actually _have_ unlocked something, because
* we have allocated space for the oldLockStates.
* So, go on and revert them!
*/
if (wasDeepLocked) {
PwMerror ret = deepLock(true);
if (ret == e_success) {
/* deep-lock succeed. We are save.
* (but if it failed, just go on
* lock them normally)
*/
delete_and_null(oldLockStates);
timer()->start(DocTimer::id_autoLockTimer);
printDebug("tempoary unlocking of dta "
"reverted by deep-locking.");
return true;
}
printDebug("deep-lock failed while reverting! "
"Falling back to normal-lock.");
}
if (unlikely(!wasDeepLocked &&
numCategories() != oldLockStates->size())) {
/* DOH! We have modified "dta" while
* it was unlocked tempoary. DON'T DO THIS!
*/
BUG();
delete_and_null(oldLockStates);
timer()->start(DocTimer::id_autoLockTimer);
return false;
}
vector<PwMCategoryItem>::iterator catBegin = dta.begin(),
catEnd = dta.end(),
catI = catBegin;
vector<PwMDataItem>::iterator entrBegin, entrEnd, entrI;
vector< vector<bool> >::iterator oldCatStatI = oldLockStates->begin();
vector<bool>::iterator oldEntrStatBegin,
oldEntrStatEnd,
oldEntrStatI;
while (catI != catEnd) {
entrBegin = catI->d.begin();
entrEnd = catI->d.end();
entrI = entrBegin;
if (likely(!wasDeepLocked)) {
oldEntrStatBegin = oldCatStatI->begin();
oldEntrStatEnd = oldCatStatI->end();
oldEntrStatI = oldEntrStatBegin;
if (unlikely(catI->d.size() != oldCatStatI->size())) {
/* DOH! We have modified "dta" while
* it was unlocked tempoary. DON'T DO THIS!
*/
BUG();
delete_and_null(oldLockStates);
timer()->start(DocTimer::id_autoLockTimer);
return false;
}
}
while (entrI != entrEnd) {
if (wasDeepLocked) {
/* this is an error-fallback if
* deeplock didn't succeed
*/
entrI->lockStat = true;
} else {
entrI->lockStat = *oldEntrStatI;
}
++entrI;
diff --git a/pwmanager/pwmanager/pwmprefs.cpp b/pwmanager/pwmanager/pwmprefs.cpp
index d3847f6..7fd347f 100644
--- a/pwmanager/pwmanager/pwmprefs.cpp
+++ b/pwmanager/pwmanager/pwmprefs.cpp
@@ -1,300 +1,301 @@
/*
This file is part of PwManager/Pi
Copyright (c) 2004 Ulf Schenk
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program 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 General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
As a special exception, permission is given to link this program
with any edition of Qt, and distribute the resulting executable,
without including the source code for Qt in the source distribution.
$Id$
*/
#include <kconfig.h>
#include <klocale.h>
#include <kstaticdeleter.h>
#include "pwmprefs.h"
PWMPrefs *PWMPrefs::sInstance = 0;
static KStaticDeleter<PWMPrefs> staticDeleter;
PWMPrefs::PWMPrefs()
: KPimPrefs("pwmanagerrc")
{
KPrefs::setCurrentGroup( "Global" );
addItemString( "autoStart", &mAutoStart, "" );
addItemString( "browserCommand", &mBrowserCommand, "" );
addItemString( "xtermCommand", &mXTermCommand, CONF_DEFAULT_XTERMCOMMAND);
addItemFont( "entryFont", &mEntryFont);
addItemInt( "pwTimeout", &mPwTimeout, CONF_DEFAULT_PWTIMEOUT );
addItemInt( "lockTimeout", &mLockTimeout, CONF_DEFAULT_LOCKTIMEOUT );
addItemInt( "compression", &mCompression, CONF_DEFAULT_COMPRESSION );
addItemInt( "filePermissions", &mFilePermissions, CONF_DEFAULT_FILEPERMISSIONS );
addItemInt( "minimizeLock", &mMinimizeLock, CONF_DEFAULT_MINIMIZELOCK );
addItemBool( "unlockOnOpen", &mUnlockOnOpen, CONF_DEFAULT_UNLOCKONOPEN );
addItemBool( "tray", &mTray, CONF_DEFAULT_TRAY );
addItemBool( "makeFileBackup", &mMakeFileBackup, CONF_DEFAULT_MAKEFILEBACKUP );
addItemBool( "autostartDeepLocked", &mAutostartDeeplocked, CONF_DEFAULT_AUTOSTART_DEEPL );
addItemBool( "autoDeepLock", &mAutoDeeplock, CONF_DEFAULT_AUTODEEPLOCK );
addItemBool( "kwalletEmu", &mKWalletEmu, CONF_DEFAULT_KWALLETEMU );
addItemBool( "newEntrLockStat", &mNewEntrLockStat, CONF_DEFAULT_NEWENTRLOCKSTAT );
KPrefs::setCurrentGroup( "Wnd" );
addItemSize( "MainWndSize", &mMainWndSize);
addItemInt( "MainViewStyle", &mMainViewStyle, CONF_DEFAULT_MAINVIEWSTYLE );
addItemBool( "autoMinimizeOnStart", &mAutoMinimizeOnStart, CONF_DEFAULT_AUTOMINIMIZE );
addItemBool( "close", &mClose, CONF_DEFAULT_WNDCLOSE );
- addItemIntList( "CommentSplitter", &mCommentSplitter );
+ addItemIntList( "commentSplitter", &mCommentSplitter );
+ addItemIntList( "categorySplitter", &mCategorySplitter );
}
PWMPrefs::~PWMPrefs()
{
}
PWMPrefs *PWMPrefs::instance()
{
if ( !sInstance ) {
#ifdef PWM_EMBEDDED
sInstance = staticDeleter.setObject( new PWMPrefs() );
#else //PWM_EMBEDDED
//US the following line has changed ???. Why
staticDeleter.setObject( sInstance, new PWMPrefs() );
#endif //KAB_EMBEDDED
sInstance->readConfig();
}
return sInstance;
}
// US introduce a nonconst way to return the config object.
KConfig* PWMPrefs::getConfig()
{
return config();
}
/*******************************************************************
* functions for reading the configuration settings
*******************************************************************/
QString PWMPrefs::confGlobAutoStart()
{
return mAutoStart;
}
QString PWMPrefs::confGlobBrowserCommand()
{
return mBrowserCommand;
}
QString PWMPrefs::confGlobXtermCommand()
{
return mXTermCommand;
}
QFont PWMPrefs::confGlobEntryFont()
{
return mEntryFont;
}
int PWMPrefs::confGlobPwTimeout()
{
return mPwTimeout;
}
int PWMPrefs::confGlobLockTimeout()
{
return mLockTimeout;
}
int PWMPrefs::confGlobCompression()
{
return mCompression;
}
int PWMPrefs::confGlobFilePermissions()
{
return mFilePermissions;
}
int PWMPrefs::confGlobMinimizeLock()
{
return mMinimizeLock;
}
bool PWMPrefs::confGlobUnlockOnOpen()
{
return mUnlockOnOpen;
}
bool PWMPrefs::confGlobTray()
{
return mTray;
}
bool PWMPrefs::confGlobMakeFileBackup()
{
return mMakeFileBackup;
}
bool PWMPrefs::confGlobAutostartDeepLocked()
{
return mAutostartDeeplocked;
}
bool PWMPrefs::confGlobAutoDeepLock()
{
return mAutoDeeplock;
}
bool PWMPrefs::confGlobKwalletEmu()
{
return mKWalletEmu;
}
bool PWMPrefs::confGlobNewEntrLockStat()
{
return mNewEntrLockStat;
}
QSize PWMPrefs::confWndMainWndSize()
{
return mMainWndSize;
}
int PWMPrefs::confWndMainViewStyle()
{
return mMainViewStyle;
}
bool PWMPrefs::confWndAutoMinimizeOnStart()
{
return mAutoMinimizeOnStart;
}
bool PWMPrefs::confWndClose()
{
return mClose;
}
/*******************************************************************
* functions for writing the configuration settings
*******************************************************************/
void PWMPrefs::confGlobAutoStart(const QString &e)
{
mAutoStart = e;
}
void PWMPrefs::confGlobBrowserCommand(const QString &e)
{
mBrowserCommand = e;
}
void PWMPrefs::confGlobXtermCommand(const QString &e)
{
mXTermCommand = e;
}
void PWMPrefs::confGlobEntryFont(const QFont &e)
{
mEntryFont = e;
}
void PWMPrefs::confGlobPwTimeout(int e)
{
mPwTimeout = e;
}
void PWMPrefs::confGlobLockTimeout(int e)
{
mLockTimeout = e;
}
void PWMPrefs::confGlobCompression(int e)
{
mCompression = e;
}
void PWMPrefs::confGlobFilePermissions(int e)
{
mFilePermissions = e;
}
void PWMPrefs::confGlobMinimizeLock(int e)
{
mMinimizeLock = e;
}
void PWMPrefs::confGlobUnlockOnOpen(bool e)
{
mUnlockOnOpen = e;
}
void PWMPrefs::confGlobTray(bool e)
{
mTray = e;
}
void PWMPrefs::confGlobMakeFileBackup(bool e)
{
mMakeFileBackup = e;
}
void PWMPrefs::confGlobAutostartDeepLocked(bool e)
{
mAutostartDeeplocked = e;
}
void PWMPrefs::confGlobAutoDeepLock(bool e)
{
mAutoDeeplock = e;
}
void PWMPrefs::confGlobKwalletEmu(bool e)
{
mKWalletEmu = e;
}
void PWMPrefs::confGlobNewEntrLockStat(bool e)
{
mNewEntrLockStat = e;
}
void PWMPrefs::confWndMainWndSize(const QSize &e)
{
mMainWndSize = e;
}
void PWMPrefs::confWndMainViewStyle(int e)
{
mMainViewStyle = e;
}
void PWMPrefs::confWndAutoMinimizeOnStart(bool e)
{
mAutoMinimizeOnStart = e;
}
void PWMPrefs::confWndClose(bool e)
{
mClose = e;
}
diff --git a/pwmanager/pwmanager/pwmprefs.h b/pwmanager/pwmanager/pwmprefs.h
index 6a89d10..9fed7d2 100644
--- a/pwmanager/pwmanager/pwmprefs.h
+++ b/pwmanager/pwmanager/pwmprefs.h
@@ -1,150 +1,151 @@
/*
This file is part of PwManager/Pi
Copyright (c) 2004 Ulf Schenk
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program 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 General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
As a special exception, permission is given to link this program
with any edition of Qt, and distribute the resulting executable,
without including the source code for Qt in the source distribution.
$Id$
*/
#ifndef PWMPREFS_H
#define PWMPREFS_H
#include <qstringlist.h>
#include <qsize.h>
#include <kpimprefs.h>
class KConfig;
#define conf() PWMPrefs::instance()
#define CONF_DEFAULT_PWTIMEOUT 10 /* 10 sec */
#define CONF_DEFAULT_LOCKTIMEOUT 0 /* 0 == disable */
#define CONF_DEFAULT_TRAY true
#define CONF_DEFAULT_UNLOCKONOPEN false
#define CONF_DEFAULT_MAINVIEWSTYLE 0
#define CONF_DEFAULT_COMPRESSION 0x01 /* gzip */
#define CONF_DEFAULT_AUTOMINIMIZE false
#define CONF_DEFAULT_BROWSERCOMMAND ""
#define CONF_DEFAULT_XTERMCOMMAND "konsole -e"
#define CONF_DEFAULT_FILEPERMISSIONS 0600
#define CONF_DEFAULT_MAKEFILEBACKUP false
#define CONF_DEFAULT_AUTOSTART_DEEPL true
#define CONF_DEFAULT_AUTODEEPLOCK true
#define CONF_DEFAULT_KWALLETEMU true
#define CONF_DEFAULT_MINIMIZELOCK 2 /* deep-lock */
#define CONF_DEFAULT_NEWENTRLOCKSTAT true /* locked */
#define CONF_DEFAULT_WNDCLOSE true /* don't minimize to tray */
class PWMPrefs : public KPimPrefs
{
public:
virtual ~PWMPrefs();
static PWMPrefs *instance();
public:
/* functions for reading the configuration settings */
/* GLOBAL */
QString confGlobAutoStart();
QString confGlobBrowserCommand();
QString confGlobXtermCommand();
QFont confGlobEntryFont();
int confGlobPwTimeout();
int confGlobLockTimeout();
int confGlobCompression();
int confGlobFilePermissions();
int confGlobMinimizeLock();
bool confGlobUnlockOnOpen();
bool confGlobTray();
bool confGlobMakeFileBackup();
bool confGlobAutostartDeepLocked();
bool confGlobAutoDeepLock();
bool confGlobKwalletEmu();
bool confGlobNewEntrLockStat();
/* WND */
QSize confWndMainWndSize();
int confWndMainViewStyle();
bool confWndAutoMinimizeOnStart();
bool confWndClose();
public:
/* functions for writing the configuration settings */
/* GLOBAL */
void confGlobAutoStart(const QString &e);
void confGlobBrowserCommand(const QString &e);
void confGlobXtermCommand(const QString &e);
void confGlobEntryFont(const QFont &e);
void confGlobPwTimeout(int e);
void confGlobLockTimeout(int e);
void confGlobCompression(int e);
void confGlobFilePermissions(int e);
void confGlobMinimizeLock(int e);
void confGlobUnlockOnOpen(bool e);
void confGlobTray(bool e);
void confGlobMakeFileBackup(bool e);
void confGlobAutostartDeepLocked(bool e);
void confGlobAutoDeepLock(bool e);
void confGlobKwalletEmu(bool e);
void confGlobNewEntrLockStat(bool e);
/* WND */
void confWndMainWndSize(const QSize &e);
void confWndMainViewStyle(int e);
void confWndAutoMinimizeOnStart(bool e);
void confWndClose(bool e);
QString mAutoStart;
QString mBrowserCommand;
QString mXTermCommand;
QFont mEntryFont;
int mPwTimeout;
int mLockTimeout;
int mCompression;
int mFilePermissions;
int mMinimizeLock;
bool mUnlockOnOpen;
bool mTray;
bool mMakeFileBackup;
bool mAutostartDeeplocked;
bool mAutoDeeplock;
bool mKWalletEmu;
bool mNewEntrLockStat;
QSize mMainWndSize;
int mMainViewStyle;
bool mAutoMinimizeOnStart;
bool mClose;
//US ENH
QValueList<int> mCommentSplitter;
+ QValueList<int> mCategorySplitter;
// US introduce a nonconst way to return the config object.
KConfig* getConfig();
private:
PWMPrefs();
static PWMPrefs *sInstance;
};
#endif
diff --git a/pwmanager/pwmanager/pwmviewstyle.cpp b/pwmanager/pwmanager/pwmviewstyle.cpp
index 9704615..0af1473 100644
--- a/pwmanager/pwmanager/pwmviewstyle.cpp
+++ b/pwmanager/pwmanager/pwmviewstyle.cpp
@@ -1,239 +1,239 @@
/***************************************************************************
* *
* copyright (C) 2004 by Michael Buesch *
* email: mbuesch@freenet.de *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License version 2 *
* as published by the Free Software Foundation. *
* *
***************************************************************************/
/***************************************************************************
* copyright (C) 2004 by Ulf Schenk
* This file is originaly based on version 1.0.1 of pwmanager
* and was modified to run on embedded devices that run microkde
*
* $Id$
**************************************************************************/
#include "pwmviewstyle.h"
#include "pwmexception.h"
#include "pwmviewstyle_0.h"
#include "pwmviewstyle_1.h"
#include "listviewpwm.h"
#include "pwmview.h"
#include "commentbox.h"
#ifndef PWM_EMBEDDED
#include "configuration.h"
#else
#include "pwmprefs.h"
#endif
PwMViewStyle::PwMViewStyle(QWidget *parent, const char *name)
: QWidget(parent, name)
{
curStyle = style_notset;
s0 = 0;
s1 = 0;
}
PwMViewStyle::~PwMViewStyle()
{
//US ENH : store the size of the listviewcolumns
switch (curStyle)
{
case style_0:
s0->saveSettings(PWMPrefs::instance());
break;
case style_1:
s1->saveSettings(PWMPrefs::instance());
break;
default:
BUG();
}
- PWMPrefs::instance()->getConfig()->sync();
+ PWMPrefs::instance()->writeConfig();
delete_ifnot_null(s0);
delete_ifnot_null(s1);
}
void PwMViewStyle::initStyle(style_t style)
{
printDebug(string("initializing style ") + tostr(style));
bool wasMaximized = v->isMaximized();
if (v->isVisible())
v->hide();
switch (style) {
case style_0:
delete_ifnot_null(s0);
delete_ifnot_null(s1);
s0 = new PwMViewStyle_0(v);
lv = s0->getLv();
commentBox = s0->getCommentBox();
break;
case style_1:
delete_ifnot_null(s0);
delete_ifnot_null(s1);
s1 = new PwMViewStyle_1(v);
lv = s1->getLv();
commentBox = s1->getCommentBox();
break;
default:
BUG();
return;
}
curStyle = style;
connect(lv, SIGNAL(pressed(QListViewItem *)),
v, SLOT(handleToggle(QListViewItem *)));
connect(lv, SIGNAL(rightButtonClicked(QListViewItem *, const QPoint &, int)),
v, SLOT(handleRightClick(QListViewItem *, const QPoint &, int)));
connect(lv, SIGNAL(clicked(QListViewItem *)),
v, SLOT(refreshCommentTextEdit(QListViewItem *)));
lv->addColumn(i18n("Description"), 180);
lv->addColumn(i18n("Username"), 150);
lv->addColumn(i18n("Password"), 150);
lv->addColumn(i18n("URL"), 180);
lv->addColumn(i18n("Launcher"), 120);
v->tmpReEnableSort();
//US ENH : load the size of the listviewcolumns
- switch (style)
+ switch (curStyle)
{
case style_0:
s0->restoreSettings(PWMPrefs::instance());
break;
case style_1:
s1->restoreSettings(PWMPrefs::instance());
break;
default:
BUG();
}
resizeView(v->size());
v->updateView();
if (wasMaximized) {
v->showMaximized();
} else {
v->show();
}
connect(lv, SIGNAL(layoutChanged()),
v, SLOT(reorgLp()));
}
void PwMViewStyle::resizeView(const QSize &size)
{
switch (curStyle) {
case style_0:
PWM_ASSERT(s0);
s0->resize(size);
return;
case style_1:
PWM_ASSERT(s1);
s1->resize(size);
return;
default:
BUG();
}
}
QString PwMViewStyle::getCurrentCategory()
{
switch (curStyle) {
case style_0:
PWM_ASSERT(s0);
return s0->getCurrentCategory();
case style_1:
PWM_ASSERT(s1);
return s1->getCurrentCategory();
default:
BUG();
}
return "";
}
void PwMViewStyle::addCategory(const QString &cat)
{
switch (curStyle) {
case style_0:
PWM_ASSERT(s0);
s0->addCategory(cat);
return;
case style_1:
PWM_ASSERT(s1);
s1->addCategory(cat);
return;
default:
BUG();
}
}
void PwMViewStyle::delCategory(const QString &cat)
{
switch (curStyle) {
case style_0:
PWM_ASSERT(s0);
s0->delCategory(cat);
return;
case style_1:
PWM_ASSERT(s1);
s1->delCategory(cat);
return;
default:
BUG();
}
}
void PwMViewStyle::delAllCategories()
{
switch (curStyle) {
case style_0:
PWM_ASSERT(s0);
s0->delAllCategories();
return;
case style_1:
PWM_ASSERT(s1);
s1->delAllCategories();
return;
default:
BUG();
}
}
void PwMViewStyle::selectCategory(const QString &cat)
{
switch (curStyle) {
case style_0:
PWM_ASSERT(s0);
s0->selectCategory(cat);
return;
case style_1:
PWM_ASSERT(s1);
s1->selectCategory(cat);
return;
default:
BUG();
}
}
int PwMViewStyle::numCategories()
{
switch (curStyle) {
case style_0:
PWM_ASSERT(s0);
return s0->numCategories();
case style_1:
PWM_ASSERT(s1);
return s1->numCategories();
default:
BUG();
}
return 0;
}
#ifndef PWM_EMBEDDED
#include "pwmviewstyle.moc"
#endif
diff --git a/pwmanager/pwmanager/pwmviewstyle_1.cpp b/pwmanager/pwmanager/pwmviewstyle_1.cpp
index 8b2d6d3..374c698 100644
--- a/pwmanager/pwmanager/pwmviewstyle_1.cpp
+++ b/pwmanager/pwmanager/pwmviewstyle_1.cpp
@@ -1,150 +1,152 @@
/***************************************************************************
* *
* copyright (C) 2004 by Michael Buesch *
* email: mbuesch@freenet.de *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License version 2 *
* as published by the Free Software Foundation. *
* *
***************************************************************************/
/***************************************************************************
* copyright (C) 2004 by Ulf Schenk
* This file is originaly based on version 1.0.1 of pwmanager
* and was modified to run on embedded devices that run microkde
*
* $Id$
**************************************************************************/
#include "pwmviewstyle_1.h"
#include "pwmview.h"
#include "listviewpwm.h"
#include "commentbox.h"
#include <klocale.h>
#include "pwmprefs.h"
#define INITIAL_CATEGORIES_WIDTH 100
PwMViewStyle_1::PwMViewStyle_1(PwMView *view)
: QObject()
{
#ifndef PWM_EMBEDDED
splitter = new QSplitter(view);
#else
splitter = new KDGanttMinimizeSplitter( Qt::Horizontal, view);
splitter->setMinimizeDirection ( KDGanttMinimizeSplitter::Right );
//US topLayout->addWidget(mMiniSplitter );
#endif
vbox1 = new QVBox(splitter);
categoriesTitle = new QLabel(vbox1);
categoriesList = new QListBox(vbox1);
#ifndef PWM_EMBEDDED
splitter2 = new QSplitter(splitter);
splitter2->setOrientation(Qt::Vertical);
#else
splitter2 = new KDGanttMinimizeSplitter( Qt::Vertical, splitter);
splitter2->setMinimizeDirection ( KDGanttMinimizeSplitter::Right );
//US topLayout->addWidget(mMiniSplitter );
#endif
lv = new ListViewPwM(splitter2);
commentBox = new CommentBox(splitter2);
// set sizes and styles
- commentBox->resize(commentBox->size().width(), 60);
+ //US commentBox->resize(commentBox->size().width(), 60);
QValueList<int> sizes;
#ifndef PWM_EMBEDDED
sizes.push_back(INITIAL_CATEGORIES_WIDTH);
sizes.push_back(view->height() - INITIAL_CATEGORIES_WIDTH);
#else
sizes.append(INITIAL_CATEGORIES_WIDTH);
sizes.append(view->height() - INITIAL_CATEGORIES_WIDTH);
#endif
- splitter->setSizes(sizes);
+ //US splitter->setSizes(sizes);
categoriesTitle->setAlignment(Qt::AlignHCenter);
#ifndef PWM_EMBEDDED
categoriesTitle->setFrameShape(QFrame::MenuBarPanel);
#else
categoriesTitle->setFrameShape(QFrame::StyledPanel);
#endif
categoriesTitle->setText(i18n("Categories:"));
catCtxMenu = new QPopupMenu(view);
catCtxMenu->insertItem(i18n("&Rename"),
view, SLOT(renCatButton_slot()));
catCtxMenu->insertItem(i18n("&Delete"),
view, SLOT(delCatButton_slot()));
// connections
connect(categoriesList, SIGNAL(highlighted(int)),
view, SLOT(shiftToView()));
connect(categoriesList,
SIGNAL(rightButtonClicked(QListBoxItem *, const QPoint &)),
this,
SLOT(catRightClick(QListBoxItem *, const QPoint &)));
}
PwMViewStyle_1::~PwMViewStyle_1()
{
delete catCtxMenu;
delete splitter;
}
void PwMViewStyle_1::catRightClick(QListBoxItem *item, const QPoint &point)
{
if (!item)
return;
catCtxMenu->move(point);
catCtxMenu->show();
}
void PwMViewStyle_1::delCategory(const QString &cat)
{
PWM_ASSERT(categoriesList);
int i, count = categoriesList->count();
for (i = 0; i < count; ++i) {
if (categoriesList->text(i) == cat) {
categoriesList->removeItem(i);
return;
}
}
BUG();
}
void PwMViewStyle_1::selectCategory(const QString &cat)
{
PWM_ASSERT(categoriesList);
int i, count = categoriesList->count();
for (i = 0; i < count; ++i) {
if (categoriesList->text(i) == cat) {
categoriesList->setCurrentItem(i);
return;
}
}
// fall back to 0
categoriesList->setCurrentItem(0);
}
//US ENH: I need a place to load the view dependend settings. Eg. splittersize
void PwMViewStyle_1::restoreSettings(PWMPrefs* prefs)
{
//load and store the size of the listviewcolumns
lv->restoreLayout(prefs->getConfig(), "listview");
+ splitter->setSizes( prefs->mCategorySplitter );
splitter2->setSizes( prefs->mCommentSplitter );
}
//US ENH: I need a place to load the view dependend settings. Eg. splittersize
void PwMViewStyle_1::saveSettings(PWMPrefs* prefs)
{
//store the size of the listviewcolumns
lv->saveLayout(prefs->getConfig(), "listview");
+ prefs->mCategorySplitter = splitter->sizes();
prefs->mCommentSplitter = splitter2->sizes();
}
#ifndef PWM_EMBEDDED
#include "pwmviewstyle_1.moc"
#endif