Source: kmimetyperesolver.h

/* This file is part of the KDE libraries
   Copyright (C) 2000 David Faure 
   Copyright (C) 2000 Rik Hemsley 
   Copyright (C) 2002 Carsten Pfeiffer 

   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library General Public
   License version 2 as published by the Free Software Foundation.

   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., 59 Temple Place - Suite 330,
   Boston, MA 02111-1307, USA.
*/

#ifndef __kmimetyperesolver_h
#define __kmimetyperesolver_h

#include 
#include 
#include 
#include 

/**
 * @internal
 * A baseclass for KMimeTypeResolver, with the interface, 
 * KMimeTypeResolverHelper uses.
 */
class KMimeTypeResolverBase
{
public:
    virtual void slotViewportAdjusted() = 0;
    virtual void slotProcessMimeIcons() = 0;
protected:
    virtual void virtual_hook( int, void* ) {};
};

/**
 * @internal
 * This class is used by KMimeTypeResolver, because it can't be a QObject
 * itself. So an object of this class is used to handle signals, slots etc.
 * and forwards them to the KMimeTypeResolver instance.
 */
class KMimeTypeResolverHelper : public QObject
{
    Q_OBJECT
    
public:
    KMimeTypeResolverHelper( KMimeTypeResolverBase *resolver, 
                             QScrollView *view )
        : m_resolver( resolver ), 
          m_timer( new QTimer( this ) )
    {
        connect( m_timer, SIGNAL( timeout() ), SLOT( slotProcessMimeIcons() ));
        
        connect( view->horizontalScrollBar(), SIGNAL( sliderMoved(int) ),
                 SLOT( slotAdjust() ) );
        connect( view->verticalScrollBar(), SIGNAL( sliderMoved(int) ),
                 SLOT( slotAdjust() ) );

        view->viewport()->installEventFilter( this );
    }
    
    void start( int delay, bool singleShot )
    {
        m_timer->start( delay, singleShot );
    }
                   
protected:
    virtual bool eventFilter( QObject *o, QEvent *e )
    {
        bool ret = QObject::eventFilter( o, e );

        if ( e->type() == QEvent::Resize )
            m_resolver->slotViewportAdjusted();
        
        return ret;
    }
    
private slots:
    void slotProcessMimeIcons()
    {
        m_resolver->slotProcessMimeIcons();
    }

    void slotAdjust()
    {
        m_resolver->slotViewportAdjusted();
    }
    
private:
    KMimeTypeResolverBase *m_resolver;
    QTimer *m_timer;
};

/**
 * This class implements the "delayed-mimetype-determination" feature,
 * for konqueror's directory views (and KFileDialog's :)
 *
 * It determines the mimetypes of the icons in the background, but giving
 * preferrence to the visible icons.
 *
 * It is implemented as a template, so that it can work with both QPtrListViewItem
 * and QIconViewItem, without requiring hacks such as void * or QPtrDict lookups.
 *
 * Here's what the parent must implement :
 - void mimeTypeDeterminationFinished();
 - QScrollView * scrollWidget();
 - void determineIcon( IconItem * item ), which should call
   KFileItem::determineMimeType on the fileItem, and update the icon, etc.
*/
template
class KMimeTypeResolver : public KMimeTypeResolverBase // if only this could be a QObject....
{
public:
    KMimeTypeResolver( Parent * parent )
        : m_parent(parent),
          m_helper( new KMimeTypeResolverHelper(this, parent->scrollWidget())),
          m_delayNonVisibleIcons(10)
    {}

    virtual ~KMimeTypeResolver() { 
        delete m_helper;
    }

    /**
     * Start the mimetype-determination. Call this when the listing is completed.
     * @param delayNonVisibleIcons the delay to use between icons not on screen.
     * Usually 10, but should be set to 0 when the image preview feature is
     * activated, because image preview can only start once we know the mimetypes
     */
    void start( uint delayNonVisibleIcons = 10 )
    {
        m_helper->start( 0, true /* single shot */ );
        m_delayNonVisibleIcons = delayNonVisibleIcons;
    }

    /**
     * The list of items to process. The view is free to
     * clear it, insert new items into it, remove items, etc.
     */
    QPtrList m_lstPendingMimeIconItems;

    /**
     * "Connected" to the viewportAdjusted signal of the scrollview
     */
    virtual void slotViewportAdjusted();

    /**
     * "Connected" to the timer
     */
    virtual void slotProcessMimeIcons();

private:
    /**
     * Find a visible icon and determine its mimetype.
     * KonqDirPart will call this method repeatedly until it returns 0L
     * (no more visible icon to process).
     * @return the file item that was just processed.
     */
    IconItem * findVisibleIcon();

    Parent * m_parent;
    KMimeTypeResolverHelper *m_helper;
    uint m_delayNonVisibleIcons;
};

// The main slot
template
inline void KMimeTypeResolver::slotProcessMimeIcons()
{
    //kdDebug(1203) << "KMimeTypeResolver::slotProcessMimeIcons() "
    //              << m_lstPendingMimeIconItems.count() << endl;
    IconItem * item = 0L;
    int nextDelay = 0;

    if ( m_lstPendingMimeIconItems.count() > 0 )
    {
        // We only find mimetypes for icons that are visible. When more
        // of our viewport is exposed, we'll get a signal and then get
        // the mimetypes for the newly visible icons. (Rikkus)
        item = findVisibleIcon();
    }

    // No more visible items.
    if (0 == item)
    {
        // Do the unvisible ones, then, but with a bigger delay, if so configured
        if ( m_lstPendingMimeIconItems.count() > 0 )
        {
            item = m_lstPendingMimeIconItems.first();
            nextDelay = m_delayNonVisibleIcons;
        }
        else
        {
            m_parent->mimeTypeDeterminationFinished();
            return;
        }
    }

    m_parent->determineIcon(item);
    m_lstPendingMimeIconItems.remove(item);
    m_helper->start( nextDelay, true /* single shot */ );
}

template
inline void KMimeTypeResolver::slotViewportAdjusted()
{
    if (m_lstPendingMimeIconItems.isEmpty()) return;
    IconItem * item = findVisibleIcon();
    if (item)
    {
        m_parent->determineIcon( item );
        m_lstPendingMimeIconItems.remove(item);
        m_helper->start( 0, true /* single shot */ );
    }
}

template
inline IconItem * KMimeTypeResolver::findVisibleIcon()
{
    // Find an icon that's visible and whose mimetype we don't know.

    QPtrListIterator it(m_lstPendingMimeIconItems);
    if ( m_lstPendingMimeIconItems.count()<20) // for few items, it's faster to not bother
        return m_lstPendingMimeIconItems.first();

    QScrollView * view = m_parent->scrollWidget();
    QRect visibleContentsRect
        (
            view->viewportToContents(QPoint(0, 0)),
            view->viewportToContents
            (
                QPoint(view->visibleWidth(), view->visibleHeight())
                )
            );

    for (; it.current(); ++it)
        if (visibleContentsRect.intersects(it.current()->rect()))
            return it.current();

    return 0L;
}

#endif