diff options
Diffstat (limited to 'tdeio/tdeio/kmimetyperesolver.h')
-rw-r--r-- | tdeio/tdeio/kmimetyperesolver.h | 255 |
1 files changed, 255 insertions, 0 deletions
diff --git a/tdeio/tdeio/kmimetyperesolver.h b/tdeio/tdeio/kmimetyperesolver.h new file mode 100644 index 000000000..c8828a0da --- /dev/null +++ b/tdeio/tdeio/kmimetyperesolver.h @@ -0,0 +1,255 @@ +/* This file is part of the KDE libraries + Copyright (C) 2000 David Faure <faure@kde.org> + Copyright (C) 2000 Rik Hemsley <rik@kde.org> + Copyright (C) 2002 Carsten Pfeiffer <pfeiffer@kde.org> + + 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., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. +*/ + +#ifndef __kmimetyperesolver_h +#define __kmimetyperesolver_h + +#include <tqscrollview.h> +#include <tqptrlist.h> +#include <tqtimer.h> +#include <kdebug.h> + +/** + * @internal + * A baseclass for KMimeTypeResolver, with the interface, + * KMimeTypeResolverHelper uses. + */ +class TDEIO_EXPORT 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 TDEIO_EXPORT KMimeTypeResolverHelper : public TQObject +{ + Q_OBJECT + +public: + KMimeTypeResolverHelper( KMimeTypeResolverBase *resolver, + TQScrollView *view ) + : m_resolver( resolver ), + m_timer( new TQTimer( this ) ) + { + connect( m_timer, TQT_SIGNAL( timeout() ), TQT_SLOT( slotProcessMimeIcons() )); + + connect( view->horizontalScrollBar(), TQT_SIGNAL( sliderMoved(int) ), + TQT_SLOT( slotAdjust() ) ); + connect( view->verticalScrollBar(), TQT_SIGNAL( sliderMoved(int) ), + TQT_SLOT( slotAdjust() ) ); + + view->viewport()->installEventFilter( this ); + } + + void start( int delay, bool singleShot ) + { + m_timer->start( delay, singleShot ); + } + +protected: + virtual bool eventFilter( TQObject *o, TQEvent *e ) + { + bool ret = TQObject::eventFilter( o, e ); + + if ( e->type() == TQEvent::Resize ) + m_resolver->slotViewportAdjusted(); + + return ret; + } + +private slots: + void slotProcessMimeIcons() + { + m_resolver->slotProcessMimeIcons(); + } + + void slotAdjust() + { + m_resolver->slotViewportAdjusted(); + } + +private: + KMimeTypeResolverBase *m_resolver; + TQTimer *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 TQIconViewItem, without requiring hacks such as void * or TQPtrDict lookups. + * + * Here's what the parent must implement : + * @li void mimeTypeDeterminationFinished(); + * @li TQScrollView * scrollWidget(); + * @li void determineIcon( IconItem * item ), which should call + * @li KFileItem::determineMimeType on the fileItem, and update the icon, etc. +*/ +template<class IconItem, class Parent> +class KMimeTypeResolver : public KMimeTypeResolverBase // if only this could be a TQObject.... +{ +public: + /** + * Creates a new KMimeTypeResolver with the given parent. + * @param parent the parent's resolver + */ + 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. + * @return the list of items to process + */ + TQPtrList<IconItem> 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<class IconItem, class Parent> +inline void KMimeTypeResolver<IconItem, Parent>::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<class IconItem, class Parent> +inline void KMimeTypeResolver<IconItem, Parent>::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<class IconItem, class Parent> +inline IconItem * KMimeTypeResolver<IconItem, Parent>::findVisibleIcon() +{ + // Find an icon that's visible and whose mimetype we don't know. + + TQPtrListIterator<IconItem> it(m_lstPendingMimeIconItems); + if ( m_lstPendingMimeIconItems.count()<20) // for few items, it's faster to not bother + return m_lstPendingMimeIconItems.first(); + + TQScrollView * view = m_parent->scrollWidget(); + TQRect visibleContentsRect + ( + view->viewportToContents(TQPoint(0, 0)), + view->viewportToContents + ( + TQPoint(view->visibleWidth(), view->visibleHeight()) + ) + ); + + for (; it.current(); ++it) + if (visibleContentsRect.intersects(it.current()->rect())) + return it.current(); + + return 0L; +} + +#endif |