Blokkal

an Extendable KDE Blogging Client

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

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

blokkalfileengine.cpp

/***************************************************************************
 *   Copyright (C) 2007 - 2008 by Martin Mueller                           *
 *   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 "blokkalfileengine.h"

#include "blokkalaccount.h"
#include "blokkalaccountmanager.h"
#include "blokkalblog.h"
#include "blokkalprotocol.h"
#include "blokkalpluginmanager.h"
#include "blokkalutils.h"

#include <QBuffer>
#include <QPixmap>

#include <kurl.h>
#include <kdebug.h>
#include <kiconloader.h>
#include <kicon.h>

//-----------------
//FileEngineHandler
//-----------------
QAbstractFileEngine * Blokkal::FileEngineHandler::create( const QString & fileName ) const
{
        KUrl url( fileName );
        if( url.protocol() != "blokkal" || url.hasHost() || !url.hasPath() ) {
                return 0;
        }

        FileEngine * const engine = new FileEngine();
        engine->setFileName( fileName );
        return engine;
}

//----------
//FileEngine
//----------
class Blokkal::FileEngine::Private {
public:
        Private( void ) :
        buffer( new QBuffer() ){}

        QBuffer * const buffer;
        KUrl url;
};

Blokkal::FileEngine::FileEngine( void ) :
QAbstractFileEngine(),
d( new Private() )
{
}

Blokkal::FileEngine::~FileEngine( void )
{
        d->buffer->close();
        delete d->buffer;
        delete d;
}

bool Blokkal::FileEngine::caseSensitive( void ) const
{
        return TRUE;
}

bool Blokkal::FileEngine::close( void )
{
        d->buffer->close();
        return TRUE;
}

bool Blokkal::FileEngine::copy( const QString & newName )
{
        Q_UNUSED( newName );
        return FALSE;
}

QStringList Blokkal::FileEngine::entryList( QDir::Filters filters, const QStringList & filterNames ) const
{
        Q_UNUSED( filters );
        Q_UNUSED( filterNames );
        return QStringList();
}

QAbstractFileEngine::FileFlags Blokkal::FileEngine::fileFlags( FileFlags type ) const
{
        Q_UNUSED( type );
        return 0;
}

QString Blokkal::FileEngine::fileName( FileName file ) const
{
        Q_UNUSED( file );
        return d->url.url();
}

QDateTime Blokkal::FileEngine::fileTime( FileTime time ) const
{
        Q_UNUSED( time );
        return QDateTime();
}

bool Blokkal::FileEngine::isRelativePath( void ) const
{
        return FALSE;
}

bool Blokkal::FileEngine::isSequential( void ) const
{
        return FALSE;
}

bool Blokkal::FileEngine::mkdir( const QString & dirName, bool createParentDirectories ) const
{
        Q_UNUSED( dirName );
        Q_UNUSED( createParentDirectories );
        return FALSE;
}

bool Blokkal::FileEngine::open( QIODevice::OpenMode mode )
{
        QStringList path = d->url.path( KUrl::RemoveTrailingSlash ).split( '/', QString::KeepEmptyParts );
        path.removeFirst();
        QPixmap icon;

        if( path[0] == "accounts" ) {
                //Testing:
                //blokkal:///accounts/[accountId]/icon
                //blokkal:///accounts/[accountId]/stateicon
                //blokkal:///accounts/[accountId]/blogs/[blogId]/icon
                //blokkal:///accounts/[accountId]/blogs/[blogId]/stateicon
                if( path.size() >= 3 ) {
                        QString accountName = path[1];
                        Account * account = AccountManager::self()->account( accountName );
                        int accountSpan = 0;
                        
                        if( !account ) {
                                accountSpan = 1;
                                for( ;path.size() >= ( 3 + accountSpan ); ++accountSpan ) {
                                        //probe deeper to identify accounts with names containing a slash
                                        accountName += '/' + path[1 + accountSpan];
                                        account = AccountManager::self()->account( accountName );
                                        if( account ) {
                                                break;
                                        }
                                }
                        }
                        
                        if( account ) {
                                if( path[2 + accountSpan] == "icon" ) {
                                        icon = account->icon().pixmap(16,16);
                                }
                                else if( path[2 + accountSpan] == "stateicon" ) {
                                        icon = account->isConnected() ? account->icon().pixmap(16,16) : Utils::fadePixmap( account->icon().pixmap(16,16) );
                                }
                                else if( path[2 + accountSpan] == "blogs"
                                         && path.size() == ( 5 + accountSpan ) )
                                {
                                        //Testing:
                                        //blokkal:///accounts/[accountId]/blogs/[blogId]/icon
                                        //blokkal:///accounts/[accountId]/blogs/[blogId]/stateicon
                                        Blog * blog = account->blog( path[3 + accountSpan] );
                                        if( blog ) {
                                                if( path[4 + accountSpan] == "icon" ) {
                                                        icon = blog->icon().pixmap(16,16);
                                                }
                                                else if( path[4 + accountSpan] == "stateicon" ) {
                                                        icon = blog->account()->isConnected() ? blog->icon().pixmap(16,16) : Utils::fadePixmap( blog->icon().pixmap(16,16) );
                                                }
                                                else {
                                                        kDebug() << "no such blog resource: " << path[4 + accountSpan] << endl;
                                                }
                                        }
                                        else {
                                                kDebug() << "no such blog: " << path[3 + accountSpan] << endl;
                                        }
                                }
                                else {
                                        kDebug() << "no such account resource: " << path[2 + accountSpan] << endl;
                                }
                        }
                        else {
                                        kDebug() << "no such account: " << accountName << endl;
                        }
                }
                else {
                        kDebug() << "incomplete account resource path" << endl;
                }
        }
        else if( path[0] == "protocols" ) {
                //Testing:
                //blokkal:///protocols/[protocolname]/icon
                if( path.size() == 3 ) {
                        Protocol * protocol = PluginManager::self()->protocol( path[1] );
                        if( protocol ) {
                                if( path[2] == "icon") {
                                        icon = protocol->icon().pixmap(16,16);
                                }
                                else {
                                        kDebug() << "no such protocol resource: " << path[2] << endl;
                                }
                        }
                        else {
                                kDebug() << "no such protocol: " << path[1] << endl;
                        }
                }
                else {
                        kDebug() << "incomplete protocol resource path" << endl;
                }
        }
        else if( path[0] == "smallicons") {
                //Testing
                //blokkal:///smallicons/[iconname]
                if( path.size() == 2 ) {
                        icon = SmallIcon( path[1] );
                }
                else {
                        kDebug() << "incomplete smallicons resource path" << endl;
                }               
        }
        else {
                kDebug() << "unknown base resource name: " << path[0] << endl;
        }

        if( !icon.isNull() ) {
                d->buffer->open( QIODevice::WriteOnly );
                icon.save( d->buffer, "PNG" );
                d->buffer->close();
                d->buffer->open( mode );
        }

        return !icon.isNull();
}

QString Blokkal::FileEngine::owner( FileOwner owner ) const
{
        Q_UNUSED( owner );
        return QString::null;
}

unsigned int Blokkal::FileEngine::ownerId( FileOwner owner ) const
{
        Q_UNUSED( owner );
        return -2;
}

qint64 Blokkal::FileEngine::pos( void ) const
{
        return d->buffer->pos();
}

qint64 Blokkal::FileEngine::read( char * data, qint64 maxlen )
{
        return d->buffer->read( data, maxlen );
}

qint64 Blokkal::FileEngine::readLine( char * data, qint64 maxlen )
{
        return read( data, maxlen );
}

bool Blokkal::FileEngine::remove( void )
{
        return FALSE;
}

bool Blokkal::FileEngine::rename( const QString & newName )
{
        Q_UNUSED( newName );
        return FALSE;
}

bool Blokkal::FileEngine::rmdir( const QString & dirName, bool recurseParentDirectories ) const
{
        Q_UNUSED( dirName );
        Q_UNUSED( recurseParentDirectories );
        return FALSE;
}

bool Blokkal::FileEngine::seek( qint64 offset )
{
        return d->buffer->seek( offset );
}

void Blokkal::FileEngine::setFileName( const QString & file )
{
        d->url = KUrl( file );
}

bool Blokkal::FileEngine::setPermissions( uint perms )
{
        Q_UNUSED( perms );
        return FALSE;
}

bool Blokkal::FileEngine::setSize( qint64 size )
{
        Q_UNUSED( size );
        return FALSE;
}

qint64 Blokkal::FileEngine::size( void ) const
{
        return d->buffer->size();
}

qint64 Blokkal::FileEngine::write( const char * data, qint64 len )
{
        Q_UNUSED( data );
        Q_UNUSED( len );
        return -1;
}