diff options
Diffstat (limited to 'libkonq/konq_iconviewwidget.cpp')
-rw-r--r-- | libkonq/konq_iconviewwidget.cpp | 1939 |
1 files changed, 1939 insertions, 0 deletions
diff --git a/libkonq/konq_iconviewwidget.cpp b/libkonq/konq_iconviewwidget.cpp new file mode 100644 index 000000000..3fe916cad --- /dev/null +++ b/libkonq/konq_iconviewwidget.cpp @@ -0,0 +1,1939 @@ +/* This file is part of the KDE projects + Copyright (C) 1998, 1999 Torben Weis <weis@kde.org> + Copyright (C) 2000 - 2005 David Faure <faure@kde.org> + + 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; see the file COPYING. If not, write to + the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. +*/ +#include "konq_iconviewwidget.h" +#include "konq_operations.h" +#include "konq_undo.h" +#include "konq_sound.h" +#include "konq_filetip.h" + +#include <tqclipboard.h> +#include <tqlayout.h> +#include <tqtimer.h> +#include <tqpainter.h> +#include <tqtooltip.h> +#include <tqlabel.h> +#include <tqmovie.h> +#include <tqregexp.h> +#include <tqcursor.h> + +#include <tdeapplication.h> +#include <kdebug.h> +#include <tdeio/previewjob.h> +#include <tdefileivi.h> +#include <konq_settings.h> +#include <konq_drag.h> +#include <tdeglobalsettings.h> +#include <kpropertiesdialog.h> +#include <kipc.h> +#include <kicontheme.h> +#include <kiconeffect.h> +#include <kurldrag.h> +#include <kstandarddirs.h> +#include <kprotocolinfo.h> +#include <ktrader.h> + +#include <assert.h> +#include <unistd.h> +#include <tdelocale.h> + + +struct KonqIconViewWidgetPrivate +{ + KonqIconViewWidgetPrivate() { + pActiveItem = 0; + bSoundPreviews = false; + pSoundItem = 0; + bSoundItemClicked = false; + pSoundPlayer = 0; + pSoundTimer = 0; + pPreviewJob = 0; + bAllowSetWallpaper = false; + + doAnimations = true; + m_movie = 0L; + m_movieBlocked = 0; + pFileTip = 0; + pActivateDoubleClick = 0L; + bCaseInsensitive = true; + pPreviewMimeTypes = 0L; + bProgramsURLdrag = false; + } + ~KonqIconViewWidgetPrivate() { + delete pSoundPlayer; + delete pSoundTimer; + delete m_movie; + delete pFileTip; + delete pActivateDoubleClick; + delete pPreviewMimeTypes; + //delete pPreviewJob; done by stopImagePreview + } + KFileIVI *pActiveItem; + // Sound preview + KFileIVI *pSoundItem; + KonqSoundPlayer *pSoundPlayer; + TQTimer *pSoundTimer; + bool bSoundPreviews; + bool bSoundItemClicked; + bool bAllowSetWallpaper; + bool bCaseInsensitive; + bool bBoostPreview; + + // Animated icons support + bool doAnimations; + TQMovie* m_movie; + int m_movieBlocked; + TQString movieFileName; + + TDEIO::PreviewJob *pPreviewJob; + KonqFileTip* pFileTip; + TQStringList previewSettings; + bool renameItem; + bool firstClick; + bool releaseMouseEvent; + TQPoint mousePos; + int mouseState; + TQTimer *pActivateDoubleClick; + TQStringList* pPreviewMimeTypes; + bool bProgramsURLdrag; +}; + +KonqIconViewWidget::KonqIconViewWidget( TQWidget * parent, const char * name, WFlags f, bool kdesktop ) + : TDEIconView( parent, name, f ), + m_rootItem( 0L ), m_size( 0 ) /* default is DesktopIcon size */, + m_bDesktop( kdesktop ), + m_bSetGridX( !kdesktop ) /* No line breaking on the desktop */ +{ + d = new KonqIconViewWidgetPrivate; + connect( this, TQT_SIGNAL( dropped( TQDropEvent *, const TQValueList<TQIconDragItem> & ) ), + this, TQT_SLOT( slotDropped( TQDropEvent*, const TQValueList<TQIconDragItem> & ) ) ); + + connect( this, TQT_SIGNAL( selectionChanged() ), + this, TQT_SLOT( slotSelectionChanged() ) ); + + kapp->addKipcEventMask( KIPC::IconChanged ); + connect( kapp, TQT_SIGNAL(iconChanged(int)), TQT_SLOT(slotIconChanged(int)) ); + connect( this, TQT_SIGNAL(onItem(TQIconViewItem *)), TQT_SLOT(slotOnItem(TQIconViewItem *)) ); + connect( this, TQT_SIGNAL(onViewport()), TQT_SLOT(slotOnViewport()) ); + connect( this, TQT_SIGNAL(itemRenamed(TQIconViewItem *, const TQString &)), TQT_SLOT(slotItemRenamed(TQIconViewItem *, const TQString &)) ); + + m_pSettings = KonqFMSettings::settings(); // already needed in setItemTextPos(), calculateGridX() + d->bBoostPreview = boostPreview(); + + // hardcoded settings + setSelectionMode( TQIconView::Extended ); + setItemTextPos( TQIconView::Bottom ); + d->releaseMouseEvent = false; + d->pFileTip = new KonqFileTip(this); + d->firstClick = false; + calculateGridX(); + setAutoArrange( true ); + setSorting( true, sortDirection() ); + readAnimatedIconsConfig(); + m_bSortDirsFirst = true; + m_bMousePressed = false; + m_LineupMode = LineupBoth; + // emit our signals + slotSelectionChanged(); + m_iconPositionGroupPrefix = TQString::fromLatin1( "IconPosition::" ); + KonqUndoManager::incRef(); +} + +KonqIconViewWidget::~KonqIconViewWidget() +{ + stopImagePreview(); + KonqUndoManager::decRef(); + delete d; +} + +bool KonqIconViewWidget::maySetWallpaper() +{ + return d->bAllowSetWallpaper; +} + +void KonqIconViewWidget::setMaySetWallpaper(bool b) +{ + d->bAllowSetWallpaper = b; +} + +void KonqIconViewWidget::focusOutEvent( TQFocusEvent * ev ) +{ + // We can't possibly have the mouse pressed and still lose focus. + // Well, we can, but when we regain focus we should assume the mouse is + // not down anymore or the slotOnItem code will break with highlighting! + m_bMousePressed = false; + + // This will ensure that tooltips don't pop up and the mouseover icon + // effect will go away if the mouse goes out of the view without + // first moving into an empty portion of the view + // Fixes part of #86968, and #85204 + // Matt Newell 2004-09-24 + slotOnViewport(); + + TDEIconView::focusOutEvent( ev ); +} + +void KonqIconViewWidget::slotItemRenamed(TQIconViewItem *item, const TQString &name) +{ + kdDebug(1203) << "KonqIconViewWidget::slotItemRenamed" << endl; + KFileIVI *viewItem = static_cast<KFileIVI *>(item); + KFileItem *fileItem = viewItem->item(); + + // The correct behavior is to show the old name until the rename has successfully + // completed. Unfortunately, TDEIconView forces us to allow the text to be changed + // before we try the rename, so set it back to the pre-rename state. + viewItem->setText( fileItem->text() ); + kdDebug(1203)<<" fileItem->text() ;"<<fileItem->text()<<endl; + // Don't do anything if the user renamed to a blank name. + if( !name.isEmpty() ) + { + // Actually attempt the rename. If it succeeds, KDirLister will update the name. + KURL oldurl( fileItem->url() ); + KURL newurl( oldurl ); + newurl.setPath( newurl.directory(false) + TDEIO::encodeFileName( name ) ); + kdDebug(1203)<<" newurl :"<<newurl<<endl; + // We use url()+name so that it also works if the name is a relative path (#51176) + KonqOperations::rename( this, oldurl, newurl ); + } +} + +void KonqIconViewWidget::slotIconChanged( int group ) +{ + if (group != TDEIcon::Desktop) + return; + + int size = m_size; + if ( m_size == 0 ) + m_size = -1; // little trick to force grid change in setIcons + setIcons( size ); // force re-determining all icons + readAnimatedIconsConfig(); +} + +void KonqIconViewWidget::readAnimatedIconsConfig() +{ + TDEConfigGroup cfgGroup( TDEGlobal::config(), "DesktopIcons" ); + d->doAnimations = cfgGroup.readBoolEntry( "Animated", true /*default*/ ); +} + +void KonqIconViewWidget::slotOnItem( TQIconViewItem *_item ) +{ + KFileIVI* item = static_cast<KFileIVI *>( _item ); + // Reset icon of previous item + if( d->pActiveItem != 0L && d->pActiveItem != item ) + { + if ( d->m_movie && d->pActiveItem->isAnimated() ) + { + d->m_movie->pause(); // we'll see below what we do with it + d->pActiveItem->setAnimated( false ); + d->pActiveItem->refreshIcon( true ); + } + else { + d->pActiveItem->setActive( false ); + } + d->pActiveItem = 0L; + d->pFileTip->setItem( 0L ); + } + + // Stop sound + if (d->pSoundPlayer != 0 && item != d->pSoundItem) + { + d->pSoundPlayer->stop(); + + d->pSoundItem = 0; + if (d->pSoundTimer && d->pSoundTimer->isActive()) + d->pSoundTimer->stop(); + } + + if ( !m_bMousePressed ) + { + if( item != d->pActiveItem ) + { + d->pActiveItem = item; + d->pFileTip->setItem( d->pActiveItem->item(), + item->rect(), + item->pixmap() ); + + if ( d->doAnimations && d->pActiveItem && d->pActiveItem->hasAnimation() ) + { + //kdDebug(1203) << "Playing animation for: " << d->pActiveItem->mouseOverAnimation() << endl; + // Check if cached movie can be used +#if 0 // Qt-mng bug, reusing the movie doesn't work currently. + if ( d->m_movie && d->movieFileName == d->pActiveItem->mouseOverAnimation() ) + { + d->pActiveItem->setAnimated( true ); + if (d->m_movieBlocked) { + kdDebug(1203) << "onitem, but blocked" << endl; + d->m_movie->pause(); + } + else { + kdDebug(1203) << "we go ahead.." << endl; + d->m_movieBlocked++; + TQTimer::singleShot(300, this, TQT_SLOT(slotReenableAnimation())); + d->m_movie->restart(); + d->m_movie->unpause(); + } + } + else +#endif + { + TQMovie movie = TDEGlobal::iconLoader()->loadMovie( d->pActiveItem->mouseOverAnimation(), TDEIcon::Desktop, d->pActiveItem->iconSize() ); + if ( !movie.isNull() ) + { + delete d->m_movie; + d->m_movie = new TQMovie( movie ); // shallow copy, don't worry + // Fix alpha-channel - currently only if no background pixmap, + // the bg pixmap case requires to uncomment the code at qmovie.cpp:404 + const TQPixmap* pm = backgroundPixmap(); + bool hasPixmap = pm && !pm->isNull(); + if ( !hasPixmap ) { + pm = viewport()->backgroundPixmap(); + hasPixmap = pm && !pm->isNull(); + } + if (!hasPixmap && backgroundMode() != NoBackground) + d->m_movie->setBackgroundColor( viewport()->backgroundColor() ); + d->m_movie->connectUpdate( this, TQT_SLOT( slotMovieUpdate(const TQRect &) ) ); + d->m_movie->connectStatus( TQT_TQOBJECT(this), TQT_SLOT( slotMovieStatus(int) ) ); + d->movieFileName = d->pActiveItem->mouseOverAnimation(); + d->pActiveItem->setAnimated( true ); + } + else + { + d->pActiveItem->setAnimated( false ); + if (d->m_movie) + d->m_movie->pause(); + // No movie available, remember it + d->pActiveItem->setMouseOverAnimation( TQString::null ); + } + } + } // animations + // Only do the normal "mouseover" effect if no animation is in use + if (d->pActiveItem && !d->pActiveItem->isAnimated()) + { + d->pActiveItem->setActive( true ); + } + } + else // No change in current item + { + // No effect. If we want to underline on hover, we should + // force the IVI to repaint here, though! + d->pActiveItem = 0L; + d->pFileTip->setItem( 0L ); + } + } // bMousePressed + else + { + // All features disabled during mouse clicking, e.g. rectangular + // selection + d->pActiveItem = 0L; + d->pFileTip->setItem( 0L ); + } + + // ## shouldn't this be disabled during rectangular selection too ? + if (d->bSoundPreviews && d->pSoundPlayer && + d->pSoundPlayer->mimeTypes().contains( + item->item()->mimetype()) + && TDEGlobalSettings::showFilePreview(item->item()->url()) + && topLevelWidget() == kapp->activeWindow()) + { + d->pSoundItem = item; + d->bSoundItemClicked = false; + if (!d->pSoundTimer) + { + d->pSoundTimer = new TQTimer(this); + connect(d->pSoundTimer, TQT_SIGNAL(timeout()), TQT_SLOT(slotStartSoundPreview())); + } + if (d->pSoundTimer->isActive()) + d->pSoundTimer->stop(); + d->pSoundTimer->start(500, true); + } + else + { + if (d->pSoundPlayer) + d->pSoundPlayer->stop(); + d->pSoundItem = 0; + if (d->pSoundTimer && d->pSoundTimer->isActive()) + d->pSoundTimer->stop(); + } +} + +void KonqIconViewWidget::slotOnViewport() +{ + d->pFileTip->setItem( 0L ); + + if (d->pSoundPlayer) + d->pSoundPlayer->stop(); + d->pSoundItem = 0; + if (d->pSoundTimer && d->pSoundTimer->isActive()) + d->pSoundTimer->stop(); + + if (d->pActiveItem == 0L) + return; + + if ( d->doAnimations && d->m_movie && d->pActiveItem->isAnimated() ) + { + d->pActiveItem->setAnimated( false ); +#if 0 + // Aborting before the end of the animation ? + if (d->m_movie->running()) { + d->m_movie->pause(); + d->m_movieBlocked++; + kdDebug(1203) << "on viewport, blocking" << endl; + TQTimer::singleShot(300, this, TQT_SLOT(slotReenableAnimation())); + } +#endif + d->pActiveItem->refreshIcon( true ); + Q_ASSERT( d->pActiveItem->state() == TDEIcon::DefaultState ); + //delete d->m_movie; + //d->m_movie = 0L; + // TODO a timer to delete the movie after some time if unused? + } + else + { + d->pActiveItem->setActive( false ); + } + d->pActiveItem = 0L; +} + +void KonqIconViewWidget::slotStartSoundPreview() +{ + if (!d->pSoundItem || d->bSoundItemClicked) + return; + + d->pSoundPlayer->play(d->pSoundItem->item()->url().url()); +} + + +void KonqIconViewWidget::slotPreview(const KFileItem *item, const TQPixmap &pix) +{ + // ### slow. Idea: move KonqKfmIconView's m_itemDict into this class + for (TQIconViewItem *it = firstItem(); it; it = it->nextItem()) + { + KFileIVI* current = static_cast<KFileIVI *>(it); + if (current->item() == item) + { + if (item->overlays() & TDEIcon::HiddenOverlay) { + TQPixmap p(pix); + + TDEIconEffect::semiTransparent(p); + current->setThumbnailPixmap(p); + } else { + current->setThumbnailPixmap(pix); + } + break; + } + } +} + +void KonqIconViewWidget::slotPreviewResult() +{ + d->pPreviewJob = 0; + emit imagePreviewFinished(); +} + +void KonqIconViewWidget::slotToolTipPreview(const KFileItem* , const TQPixmap &) +{ +// unused - remove for KDE4 +} + +void KonqIconViewWidget::slotToolTipPreviewResult() +{ +// unused - remove for KDE4 +} + +void KonqIconViewWidget::slotMovieUpdate( const TQRect& rect ) +{ + //kdDebug(1203) << "KonqIconViewWidget::slotMovieUpdate " << rect.x() << "," << rect.y() << " " << rect.width() << "x" << rect.height() << endl; + Q_ASSERT( d ); + Q_ASSERT( d->m_movie ); + // seems stopAnimation triggers one last update + if ( d->pActiveItem && d->m_movie && d->pActiveItem->isAnimated() ) { + const TQPixmap &frame = d->m_movie->framePixmap(); + // This can happen if the icon was scaled to the desired size, so TDEIconLoader + // will happily return a movie with different dimensions than the icon + int iconSize=d->pActiveItem->iconSize(); + if (iconSize==0) iconSize = TDEGlobal::iconLoader()->currentSize( TDEIcon::Desktop ); + if ( frame.width() != iconSize || frame.height() != iconSize ) { + d->pActiveItem->setAnimated( false ); + d->m_movie->pause(); + // No movie available, remember it + d->pActiveItem->setMouseOverAnimation( TQString::null ); + d->pActiveItem->setActive( true ); + return; + } + d->pActiveItem->setPixmapDirect( frame, false, false /*no redraw*/ ); + TQRect pixRect = d->pActiveItem->pixmapRect(false); + repaintContents( pixRect.x() + rect.x(), pixRect.y() + rect.y(), rect.width(), rect.height(), false ); + } +} + +void KonqIconViewWidget::slotMovieStatus( int status ) +{ + if ( status < 0 ) { + // Error playing the MNG -> forget about it and do normal iconeffect + if ( d->pActiveItem && d->pActiveItem->isAnimated() ) { + d->pActiveItem->setAnimated( false ); + d->pActiveItem->setMouseOverAnimation( TQString::null ); + d->pActiveItem->setActive( true ); + } + } +} + +void KonqIconViewWidget::slotReenableAnimation() +{ + if (!--d->m_movieBlocked) { + if ( d->pActiveItem && d->m_movie && d->m_movie->paused()) { + kdDebug(1203) << "reenabled animation" << endl; + d->m_movie->restart(); + d->m_movie->unpause(); + } + } +} + +void KonqIconViewWidget::clear() +{ + d->pFileTip->setItem( 0L ); + stopImagePreview(); // Just in case + TDEIconView::clear(); + d->pActiveItem = 0L; +} + +void KonqIconViewWidget::takeItem( TQIconViewItem *item ) +{ + if ( d->pActiveItem == static_cast<KFileIVI *>(item) ) + { + d->pFileTip->setItem( 0L ); + d->pActiveItem = 0L; + } + + if ( d->pPreviewJob ) + d->pPreviewJob->removeItem( static_cast<KFileIVI *>(item)->item() ); + + TDEIconView::takeItem( item ); +} + +// Currently unused - remove in KDE 4.0 +void KonqIconViewWidget::setThumbnailPixmap( KFileIVI * item, const TQPixmap & pixmap ) +{ + if ( item ) + { + if ( d->pActiveItem == item ) + { + d->pFileTip->setItem( 0L ); + d->pActiveItem = 0L; + } + item->setThumbnailPixmap( pixmap ); + if ( m_bSetGridX && item->width() > gridX() ) + { + setGridX( item->width() ); + if (autoArrange()) + arrangeItemsInGrid(); + } + } +} + +bool KonqIconViewWidget::initConfig( bool bInit ) +{ + bool fontChanged = false; + + // Color settings + TQColor normalTextColor = m_pSettings->normalTextColor(); + setItemColor( normalTextColor ); + + if (m_bDesktop) + { + TQColor itemTextBg = m_pSettings->itemTextBackground(); + if ( itemTextBg.isValid() ) + setItemTextBackground( itemTextBg ); + else + setItemTextBackground( Qt::NoBrush ); + } + + bool on = m_pSettings->showFileTips() && TQToolTip::isGloballyEnabled(); + d->pFileTip->setOptions(on, + m_pSettings->showPreviewsInFileTips(), + m_pSettings->numFileTips()); + + // if the user wants our own tooltip, don't show the one from Qts ListView + setShowToolTips(!on); + + // Font settings + TQFont font( m_pSettings->standardFont() ); + if (!m_bDesktop) + font.setUnderline( m_pSettings->underlineLink() ); + + if ( font != KonqIconViewWidget::font() ) + { + setFont( font ); + if (!bInit) + { + // TQIconView doesn't do it by default... but if the font is made much + // bigger, we really need to give more space between the icons + fontChanged = true; + } + } + + setIconTextHeight( m_pSettings->iconTextHeight() ); + + if ( (itemTextPos() == TQIconView::Right) && (maxItemWidth() != gridXValue()) ) + { + int size = m_size; + m_size = -1; // little trick to force grid change in setIcons + setIcons( size ); // force re-determining all icons + } + else if ( d->bBoostPreview != boostPreview() ) // Update icons if settings for preview icon size have changed + setIcons(m_size); + else if (!bInit) + updateContents(); + return fontChanged; +} + +bool KonqIconViewWidget::boostPreview() const +{ + if ( m_bDesktop ) return false; + + TDEConfigGroup group( TDEGlobal::config(), "PreviewSettings" ); + return group.readBoolEntry( "BoostSize", false ); +} + +void KonqIconViewWidget::disableSoundPreviews() +{ + d->bSoundPreviews = false; + + if (d->pSoundPlayer) + d->pSoundPlayer->stop(); + d->pSoundItem = 0; + if (d->pSoundTimer && d->pSoundTimer->isActive()) + d->pSoundTimer->stop(); +} + +void KonqIconViewWidget::setIcons( int size, const TQStringList& stopImagePreviewFor ) +{ + // size has changed? + bool sizeChanged = (m_size != size); + int oldGridX = gridX(); + m_size = size; + + // boost preview option has changed? + bool boost = boostPreview(); + bool previewSizeChanged = ( d->bBoostPreview != boost ); + d->bBoostPreview = boost; + + if ( sizeChanged || previewSizeChanged ) + { + int realSize = size ? size : TDEGlobal::iconLoader()->currentSize( TDEIcon::Desktop ); + // choose spacing depending on font, but min 5 (due to KFileIVI move limit) + setSpacing( ( m_bDesktop || ( realSize > TDEIcon::SizeSmall ) ) ? + TQMAX( 5, TQFontMetrics(font()).width('n') ) : 0 ); + } + + if ( sizeChanged || previewSizeChanged || !stopImagePreviewFor.isEmpty() ) + { + calculateGridX(); + } + bool stopAll = !stopImagePreviewFor.isEmpty() && stopImagePreviewFor.first() == "*"; + + // Disable repaints that can be triggered by ivi->setIcon(). Since icons are + // resized in-place, if the icon size is increasing it can happens that the right + // or bottom icons exceed the size of the viewport.. here we prevent the repaint + // event that will be triggered in that case. + bool prevUpdatesState = viewport()->isUpdatesEnabled(); + viewport()->setUpdatesEnabled( false ); + + // Do this even if size didn't change, since this is used by refreshMimeTypes... + for ( TQIconViewItem *it = firstItem(); it; it = it->nextItem() ) { + KFileIVI * ivi = static_cast<KFileIVI *>( it ); + // Set a normal icon for files that are not thumbnails, and for files + // that are thumbnails but for which it should be stopped + if ( !ivi->isThumbnail() || + sizeChanged || + previewSizeChanged || + stopAll || + mimeTypeMatch( ivi->item()->mimetype(), stopImagePreviewFor ) ) + { + ivi->setIcon( size, ivi->state(), true, false ); + } + else + ivi->invalidateThumb( ivi->state(), true ); + } + + // Restore viewport update to previous state + viewport()->setUpdatesEnabled( prevUpdatesState ); + + if ( ( sizeChanged || previewSizeChanged || oldGridX != gridX() || + !stopImagePreviewFor.isEmpty() ) && autoArrange() ) + arrangeItemsInGrid( true ); // take new grid into account and repaint + else + viewport()->update(); //Repaint later.. +} + +bool KonqIconViewWidget::mimeTypeMatch( const TQString& mimeType, const TQStringList& mimeList ) const +{ + // Code duplication from TDEIO::PreviewJob + KMimeType::Ptr mime = KMimeType::mimeType( mimeType ); + for (TQStringList::ConstIterator mt = mimeList.begin(); mt != mimeList.end(); ++mt) + { + if ( mime->is( *mt ) ) + return true; + // Support for *mt == "image/*" + TQString tmp( mimeType ); + if ( (*mt).endsWith("*") && tmp.replace(TQRegExp("/.*"), "/*") == (*mt) ) + return true; + if ( (*mt) == "text/plain" ) + { + TQVariant textProperty = mime->property( "X-TDE-text" ); + if ( textProperty.type() == TQVariant::Bool && textProperty.toBool() ) + return true; + } + } + return false; +} + +void KonqIconViewWidget::setItemTextPos( ItemTextPos pos ) +{ + // can't call gridXValue() because this already would need the new itemTextPos() + int sz = m_size ? m_size : TDEGlobal::iconLoader()->currentSize( TDEIcon::Desktop ); + + if ( m_bSetGridX ) { + if ( pos == TQIconView::Bottom ) { + setGridX( TQMAX( sz + 50, previewIconSize( sz ) + 13 ) ); + } + else + { + setMaxItemWidth( TQMAX( sz, previewIconSize( sz ) ) + m_pSettings->iconTextWidth() ); + setGridX( -1 ); + } + } + + TDEIconView::setItemTextPos( pos ); +} + +void KonqIconViewWidget::gridValues( int* x, int* y, int* dx, int* dy, + int* nx, int* ny ) +{ + int previewSize = previewIconSize( m_size ); + int iconSize = m_size ? m_size : TDEGlobal::iconLoader()->currentSize( TDEIcon::Desktop ); + + // Grid size + // as KFileIVI limits to move an icon to x >= 5, y >= 5, we define a grid cell as: + // spacing() must be >= 5 (currently set to 5 in setIcons()) + // horizontal: left spacing() + <width> + // vertical : top spacing(), <height>, bottom spacing() + // The doubled space in y-direction gives a better visual separation and makes it clearer + // to which item the text belongs + *dx = spacing() + TQMAX( TQMAX( iconSize, previewSize ), m_pSettings->iconTextWidth() ); + int textHeight = iconTextHeight() * fontMetrics().height(); + *dy = spacing() + TQMAX( iconSize, previewSize ) + 2 + textHeight + spacing(); + + // Icon Area + int w, h; + if ( m_IconRect.isValid() ) { // w and h must be != 0, otherwise we would get a div by zero + *x = m_IconRect.left(); w = m_IconRect.width(); + *y = m_IconRect.top(); h = m_IconRect.height(); + } + else { + *x = 0; w = viewport()->width(); + *y = 0; h = viewport()->height(); + } + + // bug:110775 avoid div by zero (happens e.g. when iconTextHeight or iconTextWidth are very large) + if ( *dx > w ) + *dx = w; + + if ( *dy > h ) + *dy = h; + + *nx = w / *dx; + *ny = h / *dy; + // TODO: Check that items->count() <= nx * ny + + // Let have exactly nx columns and ny rows + if(*nx && *ny) { + *dx = w / *nx; + *dy = h / *ny; + } + kdDebug(1203) << "x=" << *x << " y=" << *y << " spacing=" << spacing() << " iconSize=" << iconSize + << " w=" << w << " h=" << h + << " nx=" << *nx << " ny=" << *ny + << " dx=" << *dx << " dy=" << *dy << endl; +} + +void KonqIconViewWidget::calculateGridX() +{ + if ( m_bSetGridX ) { + if ( itemTextPos() == TQIconView::Bottom ) { + setGridX( gridXValue() ); + } + else + { + setMaxItemWidth( gridXValue() ); + setGridX( -1 ); + } + } +} + +int KonqIconViewWidget::gridXValue() const +{ + // this method is only used in konqi as filemanager (not desktop) + int sz = m_size ? m_size : TDEGlobal::iconLoader()->currentSize( TDEIcon::Desktop ); + int newGridX; + + if ( itemTextPos() == TQIconView::Bottom ) + newGridX = TQMAX( sz + 50, previewIconSize( sz ) + 13 ); + else + newGridX = TQMAX( sz, previewIconSize( sz ) ) + m_pSettings->iconTextWidth(); + + //kdDebug(1203) << "gridXValue: " << newGridX << " sz=" << sz << endl; + return newGridX; +} + +void KonqIconViewWidget::refreshMimeTypes() +{ + updatePreviewMimeTypes(); + for ( TQIconViewItem *it = firstItem(); it; it = it->nextItem() ) + (static_cast<KFileIVI *>( it ))->item()->refreshMimeType(); + setIcons( m_size ); +} + +void KonqIconViewWidget::setURL( const KURL &kurl ) +{ + stopImagePreview(); + m_url = kurl; + + d->pFileTip->setPreview( TDEGlobalSettings::showFilePreview(m_url) ); + + if ( m_url.isLocalFile() ) + m_dotDirectoryPath = m_url.path(1).append( ".directory" ); + else + m_dotDirectoryPath = TQString::null; +} + +void KonqIconViewWidget::startImagePreview( const TQStringList &, bool force ) +{ + stopImagePreview(); // just in case + + // Check config + if ( !TDEGlobalSettings::showFilePreview( url() ) ) { + kdDebug(1203) << "Previews disabled for protocol " << url().protocol() << endl; + emit imagePreviewFinished(); + return; + } + + if ((d->bSoundPreviews = d->previewSettings.contains( "audio/" )) && + !d->pSoundPlayer) + { + KLibFactory *factory = KLibLoader::self()->factory("konq_sound"); + if (factory) + d->pSoundPlayer = static_cast<KonqSoundPlayer *>( + factory->create(TQT_TQOBJECT(this), 0, "KonqSoundPlayer")); + d->bSoundPreviews = (d->pSoundPlayer != 0L); + } + + KFileItemList items; + for ( TQIconViewItem *it = firstItem(); it; it = it->nextItem() ) + if ( force || !static_cast<KFileIVI *>( it )->hasValidThumbnail() ) + items.append( static_cast<KFileIVI *>( it )->item() ); + + bool onlyAudio = true; + for ( TQStringList::ConstIterator it = d->previewSettings.begin(); it != d->previewSettings.end(); ++it ) { + if ( (*it).startsWith( "audio/" ) ) + d->bSoundPreviews = true; + else + onlyAudio = false; + } + + if ( items.isEmpty() || onlyAudio ) { + emit imagePreviewFinished(); + return; // don't start the preview job if not really necessary + } + + int iconSize = m_size ? m_size : TDEGlobal::iconLoader()->currentSize( TDEIcon::Desktop ); + int size; + + d->bBoostPreview = boostPreview(); + size = previewIconSize( iconSize ); + + if ( !d->bBoostPreview ) + iconSize /= 2; + + d->pPreviewJob = TDEIO::filePreview( items, size, size, iconSize, + m_pSettings->textPreviewIconTransparency(), true /* scale */, + true /* save */, &(d->previewSettings) ); + connect( d->pPreviewJob, TQT_SIGNAL( gotPreview( const KFileItem *, const TQPixmap & ) ), + this, TQT_SLOT( slotPreview( const KFileItem *, const TQPixmap & ) ) ); + connect( d->pPreviewJob, TQT_SIGNAL( result( TDEIO::Job * ) ), + this, TQT_SLOT( slotPreviewResult() ) ); +} + +void KonqIconViewWidget::stopImagePreview() +{ + if (d->pPreviewJob) + { + d->pPreviewJob->kill(); + d->pPreviewJob = 0; + // Now that previews are updated in-place, calling + // arrangeItemsInGrid() here is not needed anymore + } +} + +bool KonqIconViewWidget::isPreviewRunning() const +{ + return d->pPreviewJob; +} + +KFileItemList KonqIconViewWidget::selectedFileItems() +{ + KFileItemList lstItems; + + TQIconViewItem *it = firstItem(); + for (; it; it = it->nextItem() ) + if ( it->isVisible() && it->isSelected() ) { + KFileItem *fItem = (static_cast<KFileIVI *>(it))->item(); + lstItems.append( fItem ); + } + return lstItems; +} + +void KonqIconViewWidget::slotDropped( TQDropEvent *ev, const TQValueList<TQIconDragItem> & ) +{ + // Drop on background + KURL dirURL = url(); + if ( m_rootItem ) { + bool dummy; + dirURL = m_rootItem->mostLocalURL(dummy); + } + KonqOperations::doDrop( m_rootItem /* may be 0L */, dirURL, ev, this ); +} + +void KonqIconViewWidget::slotAboutToCreate(const TQPoint &, const TQValueList<TDEIO::CopyInfo> &) +{ + // Do nothing :-) +} + +void KonqIconViewWidget::drawBackground( TQPainter *p, const TQRect &r ) +{ + drawBackground(p, r, r.topLeft()); +} + +void KonqIconViewWidget::drawBackground( TQPainter *p, const TQRect &r , const TQPoint &pt) +{ + const TQPixmap *pm = backgroundPixmap(); + bool hasPixmap = pm && !pm->isNull(); + if ( !hasPixmap ) { + pm = viewport()->backgroundPixmap(); + hasPixmap = pm && !pm->isNull(); + } + + TQRect rtgt(r); + rtgt.moveTopLeft(pt); + if (!hasPixmap && backgroundMode() != NoBackground) { + p->fillRect(rtgt, viewport()->backgroundColor()); + return; + } + + if (hasPixmap) { + int ax = (r.x() + contentsX() + leftMargin()) % pm->width(); + int ay = (r.y() + contentsY() + topMargin()) % pm->height(); + p->drawTiledPixmap(rtgt, *pm, TQPoint(ax, ay)); + } +} + +TQDragObject * KonqIconViewWidget::dragObject() +{ + if ( !currentItem() ) + return 0; + + return konqDragObject( viewport() ); +} + +KonqIconDrag * KonqIconViewWidget::konqDragObject( TQWidget * dragSource ) +{ + //kdDebug(1203) << "KonqIconViewWidget::konqDragObject" << endl; + + KonqIconDrag2 * drag = new KonqIconDrag2( dragSource ); + TQIconViewItem *primaryItem = currentItem(); + // Append all items to the drag object + for ( TQIconViewItem *it = firstItem(); it; it = it->nextItem() ) { + if ( it->isVisible() && it->isSelected() ) { + if (!primaryItem) + primaryItem = it; + KFileItem* fileItem = (static_cast<KFileIVI *>(it))->item(); + KURL url = fileItem->url(); + bool dummy; + KURL mostLocalURL = fileItem->mostLocalURL(dummy); + TQString itemURL = KURLDrag::urlToString(url); + kdDebug(1203) << "itemURL=" << itemURL << endl; + TQIconDragItem id; + id.setData( TQCString(itemURL.latin1()) ); + drag->append( id, + TQRect( it->pixmapRect(false).topLeft() - m_mousePos, + it->pixmapRect().size() ), + TQRect( it->textRect(false).topLeft() - m_mousePos, + it->textRect().size() ), + itemURL, mostLocalURL ); + } + } + + if (primaryItem) + drag->setPixmap( *primaryItem->pixmap(), m_mousePos - primaryItem->pixmapRect(false).topLeft() ); + + return drag; +} + +void KonqIconViewWidget::contentsDragEnterEvent( TQDragEnterEvent *e ) +{ + if ( e->provides( "text/uri-list" ) ) + { + TQByteArray payload = e->encodedData( "text/uri-list" ); + if ( !payload.size() ) + kdError() << "Empty data !" << endl; + // Cache the URLs, since we need them every time we move over a file + // (see KFileIVI) + bool ok = KURLDrag::decode( e, m_lstDragURLs ); + if( !ok ) + kdError() << "Couldn't decode urls dragged !" << endl; + } + + KURL::List uriList; + if ( KURLDrag::decode(e, uriList) ) + { + if ( uriList.first().protocol() == "programs" ) + { + e->ignore(); + emit dragEntered( false ); + d->bProgramsURLdrag = true; + return; + } + } + + TDEIconView::contentsDragEnterEvent( e ); + emit dragEntered( true /*accepted*/ ); +} + +void KonqIconViewWidget::contentsDragMoveEvent( TQDragMoveEvent *e ) +{ + if ( d->bProgramsURLdrag ) { + emit dragMove( false ); + e->ignore(); + cancelPendingHeldSignal(); + return; + } + + TQIconViewItem *item = findItem( e->pos() ); + if ( e->source() != viewport() && + !item && m_rootItem && !m_rootItem->isWritable() ) { + emit dragMove( false ); + e->ignore(); + cancelPendingHeldSignal(); + return; + } + emit dragMove( true ); + TDEIconView::contentsDragMoveEvent( e ); +} + +void KonqIconViewWidget::contentsDragLeaveEvent( TQDragLeaveEvent *e ) +{ + d->bProgramsURLdrag = false; + TDEIconView::contentsDragLeaveEvent(e); + emit dragLeft(); +} + + +void KonqIconViewWidget::setItemColor( const TQColor &c ) +{ + iColor = c; +} + +TQColor KonqIconViewWidget::itemColor() const +{ + return iColor; +} + +void KonqIconViewWidget::disableIcons( const KURL::List & lst ) +{ + for ( TQIconViewItem *kit = firstItem(); kit; kit = kit->nextItem() ) + { + bool bFound = false; + // Wow. This is ugly. Matching two lists together.... + // Some sorting to optimise this would be a good idea ? + for (KURL::List::ConstIterator it = lst.begin(); !bFound && it != lst.end(); ++it) + { + if ( static_cast<KFileIVI *>( kit )->item()->url() == *it ) + { + bFound = true; + // maybe remove "it" from lst here ? + } + } + static_cast<KFileIVI *>( kit )->setDisabled( bFound ); + } +} + +void KonqIconViewWidget::slotSelectionChanged() +{ + // This code is very related to ListViewBrowserExtension::updateActions + int canCopy = 0; + int canDel = 0; + int canTrash = 0; + bool bInTrash = false; + int iCount = 0; + + for ( TQIconViewItem *it = firstItem(); it; it = it->nextItem() ) + { + if ( it->isVisible() && it->isSelected() ) + { + iCount++; + canCopy++; + + KFileItem *item = ( static_cast<KFileIVI *>( it ) )->item(); + KURL url = item->url(); + TQString local_path = item->localPath(); + + if ( url.directory(false) == TDEGlobalSettings::trashPath() ) { + bInTrash = true; + } + if ( KProtocolInfo::supportsDeleting( url ) ) { + canDel++; + } + if ( !local_path.isEmpty() ) { + canTrash++; + } + } + } + + emit enableAction( "cut", canDel > 0 ); + emit enableAction( "copy", canCopy > 0 ); + emit enableAction( "trash", canDel > 0 && !bInTrash && canTrash==canDel ); + emit enableAction( "del", canDel > 0 ); + emit enableAction( "properties", iCount > 0 && KPropertiesDialog::canDisplay( selectedFileItems() ) ); + emit enableAction( "editMimeType", ( iCount == 1 ) ); + emit enableAction( "rename", ( iCount == 1) && !bInTrash ); +} + +void KonqIconViewWidget::renameCurrentItem() +{ + if ( currentItem() ) + currentItem()->rename(); +} + +void KonqIconViewWidget::renameSelectedItem() +{ + kdDebug(1203) << " -- KonqIconViewWidget::renameSelectedItem() -- " << endl; + TQIconViewItem * item = 0L; + TQIconViewItem *it = firstItem(); + for (; it; it = it->nextItem() ) + if ( it->isVisible() && it->isSelected() && !item ) + { + item = it; + break; + } + if (!item) + { + Q_ASSERT(item); + return; + } + item->rename(); +} + +void KonqIconViewWidget::cutSelection() +{ + kdDebug(1203) << " -- KonqIconViewWidget::cutSelection() -- " << endl; + KonqIconDrag * obj = konqDragObject( /* no parent ! */ ); + obj->setMoveSelection( true ); + TQApplication::clipboard()->setData( obj ); +} + +void KonqIconViewWidget::copySelection() +{ + kdDebug(1203) << " -- KonqIconViewWidget::copySelection() -- " << endl; + KonqIconDrag * obj = konqDragObject( /* no parent ! */ ); + TQApplication::clipboard()->setData( obj ); +} + +void KonqIconViewWidget::pasteSelection() +{ + paste( url() ); +} + +void KonqIconViewWidget::paste( const KURL &url ) +{ + KonqOperations::doPaste( this, url ); +} + +KURL::List KonqIconViewWidget::selectedUrls() +{ + return selectedUrls( UserVisibleUrls ); +} + +KURL::List KonqIconViewWidget::selectedUrls( UrlFlags flags ) const +{ + KURL::List lstURLs; + bool dummy; + for ( TQIconViewItem *it = firstItem(); it; it = it->nextItem() ) + if ( it->isVisible() && it->isSelected() ) { + KFileItem* item = (static_cast<KFileIVI *>( it ))->item(); + lstURLs.append( flags == MostLocalUrls ? item->mostLocalURL( dummy ) : item->url() ); + } + return lstURLs; +} + +TQRect KonqIconViewWidget::iconArea() const +{ + return m_IconRect; +} + +void KonqIconViewWidget::setIconArea(const TQRect &rect) +{ + m_IconRect = rect; +} + +int KonqIconViewWidget::lineupMode() const +{ + return m_LineupMode; +} + +void KonqIconViewWidget::setLineupMode(int mode) +{ + m_LineupMode = mode; +} + +bool KonqIconViewWidget::sortDirectoriesFirst() const +{ + return m_bSortDirsFirst; +} + +void KonqIconViewWidget::setSortDirectoriesFirst( bool b ) +{ + m_bSortDirsFirst = b; +} + +void KonqIconViewWidget::contentsMouseMoveEvent( TQMouseEvent *e ) +{ + if ( (d->pSoundPlayer && d->pSoundPlayer->isPlaying()) || (d->pSoundTimer && d->pSoundTimer->isActive())) + { + // The following call is SO expensive (the ::widgetAt call eats up to 80% + // of the mouse move cpucycles!), so it's mandatory to place that function + // under strict checks, such as d->pSoundPlayer->isPlaying() + if ( TQApplication::widgetAt( TQCursor::pos() ) != topLevelWidget() ) + { + if (d->pSoundPlayer) + d->pSoundPlayer->stop(); + d->pSoundItem = 0; + if (d->pSoundTimer && d->pSoundTimer->isActive()) + d->pSoundTimer->stop(); + } + } + d->renameItem= false; + TDEIconView::contentsMouseMoveEvent( e ); +} + +void KonqIconViewWidget::contentsDropEvent( TQDropEvent * ev ) +{ + TQIconViewItem *i = findItem( ev->pos() ); + KURL::List uriList; + + if ( ev->source() != viewport() && + !i && m_rootItem && !m_rootItem->isWritable() ) { + ev->accept( false ); + return; + } + + // Short-circuit TQIconView if Ctrl is pressed, so that it's possible + // to drop a file into its own parent widget to copy it. + if ( !i && (ev->action() == TQDropEvent::Copy || ev->action() == TQDropEvent::Link) + && ev->source() && ev->source() == viewport() + && KURLDrag::decode(ev, uriList) && !uriList.isEmpty() + && uriList.first().upURL().url(1) == url().url(1)) + { + // First we need to call TQIconView though, to clear the drag shape + bool bMovable = itemsMovable(); + setItemsMovable(false); // hack ? call it what you want :-) + TDEIconView::contentsDropEvent( ev ); + setItemsMovable(bMovable); + + TQValueList<TQIconDragItem> lst; + slotDropped(ev, lst); + } + else + { + TDEIconView::contentsDropEvent( ev ); + emit dropped(); // What is this for ? (David) KDE4: remove + } + // Don't do this here, it's too early ! + // slotSaveIconPositions(); + // If we want to save after the new file gets listed, though, + // we could reimplement contentsDropEvent in KDIconView and set m_bNeedSave. Bah. + + // This signal is sent last because we need to ensure it is + // taken in account when all the slots triggered by the dropped() signal + // are executed. This way we know that the Drag and Drop is truely finished + emit dragFinished(); +} + +void KonqIconViewWidget::doubleClickTimeout() +{ + d->renameItem= true; + mousePressChangeValue(); + if ( d->releaseMouseEvent ) + { + TQMouseEvent e( TQEvent::MouseButtonPress,d->mousePos , 1, d->mouseState); + TQIconViewItem* item = findItem( e.pos() ); + KURL url; + if ( item ) + { + url= ( static_cast<KFileIVI *>( item ) )->item()->url(); + bool brenameTrash =false; + if ( url.isLocalFile() && (url.directory(false) == TDEGlobalSettings::trashPath() || url.path(1).startsWith(TDEGlobalSettings::trashPath()))) + brenameTrash = true; + + if ( url.isLocalFile() && !brenameTrash && d->renameItem && m_pSettings->renameIconDirectly() && e.button() == Qt::LeftButton && item->textRect( false ).contains(e.pos())) + { + if( d->pActivateDoubleClick->isActive () ) + d->pActivateDoubleClick->stop(); + item->rename(); + m_bMousePressed = false; + } + } + } + else + { + TQMouseEvent e( TQEvent::MouseMove,d->mousePos , 1, d->mouseState); + TDEIconView::contentsMousePressEvent( &e ); + } + if( d->pActivateDoubleClick->isActive() ) + d->pActivateDoubleClick->stop(); + + d->releaseMouseEvent = false; + d->renameItem= false; +} + +void KonqIconViewWidget::wheelEvent(TQWheelEvent* e) +{ + // when scrolling with mousewheel, stop possible pending filetip + d->pFileTip->setItem( 0 ); + + if (e->state() == ControlButton) + { + if (e->delta() >= 0) + { + emit incIconSize(); + } + else + { + emit decIconSize(); + } + e->accept(); + return; + } + + TDEIconView::wheelEvent(e); +} + +void KonqIconViewWidget::leaveEvent( TQEvent *e ) +{ + // when leaving the widget, stop possible pending filetip and icon effect + slotOnViewport(); + + TDEIconView::leaveEvent(e); +} + +void KonqIconViewWidget::mousePressChangeValue() +{ + //kdDebug(1203) << "KonqIconViewWidget::contentsMousePressEvent" << endl; + m_bMousePressed = true; + if (d->pSoundPlayer) + d->pSoundPlayer->stop(); + d->bSoundItemClicked = true; + d->firstClick = false; + + // Once we click on the item, we don't want a tooltip + // Fixes part of #86968 + d->pFileTip->setItem( 0 ); +} + +void KonqIconViewWidget::contentsMousePressEvent( TQMouseEvent *e ) +{ + if(d->pActivateDoubleClick && d->pActivateDoubleClick->isActive ()) + d->pActivateDoubleClick->stop(); + TQIconViewItem* item = findItem( e->pos() ); + m_mousePos = e->pos(); + KURL url; + if ( item ) + { + url = ( static_cast<KFileIVI *>( item ) )->item()->url(); + bool brenameTrash =false; + if ( url.isLocalFile() && (url.directory(false) == TDEGlobalSettings::trashPath() || url.path(1).startsWith(TDEGlobalSettings::trashPath()))) + brenameTrash = true; + if ( !brenameTrash && !TDEGlobalSettings::singleClick() && m_pSettings->renameIconDirectly() && e->button() == Qt::LeftButton && item->textRect( false ).contains(e->pos())&& !d->firstClick && url.isLocalFile() && (!url.protocol().find("device", 0, false)==0)) + { + d->firstClick = true; + d->mousePos = e->pos(); + d->mouseState = e->state(); + if (!d->pActivateDoubleClick) + { + d->pActivateDoubleClick = new TQTimer(this); + connect(d->pActivateDoubleClick, TQT_SIGNAL(timeout()), this, TQT_SLOT(doubleClickTimeout())); + } + if( d->pActivateDoubleClick->isActive () ) + d->pActivateDoubleClick->stop(); + else + d->pActivateDoubleClick->start(TQApplication::doubleClickInterval()); + d->releaseMouseEvent = false; + return; + } + else + d->renameItem= false; + } + else + d->renameItem= false; + mousePressChangeValue(); + if(d->pActivateDoubleClick && d->pActivateDoubleClick->isActive()) + d->pActivateDoubleClick->stop(); + TDEIconView::contentsMousePressEvent( e ); + +} + +void KonqIconViewWidget::contentsMouseReleaseEvent( TQMouseEvent *e ) +{ + TDEIconView::contentsMouseReleaseEvent( e ); + if(d->releaseMouseEvent && d->pActivateDoubleClick && d->pActivateDoubleClick->isActive ()) + d->pActivateDoubleClick->stop(); + slotSelectionChanged(); + d->releaseMouseEvent = true; + m_bMousePressed = false; +} + +void KonqIconViewWidget::slotSaveIconPositions() +{ + // WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING + // This code is currently not used but left in for compatibility reasons. + // It can be removed in KDE 4.0 + // Saving of desktop icon positions is now done in KDIconView::saveIconPositions() + // in tdebase/kdesktop/kdiconview.cpp + // WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING + + printf("WARNING: Strongly deprecated method KonqIconViewWidget::slotSaveIconPositions() called!\n"); fflush(stdout); + + if ( m_dotDirectoryPath.isEmpty() ) + return; + if ( !m_bDesktop ) + return; // Currently not available in Konqueror + kdDebug(1214) << "KonqIconViewWidget::slotSaveIconPositions" << endl; + KSimpleConfig dotDirectory( m_dotDirectoryPath ); + TQIconViewItem *it = firstItem(); + if ( !it ) + return; // No more icons. Maybe we're closing and they've been removed already + while ( it ) + { + KFileIVI *ivi = static_cast<KFileIVI *>( it ); + KFileItem *item = ivi->item(); + + dotDirectory.setGroup( TQString( m_iconPositionGroupPrefix ).append( item->url().fileName() ) ); + kdDebug(1214) << "KonqIconViewWidget::slotSaveIconPositions " << item->url().fileName() << " " << it->x() << " " << it->y() << endl; + dotDirectory.writeEntry( TQString( "X %1" ).arg( width() ), it->x() ); + dotDirectory.writeEntry( TQString( "Y %1" ).arg( height() ), it->y() ); + dotDirectory.writeEntry( "Exists", true ); + + it = it->nextItem(); + } + + TQStringList groups = dotDirectory.groupList(); + TQStringList::ConstIterator gIt = groups.begin(); + TQStringList::ConstIterator gEnd = groups.end(); + for (; gIt != gEnd; ++gIt ) + if ( (*gIt).left( m_iconPositionGroupPrefix.length() ) == m_iconPositionGroupPrefix ) + { + dotDirectory.setGroup( *gIt ); + if ( dotDirectory.hasKey( "Exists" ) ) + dotDirectory.deleteEntry( "Exists", false ); + else + { + kdDebug(1214) << "KonqIconViewWidget::slotSaveIconPositions deleting group " << *gIt << endl; + dotDirectory.deleteGroup( *gIt ); + } + } + + dotDirectory.sync(); + + // WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING + // This code is currently not used but left in for compatibility reasons. + // It can be removed in KDE 4.0 + // Saving of desktop icon positions is now done in KDIconView::saveIconPositions() + // in tdebase/kdesktop/kdiconview.cpp + // WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING +} + +// Adapted version of TQIconView::insertInGrid, that works relative to +// m_IconRect, instead of the entire viewport. + +void KonqIconViewWidget::insertInGrid(TQIconViewItem *item) +{ + if (0L == item) + return; + + if (!m_IconRect.isValid()) + { + TDEIconView::insertInGrid(item); + return; + } + + TQRegion r(m_IconRect); + TQIconViewItem *i = firstItem(); + int y = -1; + for (; i; i = i->nextItem() ) + { + r = r.subtract(i->rect()); + y = TQMAX(y, i->y() + i->height()); + } + + TQMemArray<TQRect> rects = r.rects(); + TQMemArray<TQRect>::Iterator it = rects.begin(); + bool foundPlace = FALSE; + for (; it != rects.end(); ++it) + { + TQRect rect = *it; + if (rect.width() >= item->width() && rect.height() >= item->height()) + { + int sx = 0, sy = 0; + if (rect.width() >= item->width() + spacing()) + sx = spacing(); + if (rect.height() >= item->height() + spacing()) + sy = spacing(); + item->move(rect.x() + sx, rect.y() + sy); + foundPlace = true; + break; + } + } + + if (!foundPlace) + item->move(m_IconRect.topLeft()); + + //item->dirty = false; + return; +} + + +/* + * The algorithm used for lineing up the icons could be called + * "beating flat the icon field". Imagine the icon field to be some height + * field on a regular grid, with the height being the number of icons in + * each grid element. Now imagine slamming on the field with a shovel or + * some other flat surface. The high peaks will be flattened and spread out + * over their adjacent areas. This is basically what the algorithm tries to + * simulate. + * + * First, the icons are binned to a grid of the desired size. If all bins + * are containing at most one icon, we're done, of course. We just have to + * move all icons to the center of each grid element. + * For each bin which has more than one icon in it, we calculate 4 + * "friction coefficients", one for each cardinal direction. The friction + * coefficient of a direction is the number of icons adjacent in that + * direction. The idea is that this number is somewhat a measure in which + * direction the icons should flow: icons flow in the direction of lowest + * friction coefficient. We move a maximum of one icon per bin and loop over + * all bins. This procedure is repeated some maximum number of times or until + * no icons are moved anymore. + * + * I don't know if this algorithm is good or bad, I don't even know if it will + * work all the time. It seems a correct thing to do, however, and it seems to + * work particularly well. In any case, the number of runs is limited so there + * can be no races. + */ + +void KonqIconViewWidget::lineupIcons() +{ + // even if there are no items yet, calculate the maxItemWidth to have the correct + // item rect when we insert new items + + // Create a grid of (ny x nx) bins. + int x0, y0, dx, dy, nx, ny; + gridValues( &x0, &y0, &dx, &dy, &nx, &ny ); + + int itemWidth = dx - spacing(); + bool newItemWidth = false; + if ( maxItemWidth() != itemWidth ) { + newItemWidth = true; + setMaxItemWidth( itemWidth ); + setFont( font() ); // Force calcRect() + } + + if ( !firstItem() ) { + kdDebug(1203) << "No icons at all ?\n"; + return; + } + + int iconSize = m_size ? m_size : TDEGlobal::iconLoader()->currentSize( TDEIcon::Desktop ); + + typedef TQValueList<TQIconViewItem*> Bin; + Bin*** bins = new Bin**[nx]; + int i; + int j; + for ( i = 0; i < nx ; i++ ) { + bins[i] = new Bin*[ny]; + for ( j = 0; j < ny; j++ ) + bins[i][j] = 0L; + } + + // Insert items into grid + int textHeight = iconTextHeight() * fontMetrics().height(); + + for ( TQIconViewItem* item = firstItem(); item; item = item->nextItem() ) { + int x = item->x() + item->width() / 2 - x0; + int y = item->pixmapRect( false ).bottom() - iconSize / 2 + - ( dy - ( iconSize + textHeight ) ) / 2 - y0; + int posX = TQMIN( nx-1, TQMAX( 0, x / dx ) ); + int posY = TQMIN( ny-1, TQMAX( 0, y / dy ) ); + + if ( !bins[posX][posY] ) + bins[posX][posY] = new Bin; + bins[posX][posY]->prepend( item ); + } + + // The shuffle code + int n, k; + const int infinity = 10000; + int nmoves = 1; + for ( n = 0; n < 30 && nmoves > 0; n++ ) { + nmoves = 0; + for ( i = 0; i < nx; i++ ) { + for ( j = 0; j < ny; j++ ) { + if ( !bins[i][j] || ( bins[i][j]->count() <= 1 ) ) + continue; + + // Calculate the 4 "friction coefficients". + int tf = 0, bf = 0, lf = 0, rf = 0; + for ( k = j-1; k >= 0 && bins[i][k] && bins[i][k]->count(); k-- ) + tf += bins[i][k]->count(); + if ( k == -1 ) + tf += infinity; + + for ( k = j+1; k < ny && bins[i][k] && bins[i][k]->count(); k++ ) + bf += bins[i][k]->count(); + if ( k == ny ) + bf += infinity; + + for ( k = i-1; k >= 0 && bins[k][j] && bins[k][j]->count(); k-- ) + lf += bins[k][j]->count(); + if ( k == -1 ) + lf += infinity; + + for ( k = i+1; k < nx && bins[k][j] && bins[k][j]->count(); k++ ) + rf += bins[k][j]->count(); + if ( k == nx ) + rf += infinity; + + // If we are stuck between walls, continue + if ( tf >= infinity && bf >= infinity && + lf >= infinity && rf >= infinity ) + continue; + + // Is there a preferred lineup direction? + if ( m_LineupMode == LineupHorizontal ) { + tf += infinity; + bf += infinity; + } + else if ( m_LineupMode == LineupVertical ) { + lf += infinity; + rf += infinity; + } + + // Move one item in the direction of the least friction + TQIconViewItem* movedItem; + Bin* items = bins[i][j]; + + int mini = TQMIN( TQMIN( tf, bf ), TQMIN( lf, rf ) ); + if ( tf == mini ) { + // move top item in (i,j) to (i,j-1) + Bin::iterator it = items->begin(); + movedItem = *it; + for ( ++it; it != items->end(); ++it ) { + if ( (*it)->y() < movedItem->y() ) + movedItem = *it; + } + items->remove( movedItem ); + if ( !bins[i][j-1] ) + bins[i][j-1] = new Bin; + bins[i][j-1]->prepend( movedItem ); + } + else if ( bf ==mini ) { + // move bottom item in (i,j) to (i,j+1) + Bin::iterator it = items->begin(); + movedItem = *it; + for ( ++it; it != items->end(); ++it ) { + if ( (*it)->y() > movedItem->y() ) + movedItem = *it; + } + items->remove( movedItem ); + if ( !bins[i][j+1] ) + bins[i][j+1] = new Bin; + bins[i][j+1]->prepend( movedItem ); + } + else if ( lf == mini ) + { + // move left item in (i,j) to (i-1,j) + Bin::iterator it = items->begin(); + movedItem = *it; + for ( ++it; it != items->end(); ++it ) { + if ( (*it)->x() < movedItem->x() ) + movedItem = *it; + } + items->remove( movedItem ); + if ( !bins[i-1][j] ) + bins[i-1][j] = new Bin; + bins[i-1][j]->prepend( movedItem ); + } + else { + // move right item in (i,j) to (i+1,j) + Bin::iterator it = items->begin(); + movedItem = *it; + for ( ++it; it != items->end(); ++it ) { + if ( (*it)->x() > movedItem->x() ) + movedItem = *it; + } + items->remove( movedItem ); + if ( !bins[i+1][j] ) + bins[i+1][j] = new Bin; + bins[i+1][j]->prepend( movedItem ); + } + nmoves++; + } + } + } + + // Perform the actual moving + TQRegion repaintRegion; + TQValueList<TQIconViewItem*> movedItems; + + for ( i = 0; i < nx; i++ ) { + for ( j = 0; j < ny; j++ ) { + Bin* bin = bins[i][j]; + if ( !bin ) + continue; + if ( !bin->isEmpty() ) { + TQIconViewItem* item = bin->first(); + int newX = x0 + i*dx + spacing() + + TQMAX(0, ( (dx-spacing()) - item->width() ) / 2); // pixmap can be larger as iconsize + // align all icons vertically to their text + int newY = y0 + j*dy + dy - spacing() - ( item->pixmapRect().bottom() + 2 + textHeight ); + if ( item->x() != newX || item->y() != newY ) { + TQRect oldRect = item->rect(); + movedItems.prepend( item ); + item->move( newX, newY ); + if ( item->rect() != oldRect ) + repaintRegion = repaintRegion.unite( oldRect ); + } + } + delete bin; + bins[i][j] = 0L; + } + } + + // repaint + if ( newItemWidth ) + updateContents(); + else { + // Repaint only repaintRegion... + TQMemArray<TQRect> rects = repaintRegion.rects(); + for ( uint l = 0; l < rects.count(); l++ ) { + kdDebug( 1203 ) << "Repainting (" << rects[l].x() << "," + << rects[l].y() << ")\n"; + repaintContents( rects[l], false ); + } + // Repaint icons that were moved + while ( !movedItems.isEmpty() ) { + repaintItem( movedItems.first() ); + movedItems.remove( movedItems.first() ); + } + } + + for ( i = 0; i < nx ; i++ ) { + delete [] bins[i]; + } + delete [] bins; +} + +void KonqIconViewWidget::lineupIcons( TQIconView::Arrangement arrangement ) +{ + int x0, y0, dx, dy, nxmax, nymax; + gridValues( &x0, &y0, &dx, &dy, &nxmax, &nymax ); + int textHeight = iconTextHeight() * fontMetrics().height(); + + TQRegion repaintRegion; + TQValueList<TQIconViewItem*> movedItems; + int nx = 0, ny = 0; + + TQIconViewItem* item; + for ( item = firstItem(); item; item = item->nextItem() ) { + int newX = x0 + nx*dx + spacing() + + TQMAX(0, ( (dx-spacing()) - item->width() ) / 2); // icon can be larger as defined + // align all icons vertically to their text + int newY = y0 + ny*dy + dy - spacing() - ( item->pixmapRect().bottom() + 2 + textHeight ); + if ( item->x() != newX || item->y() != newY ) { + TQRect oldRect = item->rect(); + movedItems.prepend( item ); + item->move( newX, newY ); + if ( item->rect() != oldRect ) + repaintRegion = repaintRegion.unite( oldRect ); + } + if ( arrangement == TQIconView::LeftToRight ) { + nx++; + if ( nx >= nxmax ) { + ny++; + nx = 0; + } + } + else { + ny++; + if ( ny >= nymax ) { + nx++; + ny = 0; + } + } + } + + // Repaint only repaintRegion... + TQMemArray<TQRect> rects = repaintRegion.rects(); + for ( uint l = 0; l < rects.count(); l++ ) { + kdDebug( 1203 ) << "Repainting (" << rects[l].x() << "," + << rects[l].y() << ")\n"; + repaintContents( rects[l], false ); + } + // Repaint icons that were moved + while ( !movedItems.isEmpty() ) { + repaintItem( movedItems.first() ); + movedItems.remove( movedItems.first() ); + } +} + +int KonqIconViewWidget::largestPreviewIconSize( int size ) const +{ + int iconSize = size ? size : TDEGlobal::iconLoader()->currentSize( TDEIcon::Desktop ); + + if (iconSize < 28) + return 48; + if (iconSize < 40) + return 64; + if (iconSize < 60) + return 96; + if (iconSize < 120) + return 128; + + return 192; +} + +int KonqIconViewWidget::previewIconSize( int size ) const +{ + int iconSize = size ? size : TDEGlobal::iconLoader()->currentSize( TDEIcon::Desktop ); + + if (!d->bBoostPreview) + return iconSize; + + return largestPreviewIconSize( iconSize ); +} + +void KonqIconViewWidget::visualActivate(TQIconViewItem * item) +{ + // Rect of the TQIconViewItem. + TQRect irect = item->rect(); + + // Rect of the QIconViewItem's pixmap area. + TQRect rect = item->pixmapRect(); + + // Adjust to correct position. If this isn't done, the fact that the + // text may be wider than the pixmap puts us off-centre. + rect.moveBy(irect.x(), irect.y()); + + // Adjust for scrolling (David) + rect.moveBy( -contentsX(), -contentsY() ); + + if (TDEGlobalSettings::showKonqIconActivationEffect() == true) { + TDEIconEffect::visualActivate(viewport(), rect, item->pixmap()); + } +} + +void KonqIconViewWidget::backgroundPixmapChange( const TQPixmap & ) +{ + viewport()->update(); +} + +void KonqIconViewWidget::setPreviewSettings( const TQStringList& settings ) +{ + d->previewSettings = settings; + updatePreviewMimeTypes(); + + int size = m_size; + m_size = -1; // little trick to force grid change in setIcons + setIcons( size ); // force re-determining all icons +} + +const TQStringList& KonqIconViewWidget::previewSettings() +{ + return d->previewSettings; +} + +void KonqIconViewWidget::setNewURL( const TQString& url ) +{ + KURL u; + if ( url.startsWith( "/" ) ) + u.setPath( url ); + else + u = url; + setURL( u ); +} + +void KonqIconViewWidget::setCaseInsensitiveSort( bool b ) +{ + d->bCaseInsensitive = b; +} + +bool KonqIconViewWidget::caseInsensitiveSort() const +{ + return d->bCaseInsensitive; +} + +bool KonqIconViewWidget::canPreview( KFileItem* item ) +{ + if ( !TDEGlobalSettings::showFilePreview( url() ) ) + return false; + + if ( d->pPreviewMimeTypes == 0L ) + updatePreviewMimeTypes(); + + return mimeTypeMatch( item->mimetype(), *( d->pPreviewMimeTypes ) ); +} + +void KonqIconViewWidget::updatePreviewMimeTypes() +{ + if ( d->pPreviewMimeTypes == 0L ) + d->pPreviewMimeTypes = new TQStringList; + else + d->pPreviewMimeTypes->clear(); + + // Load the list of plugins to determine which mimetypes are supported + TDETrader::OfferList plugins = TDETrader::self()->query("ThumbCreator"); + TDETrader::OfferList::ConstIterator it; + + for ( it = plugins.begin(); it != plugins.end(); ++it ) { + if ( d->previewSettings.contains((*it)->desktopEntryName()) ) { + TQStringList mimeTypes = (*it)->property("MimeTypes").toStringList(); + for (TQStringList::ConstIterator mt = mimeTypes.begin(); mt != mimeTypes.end(); ++mt) + d->pPreviewMimeTypes->append(*mt); + } + } +} + +#include "konq_iconviewwidget.moc" |