Blokkal

an Extendable KDE Blogging Client

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

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

blokkalconfigbase.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 "blokkalconfigbase.h"

#include <QDomElement>

class Blokkal::ConfigBase::Private
{
public:
        Private( QDomElement configNode ) :
        node( configNode ) {}

        QDomElement node;
};


Blokkal::ConfigBase::ConfigBase( void ) :
d( new Private( QDomElement() ) )
{
}

Blokkal::ConfigBase::ConfigBase( QDomElement configNode ) :
d( new Private( configNode ) )
{
}

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

void Blokkal::ConfigBase::setNode( QDomElement configNode )
{
        d->node = configNode;
}

QDomElement Blokkal::ConfigBase::node( void ) const
{
        return d->node;
}

QDomElement Blokkal::ConfigBase::findPropertyNode( const QString & name ) const
{
        for( QDomNode currentNode = node().firstChild();
             !currentNode.isNull();
             currentNode = currentNode.nextSibling()
           )
        {
                if( currentNode.isElement()
                    && currentNode.nodeName() == "property"
                    && currentNode.toElement().attribute( "name" ) == name )
                {
                        return currentNode.toElement();
                }
        }
                
        return QDomNode().toElement();
}

QDomElement Blokkal::ConfigBase::createPropertyNode( const QString & name )
{
        QDomElement propertyNode = node().ownerDocument().createElement( "property" );
        node().appendChild( propertyNode );
        propertyNode.setAttribute( "name", name );
        return propertyNode;
}

void Blokkal::ConfigBase::remove( void )
{
        node().parentNode().removeChild( node() );
}

void Blokkal::ConfigBase::writeEntry( const QString & name, const QString & value )
{
        QDomElement propertyNode = findPropertyNode( name );
        if( propertyNode.isNull() ) {
                propertyNode = createPropertyNode( name );
        }

        propertyNode.setAttribute( "value", value );
}

void Blokkal::ConfigBase::writeEntry( const QString & name, bool value )
{
        writeEntry( name, value ? QString::fromLatin1( "true" ) : QString::fromLatin1( "false" ) );
}

QString Blokkal::ConfigBase::readEntry( const QString & name, const QString & defaultValue ) const
{
        QDomElement propertyNode = findPropertyNode( name );

        if( propertyNode.isNull() ) {
                return defaultValue;
        }

        return propertyNode.attribute( "value" );
}

bool Blokkal::ConfigBase::readBoolEntry( const QString & name, bool defaultValue ) const
{
        return readEntry( name, defaultValue ? QString::fromLatin1( "true" ) : QString::fromLatin1( "false" ) ) == QString::fromLatin1( "true" );
}

void Blokkal::ConfigBase::writeEntry( const QString & name, int value )
{
        writeEntry( name, QString::number( value ) );
}

int Blokkal::ConfigBase::readIntEntry( const QString & name, int defaultValue ) const
{
        bool ok;
        int value = readEntry( name, QString::number( defaultValue ) ).toInt( &ok );
        if( ok ) {
                return value;
        }

        return defaultValue;
}

void Blokkal::ConfigBase::writeEntry( const QString & name, unsigned int value )
{
        writeEntry( name, QString::number( value ) );
}

unsigned int Blokkal::ConfigBase::readUIntEntry( const QString & name, unsigned int defaultValue ) const
{
        bool ok;
        unsigned int value = readEntry( name, QString::number( defaultValue ) ).toUInt( &ok );
        if( ok ) {
                return value;
        }

        return defaultValue;
}

unsigned long Blokkal::ConfigBase::readULongEntry( const QString & name, unsigned long defaultValue ) const
{
        bool ok;
        unsigned long value = readEntry( name, QString::number( defaultValue ) ).toULong( &ok );
        if( ok ) {
                return value;
        }

        return defaultValue;
}

void Blokkal::ConfigBase::writeEntry( const QString & name, unsigned long value )
{
        writeEntry( name, QString::number( value ) );
}

void Blokkal::ConfigBase::writeComplex( const QString & name, const QString & value )
{
        QDomElement complexNode = findComplexNode( name );
        if( complexNode.isNull() ) {
                complexNode = createComplexNode( name );
        }

        if( !complexNode.hasChildNodes() ) {
                complexNode.appendChild( node().ownerDocument().createTextNode( value ) );
        }
        else {
                complexNode.firstChild().toText().setData( value );
        }
}

QString Blokkal::ConfigBase::readComplex( const QString & name, const QString & defaultValue )
{
        QDomElement complexNode = findComplexNode( name );

        if( complexNode.isNull() ) {
                return defaultValue;
        }

        return complexNode.firstChild().toText().data();
}

QDomElement Blokkal::ConfigBase::findComplexNode( const QString & name ) const
{
        for( QDomNode currentNode = node().firstChild();
             !currentNode.isNull();
             currentNode = currentNode.nextSibling()
           )
        {
                if( currentNode.isElement()
                    && currentNode.nodeName() == "complex"
                    && currentNode.toElement().attribute( "name" ) == name )
                {
                        return currentNode.toElement();
                }
        }
                
        return QDomNode().toElement();  
}

QDomElement Blokkal::ConfigBase::createComplexNode( const QString & name )
{
        QDomElement complexNode = node().ownerDocument().createElement( "complex" );
        node().appendChild( complexNode );
        complexNode.setAttribute( "name", name );
        return complexNode;     
}