libkonq Library API Documentation

kfileivi.cc

00001 /* This file is part of the KDE project
00002    Copyright (C) 1999, 2000, 2001, 2002 David Faure <faure@kde.org>
00003 
00004    This library is free software; you can redistribute it and/or
00005    modify it under the terms of the GNU Library General Public
00006    License as published by the Free Software Foundation; either
00007    version 2 of the License, or (at your option) any later version.
00008 
00009    This library is distributed in the hope that it will be useful,
00010    but WITHOUT ANY WARRANTY; without even the implied warranty of
00011    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00012    Library General Public License for more details.
00013 
00014    You should have received a copy of the GNU Library General Public License
00015    along with this library; see the file COPYING.LIB.  If not, write to
00016    the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
00017    Boston, MA 02111-1307, USA.
00018 */
00019 
00020 #include "kfileivi.h"
00021 #include "kivdirectoryoverlay.h"
00022 #include "konq_iconviewwidget.h"
00023 #include "konq_operations.h"
00024 #include "konq_settings.h"
00025 
00026 #include <qpainter.h>
00027 
00028 #include <kurldrag.h>
00029 #include <kiconeffect.h>
00030 #include <kfileitem.h>
00031 #include <kdebug.h>
00032 
00033 #undef Bool
00034 
00038 struct KFileIVI::Private
00039 {
00040     QIconSet icons; // Icon states (cached to prevent re-applying icon effects
00041             // every time)
00042     QPixmap  thumb; // Raw unprocessed thumbnail
00043     QString m_animatedIcon; // Name of animation
00044     bool m_animated;        // Animation currently running ?
00045     KIVDirectoryOverlay* m_directoryOverlay;
00046     QPixmap m_overlay;
00047     QString m_overlayName;
00048 };
00049 
00050 KFileIVI::KFileIVI( KonqIconViewWidget *iconview, KFileItem* fileitem, int size )
00051     : KIconViewItem( iconview, fileitem->text(),
00052              fileitem->pixmap( size, KIcon::DefaultState ) ),
00053     m_size( size ), m_state( KIcon::DefaultState ),
00054     m_bDisabled( false ), m_bThumbnail( false ), m_fileitem( fileitem )
00055 {
00056     setDropEnabled( S_ISDIR( m_fileitem->mode() ) );
00057     d = new KFileIVI::Private;
00058 
00059     // Cache entry for the icon effects
00060     d->icons.reset( *pixmap(), QIconSet::Large );
00061     d->m_animated = false;
00062 
00063     // iconName() requires the mimetype to be known
00064     if ( fileitem->isMimeTypeKnown() )
00065     {
00066         QString icon = fileitem->iconName();
00067         if ( !icon.isEmpty() )
00068             setMouseOverAnimation( icon );
00069         else
00070             setMouseOverAnimation( "unknown" );
00071     }
00072     d->m_directoryOverlay = 0;
00073 }
00074 
00075 KFileIVI::~KFileIVI()
00076 {
00077     delete d->m_directoryOverlay;
00078     delete d;
00079 }
00080 
00081 void KFileIVI::invalidateThumb( int state, bool redraw )
00082 {
00083     QIconSet::Mode mode;
00084     switch( state )
00085     {
00086     case KIcon::DisabledState:
00087         mode = QIconSet::Disabled;
00088         break;
00089     case KIcon::ActiveState:
00090         mode = QIconSet::Active;
00091         break;
00092     case KIcon::DefaultState:
00093     default:
00094         mode = QIconSet::Normal;
00095         break;
00096     }
00097     d->icons = QIconSet();
00098     d->icons.setPixmap( KGlobal::iconLoader()->iconEffect()->
00099             apply( d->thumb, KIcon::Desktop, state ),
00100             QIconSet::Large, mode );
00101     m_state = state;
00102 
00103     QIconViewItem::setPixmap( d->icons.pixmap( QIconSet::Large, mode ),
00104                   false, redraw );
00105 }
00106 
00107 void KFileIVI::setIcon( int size, int state, bool recalc, bool redraw )
00108 {
00109     m_size = size;
00110     m_bThumbnail = false;
00111     if ( m_bDisabled )
00112       m_state = KIcon::DisabledState;
00113     else
00114       m_state = state;
00115 
00116     if ( d->m_overlayName.isNull() )
00117         d->m_overlay = QPixmap();
00118     else {
00119         int halfSize;
00120         if (m_size == 0) {
00121             halfSize = IconSize(KIcon::Desktop) / 2;
00122         } else {
00123             halfSize = m_size / 2;
00124         }
00125         d->m_overlay = DesktopIcon(d->m_overlayName, halfSize);
00126     }
00127 
00128     setPixmapDirect(m_fileitem->pixmap( m_size, m_state ) , recalc, redraw );
00129 }
00130 
00131 void KFileIVI::setOverlay( const QString& iconName )
00132 {
00133     d->m_overlayName = iconName;
00134 
00135     refreshIcon(true);
00136 }
00137 
00138 KIVDirectoryOverlay* KFileIVI::setShowDirectoryOverlay( bool show )
00139 {
00140     if ( !m_fileitem->isDir() || m_fileitem->iconName() != "folder" )
00141         return 0;
00142 
00143     if (show) {
00144         if (!d->m_directoryOverlay)
00145             d->m_directoryOverlay = new KIVDirectoryOverlay(this);
00146         return d->m_directoryOverlay;
00147     } else {
00148         delete d->m_directoryOverlay;
00149         d->m_directoryOverlay = 0;
00150         setOverlay(QString());
00151         return 0;
00152     }
00153 }
00154 
00155 bool KFileIVI::showDirectoryOverlay(  )
00156 {
00157     return (bool)d->m_directoryOverlay;
00158 }
00159 
00160 void KFileIVI::setPixmapDirect( const QPixmap& pixmap, bool recalc, bool redraw )
00161 {
00162     QIconSet::Mode mode;
00163     switch( m_state )
00164     {
00165     case KIcon::DisabledState:
00166         mode = QIconSet::Disabled;
00167         break;
00168     case KIcon::ActiveState:
00169         mode = QIconSet::Active;
00170         break;
00171     case KIcon::DefaultState:
00172     default:
00173         mode = QIconSet::Normal;
00174         break;
00175     }
00176 
00177     // We cannot just reset() the iconset here, because setIcon can be
00178     // called with any state and not just normal state. So we just
00179     // create a dummy empty iconset as base object.
00180     d->icons = QIconSet();
00181     d->icons.setPixmap( pixmap, QIconSet::Large, mode );
00182     QIconViewItem::setPixmap( d->icons.pixmap( QIconSet::Large, mode ),
00183                   recalc, redraw );
00184 }
00185 
00186 void KFileIVI::setDisabled( bool disabled )
00187 {
00188     if ( m_bDisabled != disabled && !isThumbnail() )
00189     {
00190         m_bDisabled = disabled;
00191         bool active = ( m_state == KIcon::ActiveState );
00192         m_state = m_bDisabled ? KIcon::DisabledState : ( active ? KIcon::ActiveState : KIcon::DefaultState );
00193         QIconViewItem::setPixmap( m_fileitem->pixmap( m_size, m_state ), false, true );
00194     }
00195 }
00196 
00197 void KFileIVI::setThumbnailPixmap( const QPixmap & pixmap )
00198 {
00199     m_bThumbnail = true;
00200     d->thumb = pixmap;
00201     // QIconSet::reset() doesn't seem to clear the other generated pixmaps,
00202     // so we just create a blank QIconSet here
00203     d->icons = QIconSet();
00204     d->icons.setPixmap( KGlobal::iconLoader()->iconEffect()->
00205             apply( pixmap, KIcon::Desktop, KIcon::DefaultState ),
00206             QIconSet::Large, QIconSet::Normal );
00207 
00208     m_state = KIcon::DefaultState;
00209 
00210     // Recalc when setting this pixmap!
00211     QIconViewItem::setPixmap( d->icons.pixmap( QIconSet::Large,
00212                   QIconSet::Normal ), true );
00213 }
00214 
00215 void KFileIVI::setActive( bool active )
00216 {
00217     if ( active )
00218         setEffect( KIcon::ActiveState );
00219     else
00220         setEffect( m_bDisabled ? KIcon::DisabledState : KIcon::DefaultState );
00221 }
00222 
00223 void KFileIVI::setEffect( int state )
00224 {
00225     QIconSet::Mode mode;
00226     switch( state )
00227     {
00228     case KIcon::DisabledState:
00229         mode = QIconSet::Disabled;
00230         break;
00231     case KIcon::ActiveState:
00232         mode = QIconSet::Active;
00233         break;
00234     case KIcon::DefaultState:
00235     default:
00236         mode = QIconSet::Normal;
00237         break;
00238     }
00239     // Do not update if the fingerprint is identical (prevents flicker)!
00240 
00241     KIconEffect *effect = KGlobal::iconLoader()->iconEffect();
00242 
00243     bool haveEffect = effect->hasEffect( KIcon::Desktop, m_state ) !=
00244                       effect->hasEffect( KIcon::Desktop, state );
00245 
00246                 //kdDebug(1203) << "desktop;defaultstate=" <<
00247                 //      effect->fingerprint(KIcon::Desktop, KIcon::DefaultState) <<
00248                 //      endl;
00249                 //kdDebug(1203) << "desktop;activestate=" <<
00250                 //      effect->fingerprint(KIcon::Desktop, KIcon::ActiveState) <<
00251                 //      endl;
00252 
00253     if( haveEffect &&
00254         effect->fingerprint( KIcon::Desktop, m_state ) !=
00255     effect->fingerprint( KIcon::Desktop, state ) )
00256     {
00257     // Effects on are not applied until they are first accessed to
00258     // save memory. Do this now when needed
00259     if( m_bThumbnail )
00260     {
00261         if( d->icons.isGenerated( QIconSet::Large, mode ) )
00262         d->icons.setPixmap( effect->apply( d->thumb, KIcon::Desktop, state ),
00263                     QIconSet::Large, mode );
00264     }
00265     else
00266     {
00267         if( d->icons.isGenerated( QIconSet::Large, mode ) )
00268         d->icons.setPixmap( m_fileitem->pixmap( m_size, state ),
00269                     QIconSet::Large, mode );
00270     }
00271     QIconViewItem::setPixmap( d->icons.pixmap( QIconSet::Large, mode ) );
00272     }
00273     m_state = state;
00274 }
00275 
00276 void KFileIVI::refreshIcon( bool redraw )
00277 {
00278     if (!isThumbnail())
00279         setIcon( m_size, m_state, true, redraw );
00280 }
00281 
00282 void KFileIVI::invalidateThumbnail()
00283 {
00284     d->thumb = QPixmap();
00285 }
00286 
00287 bool KFileIVI::isThumbnailInvalid() const
00288 {
00289     return d->thumb.isNull();
00290 }
00291 
00292 bool KFileIVI::acceptDrop( const QMimeSource *mime ) const
00293 {
00294     if ( mime->provides( "text/uri-list" ) ) // We're dragging URLs
00295     {
00296         if ( m_fileitem->acceptsDrops() ) // Directory, executables, ...
00297             return true;
00298 
00299         // Use cache
00300         KURL::List uris = ( static_cast<KonqIconViewWidget*>(iconView()) )->dragURLs();
00301 
00302         // Check if we want to drop something on itself
00303         // (Nothing will happen, but it's a convenient way to move icons)
00304         KURL::List::Iterator it = uris.begin();
00305         for ( ; it != uris.end() ; it++ )
00306         {
00307             if ( m_fileitem->url().equals( *it, true /*ignore trailing slashes*/ ) )
00308                 return true;
00309         }
00310     }
00311     return QIconViewItem::acceptDrop( mime );
00312 }
00313 
00314 void KFileIVI::setKey( const QString &key )
00315 {
00316     QString theKey = key;
00317 
00318     QVariant sortDirProp = iconView()->property( "sortDirectoriesFirst" );
00319 
00320     if ( S_ISDIR( m_fileitem->mode() ) && ( !sortDirProp.isValid() || ( sortDirProp.type() == QVariant::Bool && sortDirProp.toBool() ) ) )
00321       theKey.prepend( iconView()->sortDirection() ? '0' : '1' );
00322     else
00323       theKey.prepend( iconView()->sortDirection() ? '1' : '0' );
00324 
00325     QIconViewItem::setKey( theKey );
00326 }
00327 
00328 void KFileIVI::dropped( QDropEvent *e, const QValueList<QIconDragItem> & )
00329 {
00330     KonqOperations::doDrop( item(), item()->url(), e, iconView() );
00331 }
00332 
00333 void KFileIVI::returnPressed()
00334 {
00335     m_fileitem->run();
00336 }
00337 
00338 
00339 void KFileIVI::paintItem( QPainter *p, const QColorGroup &c )
00340 {
00341     QColorGroup cg = updateColors(c);
00342     paintFontUpdate( p );
00343 
00344     //*** TEMPORARY CODE - MUST BE MADE CONFIGURABLE FIRST - Martijn
00345     // SET UNDERLINE ON HOVER ONLY
00346     /*if ( ( ( KonqIconViewWidget* ) iconView() )->m_pActiveItem == this )
00347     {
00348         QFont f( p->font() );
00349         f.setUnderline( TRUE );
00350         p->setFont( f );
00351     }*/
00352 
00353     KIconViewItem::paintItem( p, cg );
00354     paintOverlay(p);
00355 
00356 }
00357 
00358 void KFileIVI::paintOverlay( QPainter *p ) const
00359 {
00360     if ( !d->m_overlay.isNull() ) {
00361         QRect rect = pixmapRect(true);
00362         p->drawPixmap(x() + rect.x() , y() + pixmapRect().height() - d->m_overlay.height(), d->m_overlay);
00363     }
00364 }
00365 
00366 void KFileIVI::paintFontUpdate( QPainter *p ) const
00367 {
00368     if ( m_fileitem->isLink() )
00369     {
00370         QFont f( p->font() );
00371         f.setItalic( TRUE );
00372         p->setFont( f );
00373     }
00374 }
00375 
00376 QColorGroup KFileIVI::updateColors( const QColorGroup &c ) const
00377 {
00378     QColorGroup cg( c );
00379     cg.setColor( QColorGroup::Text, static_cast<KonqIconViewWidget*>(iconView())->itemColor() );
00380     return cg;
00381 }
00382 
00383 bool KFileIVI::move( int x, int y )
00384 {
00385     if ( static_cast<KonqIconViewWidget*>(iconView())->isDesktop() ) {
00386     if ( x < 5 )
00387         x = 5;
00388     if ( x > iconView()->viewport()->width() - ( width() + 5 ) )
00389         x = iconView()->viewport()->width() - ( width() + 5 );
00390     if ( y < 5 )
00391         y = 5;
00392     if ( y > iconView()->viewport()->height() - ( height() + 5 ) )
00393         y = iconView()->viewport()->height() - ( height() + 5 );
00394     }
00395     return QIconViewItem::move( x, y );
00396 }
00397 
00398 bool KFileIVI::hasAnimation() const
00399 {
00400     return !d->m_animatedIcon.isEmpty() && !m_bThumbnail;
00401 }
00402 
00403 void KFileIVI::setMouseOverAnimation( const QString& movieFileName )
00404 {
00405     if ( !movieFileName.isEmpty() )
00406     {
00407         //kdDebug(1203) << "KIconViewItem::setMouseOverAnimation " << movieFileName << endl;
00408         d->m_animatedIcon = movieFileName;
00409     }
00410 }
00411 
00412 QString KFileIVI::mouseOverAnimation() const
00413 {
00414     return d->m_animatedIcon;
00415 }
00416 
00417 bool KFileIVI::isAnimated() const
00418 {
00419     return d->m_animated;
00420 }
00421 
00422 void KFileIVI::setAnimated( bool a )
00423 {
00424     d->m_animated = a;
00425 }
00426 
00427 int KFileIVI::compare( QIconViewItem *i ) const
00428 {
00429     KonqIconViewWidget* view = static_cast<KonqIconViewWidget*>(iconView());
00430     if ( view->caseInsensitiveSort() )
00431         return key().localeAwareCompare( i->key() );
00432     else
00433         return view->m_pSettings->caseSensitiveCompare( key(), i->key() );
00434 }
00435 
00436 /* vim: set noet sw=4 ts=8 softtabstop=4: */
KDE Logo
This file is part of the documentation for libkonq Library Version 3.2.1.
Documentation copyright © 1996-2004 the KDE developers.
Generated on Fri Mar 5 04:41:08 2004 by doxygen 1.3.6-20040222 written by Dimitri van Heesch, © 1997-2003