Blokkal

an Extendable KDE Blogging Client

• Download
• Screenshots
• LiveJournal Community
• API Documentation
• Contact

• Class Hierarchy
• Class List
• File List
• Class Members

blokkalwalletmanager.cpp

/***************************************************************************
 *   Copyright (C) 2006 by Martin Müller                                   *
 *   orvio@orvio.de                                                        *
 *                                                                         *
 *   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.             *
 ***************************************************************************/
#include "blokkalwalletmanager.h"
#include "blokkalwalletmanager.moc"

#include "blokkalui/globalsettings.h"

#include <kwallet.h>
#include <kstandarddirs.h>
#include <kdebug.h>

#include <QTimer>

#include <iostream>

class Blokkal::WalletManagerPrivate {
public:
        WalletManagerPrivate( void ):
        wallet( 0 ),
        signal( new WalletManagerSignal() ),
        openTimer( 0 ) {}
        
        ~WalletManagerPrivate( void )
        {
                delete signal;
                delete wallet;
        }
        
        KWallet::Wallet * wallet;
        WalletManagerSignal * signal;
        QTimer * openTimer;

        Blokkal::WalletManager instance;
};

K_GLOBAL_STATIC( Blokkal::WalletManagerPrivate, _bwmp );

Blokkal::WalletManager::WalletManager( void ) :
QObject( 0 )
{
        setObjectName( "BlokkalWalletManager" );
}

Blokkal::WalletManager::~WalletManager( void )
{
}

Blokkal::WalletManager * Blokkal::WalletManager::self( void )
{
        return &_bwmp->instance;
}

void Blokkal::WalletManager::openWallet( QObject * receiver, const char * slot )
{
        if( !_bwmp->wallet ) {
                //sometimes opening the wallet does not work correctly
                //on session restore.
                //the wallet is opened, but the calling app is never notified
                //the wallet manager will give "anonymous" or "DCOPServer" or
                //"konqueror" as the requesing app's name, but never the correct one.
                //so if we do not get a feedback after a minute, the process is repeated.
                _bwmp->openTimer = new QTimer( this );
                connect( _bwmp->openTimer, SIGNAL( timeout( void ) ),
                         this, SLOT( retryOpen( void ) ) );
                _bwmp->openTimer->start( 1 * 60 * 1000 );
                _bwmp->wallet = KWallet::Wallet::openWallet( KWallet::Wallet::NetworkWallet(),
                                                         Blokkal::Ui::GlobalSettings::self()->mainWindowWId(),
                                                         KWallet::Wallet::Asynchronous );
                connect( _bwmp->wallet, SIGNAL( walletOpened( bool ) ),
                         this, SLOT( slotWalletOpened( void ) ) );
        }

        receiver->connect( _bwmp->signal, SIGNAL( walletOpened( KWallet::Wallet * ) ), slot );
        
        if( _bwmp->wallet->isOpen() ) {
                QTimer::singleShot( 0, this, SLOT( slotWalletOpened( void ) ) );
        }
}

void Blokkal::WalletManager::slotWalletOpened( void )
{
        if( _bwmp->openTimer ) {
                _bwmp->openTimer->stop();
                delete _bwmp->openTimer;
                _bwmp->openTimer = 0;
        }
        
        if( _bwmp->wallet->isOpen() ) {
                const QString appFolder = "Blokkal";
                if( !_bwmp->wallet->hasFolder( appFolder ) ) {
                        _bwmp->wallet->createFolder( appFolder);
                }
                _bwmp->wallet->setFolder( appFolder );
                emit _bwmp->signal->walletOpened( _bwmp->wallet );
        }
        else {
                emit _bwmp->signal->walletOpened( 0 );
                delete _bwmp->wallet;
                _bwmp->wallet = 0;
        }
        
        
        delete _bwmp->signal;
        _bwmp->signal = new WalletManagerSignal();
}

void Blokkal::WalletManager::retryOpen( void )
{
        if( _bwmp->wallet && !_bwmp->wallet->isOpen() ) {
                delete _bwmp->wallet;
                _bwmp->wallet = KWallet::Wallet::openWallet( KWallet::Wallet::NetworkWallet(),
                                                         Blokkal::Ui::GlobalSettings::self()->mainWindowWId(),
                                                         KWallet::Wallet::Asynchronous );
                connect( _bwmp->wallet, SIGNAL( walletOpened( bool ) ),
                         this, SLOT( slotWalletOpened( void ) ) );

        }
}

//---------------
//PasswordDeleter
//---------------
class Blokkal::PasswordDeleter::Private {
public:
        Private( const QString & accountId ) :
        accountId( accountId ){}

        QString accountId;
};

Blokkal::PasswordDeleter::PasswordDeleter( const QString & accountId ):
QObject(),
d( new Private( accountId ) )
{
        WalletManager::self()->openWallet( this, SLOT( slotWalletOpened( KWallet::Wallet * ) ) );
}

Blokkal::PasswordDeleter::~PasswordDeleter( void )
{
        delete d;
}

void Blokkal::PasswordDeleter::slotWalletOpened( KWallet::Wallet * wallet )
{
        if( wallet && wallet->hasEntry( d->accountId ) ) {
                wallet->removeEntry( d->accountId );
        }

        deleteLater();
}