Blokkal

an Extendable KDE Blogging Client

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

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

blokkalentry.cpp

/***************************************************************************
 *   Copyright (C) 2006 - 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 "blokkalentry.h"
#include "blokkalentry.moc"

#include "blokkalblog.h"
#include "blokkalaccount.h"
#include "blokkalaccountmanager.h"
#include "blokkalprotocol.h"
#include "blokkalpluginmanager.h"
#include "blokkalui/viewmanager.h"
#include "blokkalui/blogchooser.h"
#include "blokkalui/globalsettings.h"

#include <klocale.h>
#include <kdebug.h>

#include <QDomElement>
#include <QFile>

class Blokkal::Entry::Private
{
public:
        Private( void ) :
        internalDocument( QDomDocument( "BlokkalEntry" ) ),
        refcount( 0 ),
        isDirty( FALSE )
        {
                internalDocument.appendChild( internalDocument.createElement( "entry" ) );
        }

        QDomDocument internalDocument;
        Blokkal::Blog * blog;
        int refcount;
        bool isDirty;
};

Blokkal::Entry::Entry( Blog * parentBlog, const QString & id, const KUrl & url ) :
QObject( parentBlog ),
Blokkal::ConfigBase(),
d( new Private() )
{
        setNode( d->internalDocument.firstChild().toElement() );
        
        d->blog = parentBlog;

        node().setAttribute( "blog", parentBlog->id() );
        node().setAttribute( "account", parentBlog->account()->id() );
        node().setAttribute( "protocol", parentBlog->account()->protocol()->pluginName() );
        node().setAttribute( "id", id );
        node().setAttribute( "url", url.url() );
}

Blokkal::Entry::~Entry( void )
{
        emit entryDestroyed( this );
        delete d;
}

QString Blokkal::Entry::id( void ) const
{
        return node().attribute( "id" );
}

Blokkal::Blog * Blokkal::Entry::blog( void ) const
{
        return d->blog;
}

KIcon Blokkal::Entry::icon( void ) const
{
        return blog()->icon();
}

QString Blokkal::Entry::text( void ) const
{
        return node().namedItem( "text" ).firstChild().nodeValue();
}

void Blokkal::Entry::setText( const QString & text )
{
        QDomElement textParent = d->internalDocument.firstChild().namedItem( "text" ).toElement();
        if( textParent.isNull() ) {
                textParent = d->internalDocument.createElement( "text" );
                d->internalDocument.firstChild().appendChild( textParent );
                textParent.appendChild( d->internalDocument.createTextNode( 0 ) );
        }

        textParent.firstChild().toText().setData( text );
}

QString Blokkal::Entry::subject( void ) const
{
        return d->internalDocument.firstChild().namedItem( "subject" ).firstChild().nodeValue();
}


QString Blokkal::Entry::preview( void ) const
{
        QString preview = subject();

        if( !preview.isEmpty() ) {
                return preview;
        }

        preview = text();
        
        if( preview.isEmpty() ) {
                return i18n( "<No Subject>" );
        }

        if( preview.length() > 100 ) {
                preview = preview.left( 100 );
                preview.replace( 97, 3, i18n( "..." ) );
        }

        return preview;
}

void Blokkal::Entry::setSubject( const QString & subject )
{
        QDomElement subjectParent = d->internalDocument.firstChild().namedItem( "subject" ).toElement();
        
        if( subjectParent.isNull() ) {
                subjectParent = d->internalDocument.createElement( "subject" );
                d->internalDocument.firstChild().appendChild( subjectParent );
                subjectParent.appendChild( d->internalDocument.createTextNode( 0 ) );
        }

        subjectParent.firstChild().toText().setData( subject );
}

QDateTime Blokkal::Entry::date( void ) const
{
        QDateTime entryDate;
        QDomElement entryElement = d->internalDocument.firstChild().toElement();
        
        if( entryElement.hasAttribute( "date" ) ) {
                entryDate.setTime_t( entryElement.attribute( "date" ).toUInt() );
        }
        
        return entryDate;
}

void Blokkal::Entry::setDate( const QDateTime & date )
{
        d->internalDocument.firstChild().toElement().setAttribute( "date", date.toTime_t() );
}

Blokkal::Ui::View * Blokkal::Entry::view( void )
{
        return Ui::ViewManager::self()->view( this );
}

void Blokkal::Entry::ref( void )
{
        d->refcount++;
}

void Blokkal::Entry::deref( void )
{
        d->refcount--;
        if( d->refcount < 1 && !Blokkal::Ui::ViewManager::hasView( this ) ) {
                deleteLater();
        }
}

QString Blokkal::Entry::fileName( bool check ) const
{
        QString fileName = node().attribute( "filename" );
        if( check && !QFile::exists( fileName) ) {
                fileName = QString::null;
                setFileName( fileName );
                
        }
        return fileName;
}

void Blokkal::Entry::setFileName( const QString & fileName ) const
{
        node().setAttribute( "filename", fileName );
}

bool Blokkal::Entry::saveAs( const QString & fileName )
{
        QFile file( fileName );
   if( !file.open( QIODevice::WriteOnly ) ) {
                kError() << "error opening file for reading" << file.fileName() << endl;
           return FALSE;
        }

        saveProperties();
        setFileName( QString::null ); //don't save the filename in the file
        
   QTextStream fileStream( &file );
        node().ownerDocument().save( fileStream, 3 );
   file.close();

        setFileName( fileName );
        return TRUE;
}

Blokkal::Entry * Blokkal::Entry::open( const QString & fileName, bool * canceled, bool neverAsk )
{
        bool error = FALSE;
        
        if( canceled ) {
                *canceled = FALSE;
        }

        QDomDocument document( "BlokkalEntry" );
        
        //load the file
        QFile file( fileName );
        if( file.open( QIODevice::ReadOnly ) ) {
                if( !document.setContent( &file ) ) {
                        kError() << "error parsing file " << file.fileName() << endl;
                        error = TRUE;
                }
                file.close();
        }
        else {
                kError() << "error opening file " << file.fileName() << endl;
                error = TRUE;
        }

        if( error ) {
                return 0;
        }

        //examine content
        QDomElement entryNode = document.firstChild().toElement();
        if( entryNode.isNull() ) {
                kError() << "malformed file " << file.fileName() << endl;
                return 0;
        }

        const QString blogId = entryNode.attribute( "blog" );
        const QString accountId = entryNode.attribute( "account" );
        const QString protocolName = entryNode.attribute( "protocol" );

        QString message;
        Blog * blog = 0;
        Account * account = AccountManager::self()->account( accountId );
        if( !account ) {
                message = i18n( "No account could be found for this entry. Please select the correct account and blog manually." );
        }
        else {
                blog = account->blog( blogId );
                if( !blog || account->protocol()->pluginName() != protocolName ) {
                        if( blog ) {
                                message = i18n( "An account and a blog for the entry have been found. However, the protocol does not match. Please review the selection." );
                        }
                        else {
                                message = i18n( "An account for the entry has been found. However, the account does not contain the blog this entry belongs to. Please select the correct blog manually.");
                        }
                }
        }

        if( !message.isEmpty() ) {
                if( neverAsk ) {
                        return 0;
                }
                
                Ui::BlogChooserDialog * dialog = new Ui::BlogChooserDialog( message, Ui::GlobalSettings::self()->mainWidget() );
                dialog->blogChooser()->setAccount( account );
                dialog->blogChooser()->setBlog( blog );
                blog = 0;

                if( dialog->exec() ) {
                        blog = dialog->blogChooser()->blog();
                }
                else if( canceled ) {
                        *canceled = TRUE;
                }

                delete dialog;
        }

        if( !blog  ) {
                return 0;
        }
        
        Entry * entry = blog->createEntry();
        entry->d->internalDocument = document;
        entry->setNode( entryNode );
        entry->setFileName( fileName );

        entry->node().setAttribute( "blog", blog->id() );
        entry->node().setAttribute( "account", blog->account()->id() );
        entry->node().setAttribute( "protocol", blog->account()->protocol()->pluginName() );
        entry->readProperties();
        
        return entry;
}

Blokkal::Ui::EntryExtensionWidget * Blokkal::Entry::createExtensionWidget( Ui::EntryExtensionWidget::ExtensionWidget /*extension*/, Blokkal::Ui::EditEntryWidget * /*parent*/ )
{
        return 0;
}

