kexiblobbuffer.cpp

/* This file is part of the KDE project
   Copyright (C) 2005 Jaroslaw Staniek <js@iidea.pl>
 
   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library General Public
   License as published by the Free Software Foundation; either
   version 2 of the License, or (at your option) any later version.
 
   This library 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
   Library General Public License for more details.
 
   You should have received a copy of the GNU Library General Public License
   along with this library; see the file COPYING.LIB.  If not, write to
   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 * Boston, MA 02110-1301, USA.
*/
 
#include "kexiblobbuffer.h"
 
#include <assert.h>
 
#include <tqfile.h>
#include <tqfileinfo.h>
#include <tqbuffer.h>
 
#include <kdebug.h>
#include <kstaticdeleter.h>
#include <kimageio.h>
 
#include <kexidb/connection.h>
 
static KStaticDeleter<KexiBLOBBuffer> m_bufferDeleter;
static KexiBLOBBuffer* m_buffer = 0;
 
//-----------------
 
class KexiBLOBBuffer::Private
{
    public:
        Private()
         : maxId(0)
         , inMemoryItems(1009)
         , storedItems(1009)
         , itemsByURL(1009)
        {
        }
        Id_t maxId; 
        TQIntDict<Item> inMemoryItems; 
        TQIntDict<Item> storedItems; 
        TQDict<Item> itemsByURL;
        TQGuardedPtr<KexiDB::Connection> conn;
};
 
//-----------------
 
KexiBLOBBuffer::Handle::Handle(Item* item)
 : m_item(item)
{
    if (m_item)
        m_item->refs++;
}
 
KexiBLOBBuffer::Handle::Handle(const Handle& handle)
{
    *this = handle;
}
 
KexiBLOBBuffer::Handle::Handle()
 : m_item(0)
{
}
 
KexiBLOBBuffer::Handle::~Handle()
{
    if (m_item) {
        m_item->refs--;
        if (m_item->refs<=0)
            KexiBLOBBuffer::self()->removeItem(m_item->id, m_item->stored);
    }
}
 
KexiBLOBBuffer::Handle& KexiBLOBBuffer::Handle::operator=(const Handle& handle)
{
    m_item = handle.m_item;
    if (m_item)
        m_item->refs++;
    return *this;
}
 
void KexiBLOBBuffer::Handle::setStoredWidthID(KexiBLOBBuffer::Id_t id)
{
    if (!m_item)
        return;
    if (m_item->stored) {
        kdWarning() << "KexiBLOBBuffer::Handle::setStoredWidthID(): object for id=" << id 
            << " is aleady stored" << endl;
        return;
    }
 
    KexiBLOBBuffer::self()->takeItem(m_item);
    m_item->id = id; //new id
    m_item->stored = true;
    KexiBLOBBuffer::self()->insertItem(m_item);
}
 
//-----------------
 
KexiBLOBBuffer::Item::Item(const TQByteArray& data, KexiBLOBBuffer::Id_t ident, bool _stored,
    const TQString& _name, const TQString& _caption, const TQString& _mimeType, 
    Id_t _folderId, const TQPixmap& pixmap)
 : name(_name), caption(_caption), mimeType(_mimeType), refs(0), 
 id(ident), folderId(_folderId), stored(_stored),
 m_pixmapLoaded(new bool(false)/*workaround for pixmap() const*/)
{
    if (pixmap.isNull())
        m_pixmap = new TQPixmap();
    else
        m_pixmap = new TQPixmap(pixmap);
 
    if (data.isEmpty())
        m_data = new TQByteArray();
    else
        m_data = new TQByteArray(data);
}
 
KexiBLOBBuffer::Item::~Item()
{
    kexipluginsdbg << "KexiBLOBBuffer::Item::~Item()" << endl;
    delete m_pixmap;
    m_pixmap = 0;
    delete m_data;
    m_data = 0;
    delete m_pixmapLoaded;
}
 
TQPixmap KexiBLOBBuffer::Item::pixmap() const
{
    if (!*m_pixmapLoaded && m_pixmap->isNull() && !m_data->isEmpty()) {
        TQString type( KImageIO::typeForMime(mimeType) );
        if (!KImageIO::canRead( type ) || !m_pixmap->loadFromData(*m_data, type.latin1())) {
        }
        *m_pixmapLoaded = true;
    }
    return *m_pixmap;
}
 
TQByteArray KexiBLOBBuffer::Item::data() const
{
    if (!m_data->isEmpty())
        return *m_data;
 
    if (m_data->isEmpty() && m_pixmap->isNull())
        return TQByteArray();
    
    if (m_data->isEmpty() && !m_pixmap->isNull()) {
        //convert pixmap to byte array
        //(do it only on demand)
        TQBuffer buffer( *m_data );
        buffer.open( IO_WriteOnly );
        m_pixmap->save( &buffer, mimeType.isEmpty() ? (const char*)"PNG" : mimeType.latin1() );
    }
    return *m_data;
}
 
//-----------------
 
KexiBLOBBuffer::KexiBLOBBuffer()
 : TQObject()
 , d(new Private())
{
    Q_ASSERT(!m_buffer);
    d->inMemoryItems.setAutoDelete(true);
    d->storedItems.setAutoDelete(true);
}
 
KexiBLOBBuffer::~KexiBLOBBuffer()
{
    delete d;
}
 
KexiBLOBBuffer::Handle KexiBLOBBuffer::insertPixmap(const KURL& url)
{
    if (url.isEmpty() )
        return KexiBLOBBuffer::Handle();
    if (!url.isValid()) {
        kexipluginswarn << "::insertPixmap: INVALID URL '" << url << "'" << endl;
        return KexiBLOBBuffer::Handle();
    }
    Item * item = d->itemsByURL.find(url.prettyURL());
    if (item)
        return KexiBLOBBuffer::Handle(item);
 
    TQString fileName = url.isLocalFile() ? url.path() : url.prettyURL();
    TQFile f(fileName);
    if (!f.open(IO_ReadOnly)) {
        return KexiBLOBBuffer::Handle();
    }
    TQString mimeType( KImageIO::mimeType( fileName ) );
 
    TQByteArray data( f.readAll() );
    if (f.status()!=IO_Ok) {
        return KexiBLOBBuffer::Handle();
    }
    TQFileInfo fi(url.fileName());
    TQString caption(fi.baseName().replace('_', " ").simplifyWhiteSpace());
 
    item = new Item(data, ++d->maxId, false, url.fileName(), caption, mimeType);
    insertItem(item);
 
    //cache
    item->prettyURL = url.prettyURL();
    d->itemsByURL.replace(url.prettyURL(), item);
    return KexiBLOBBuffer::Handle(item);
}
 
KexiBLOBBuffer::Handle KexiBLOBBuffer::insertObject(const TQByteArray& data, 
    const TQString& name, const TQString& caption, const TQString& mimeType, KexiBLOBBuffer::Id_t identifier)
{
    KexiBLOBBuffer::Id_t newIdentifier;
    if (identifier>0)
        newIdentifier = identifier;
    else
        newIdentifier = ++d->maxId;
 
    Item *item = new Item(data, newIdentifier, identifier>0, name, caption, mimeType);
    insertItem( item );
    return KexiBLOBBuffer::Handle(item);
}
 
KexiBLOBBuffer::Handle KexiBLOBBuffer::insertPixmap(const TQPixmap& pixmap)
{
    if (pixmap.isNull())
        return KexiBLOBBuffer::Handle();
 
    Item * item = new Item(
        TQByteArray(), //(pixmap will be converted to byte array on demand)
        ++d->maxId, 
        false, //not stored
        TQString(), 
        TQString(), 
        "image/png", 
        0, //folder id
        pixmap);
 
    insertItem(item);
    return KexiBLOBBuffer::Handle(item);
}
 