QStringList Blokkal::Entry::categories( void ) const
{
        QStringList ids;

        //read category childnodes for each item
        for( QDomNode currentNode = node().firstChild();
             !currentNode.isNull();
             currentNode = currentNode.nextSibling()
           )
        {
                if( currentNode.isElement()
                    && currentNode.nodeName() == "category" )
                {
                        ids.append( currentNode.toElement().attribute( "id" ) );
                }
        }       

        return ids;
}

void Blokkal::Entry::setCategories( const QStringList & ids )
{
        for( QDomNode currentNode = node().firstChild();
             !currentNode.isNull();)
        {
                if( currentNode.isElement()
                    && currentNode.nodeName() == "category" )
                {
                        QDomNode obsoleteNode = currentNode;
                        currentNode = currentNode.nextSibling();
                        node().removeChild( obsoleteNode );
                }
                else {
                        currentNode = currentNode.nextSibling();
                }
        }

        //create category childnodes for each item
        for( QStringList::ConstIterator it = ids.begin();
             it != ids.end();
             ++it )
        {
                QDomElement categoryElement = node().ownerDocument().createElement( "category" );
                node().appendChild( categoryElement );
                categoryElement.setAttribute( "id", *it );
        }
}

void Blokkal::Entry::merge( const Blokkal::Entry * entry )
{
        setDate( entry->date() );
        setSubject( entry->subject() );
        setText( entry->text() );
}

bool Blokkal::Entry::isDirty( void ) const
{
        return d->isDirty;
}

void Blokkal::Entry::setDirty( bool dirty )
{
        d->isDirty = dirty;
}

KUrl Blokkal::Entry::url( void ) const
{
        return node().attribute( "url" );
}

void Blokkal::Entry::saveProperties( void )
{
}

void Blokkal::Entry::readProperties( void )
{
}