KexiBLOBBuffer::Handle KexiBLOBBuffer::objectForId(Id_t id, bool stored)
{
    if (id<=0)
        return KexiBLOBBuffer::Handle();
    if (stored) {
        Item *item = d->storedItems.find(id);
        if (item || !d->conn)
            return KexiBLOBBuffer::Handle(item);
        //retrieve stored BLOB:
 
//#if 0
        assert(d->conn);
        KexiDB::TableSchema *blobsTable = d->conn->tableSchema("kexi__blobs"); 
        if (!blobsTable) {
            return KexiBLOBBuffer::Handle();
        }
/*      TQStringList where;
        where << "o_id";
        KexiDB::PreparedStatement::Ptr st = d->conn->prepareStatement(
            KexiDB::PreparedStatement::SelectStatement, *blobsTable, where);*/
        KexiDB::QuerySchema schema;
        schema.addField( blobsTable->field("o_data") );
        schema.addField( blobsTable->field("o_name") );
        schema.addField( blobsTable->field("o_caption") );
        schema.addField( blobsTable->field("o_mime") );
        schema.addField( blobsTable->field("o_folder_id") );
        schema.addToWhereExpression(blobsTable->field("o_id"), TQVariant((TQ_LLONG)id));
 
        KexiDB::RowData rowData;
        tristate res = d->conn->querySingleRecord(
            schema,
//          TQString::fromLatin1("SELECT o_data, o_name, o_caption, o_mime FROM kexi__blobs where o_id=")
//          +TQString::number(id), 
            rowData); 
        if (res!=true || rowData.size()<4) {
            kdWarning() << "KexiBLOBBuffer::objectForId("<<id<<","<<stored
            <<"): res!=true || rowData.size()<4; res=="<<res.toString()<<" rowData.size()=="<<rowData.size()<< endl;
            return KexiBLOBBuffer::Handle();
        }
 
        item = new Item(
            rowData[0].toByteArray(),
            id, 
            true, //stored
            rowData[1].toString(),
            rowData[2].toString(),
            rowData[3].toString(),
            (Id_t)rowData[4].toInt()
        );
 
        insertItem(item);
        return KexiBLOBBuffer::Handle(item);
//#endif
    }
    else
        return KexiBLOBBuffer::Handle(d->inMemoryItems.find(id));
}
 
KexiBLOBBuffer::Handle KexiBLOBBuffer::objectForId(Id_t id)
{
    KexiBLOBBuffer::Handle h(objectForId(id, false));
    if (h)
        return h;
    return objectForId(id, true/*stored*/);
}
 
void KexiBLOBBuffer::removeItem(Id_t id, bool stored)
{
    Item *item;
    if (stored)
        item = d->storedItems.take(id);
    else
        item = d->inMemoryItems.take(id);
 
    if (item && !item->prettyURL.isEmpty()) {
        d->itemsByURL.remove(item->prettyURL);
    }
    delete item;
}
 
void KexiBLOBBuffer::takeItem(Item *item)
{
    assert(item);
    if (item->stored)
        d->storedItems.take(item->id);
    else
        d->inMemoryItems.take(item->id);
}
 
void KexiBLOBBuffer::insertItem(Item *item)
{
    assert(item);
    if (item->stored)
        d->storedItems.insert(item->id, item);
    else
        d->inMemoryItems.insert(item->id, item);
}
 
void KexiBLOBBuffer::setConnection(KexiDB::Connection *conn)
{
    KexiBLOBBuffer::self()->d->conn = conn;
}
 
KexiBLOBBuffer* KexiBLOBBuffer::self()
{
    if(!m_buffer) {
        m_bufferDeleter.setObject( m_buffer, new KexiBLOBBuffer() );
    }
    return m_buffer;
}
 
#include "kexiblobbuffer.moc"