summaryrefslogtreecommitdiffstats
path: root/kio/kfile/kfiletreeview.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'kio/kfile/kfiletreeview.cpp')
-rw-r--r--kio/kfile/kfiletreeview.cpp677
1 files changed, 677 insertions, 0 deletions
diff --git a/kio/kfile/kfiletreeview.cpp b/kio/kfile/kfiletreeview.cpp
new file mode 100644
index 000000000..542e80d5b
--- /dev/null
+++ b/kio/kfile/kfiletreeview.cpp
@@ -0,0 +1,677 @@
+/* This file is part of the KDEproject
+ Copyright (C) 2000 David Faure <faure@kde.org>
+ 2000 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.
+*/
+
+#include <qapplication.h>
+#include <qheader.h>
+#include <qtimer.h>
+#include <kdebug.h>
+#include <kdirnotify_stub.h>
+#include <kglobalsettings.h>
+#include <kfileitem.h>
+#include <kfileview.h>
+#include <kmimetype.h>
+#include <kstandarddirs.h>
+#include <stdlib.h>
+#include <assert.h>
+#include <kio/job.h>
+#include <kio/global.h>
+#include <kurldrag.h>
+#include <kiconloader.h>
+
+
+#include "kfiletreeview.h"
+#include "kfiletreebranch.h"
+#include "kfiletreeviewitem.h"
+
+KFileTreeView::KFileTreeView( QWidget *parent, const char *name )
+ : KListView( parent, name ),
+ m_wantOpenFolderPixmaps( true ),
+ m_toolTip( this )
+{
+ setDragEnabled(true);
+ setSelectionModeExt( KListView::Single );
+
+ m_animationTimer = new QTimer( this );
+ connect( m_animationTimer, SIGNAL( timeout() ),
+ this, SLOT( slotAnimation() ) );
+
+ m_currentBeforeDropItem = 0;
+ m_dropItem = 0;
+
+ m_autoOpenTimer = new QTimer( this );
+ connect( m_autoOpenTimer, SIGNAL( timeout() ),
+ this, SLOT( slotAutoOpenFolder() ) );
+
+ /* The executed-Slot only opens a path, while the expanded-Slot populates it */
+ connect( this, SIGNAL( executed( QListViewItem * ) ),
+ this, SLOT( slotExecuted( QListViewItem * ) ) );
+ connect( this, SIGNAL( expanded ( QListViewItem *) ),
+ this, SLOT( slotExpanded( QListViewItem *) ));
+ connect( this, SIGNAL( collapsed( QListViewItem *) ),
+ this, SLOT( slotCollapsed( QListViewItem* )));
+
+
+ /* connections from the konqtree widget */
+ connect( this, SIGNAL( selectionChanged() ),
+ this, SLOT( slotSelectionChanged() ) );
+ connect( this, SIGNAL( onItem( QListViewItem * )),
+ this, SLOT( slotOnItem( QListViewItem * ) ) );
+ connect( this, SIGNAL(itemRenamed(QListViewItem*, const QString &, int)),
+ this, SLOT(slotItemRenamed(QListViewItem*, const QString &, int)));
+
+
+ m_bDrag = false;
+ m_branches.setAutoDelete( true );
+
+ m_openFolderPixmap = DesktopIcon( "folder_open",KIcon::SizeSmall,KIcon::ActiveState );
+}
+
+KFileTreeView::~KFileTreeView()
+{
+ // we must make sure that the KFileTreeViewItems are deleted _before_ the
+ // branches are deleted. Otherwise, the KFileItems would be destroyed
+ // and the KFileTreeViewItems had dangling pointers to them.
+ hide();
+ clear();
+ m_branches.clear(); // finally delete the branches and KFileItems
+}
+
+
+bool KFileTreeView::isValidItem( QListViewItem *item)
+{
+ if (!item)
+ return false;
+ QPtrList<QListViewItem> lst;
+ QListViewItemIterator it( this );
+ while ( it.current() )
+ {
+ if ( it.current() == item )
+ return true;
+ ++it;
+ }
+ return false;
+}
+
+void KFileTreeView::contentsDragEnterEvent( QDragEnterEvent *ev )
+{
+ if ( ! acceptDrag( ev ) )
+ {
+ ev->ignore();
+ return;
+ }
+ ev->acceptAction();
+ m_currentBeforeDropItem = selectedItem();
+
+ QListViewItem *item = itemAt( contentsToViewport( ev->pos() ) );
+ if( item )
+ {
+ m_dropItem = item;
+ m_autoOpenTimer->start( KFileView::autoOpenDelay() );
+ }
+ else
+ {
+ m_dropItem = 0;
+}
+}
+
+void KFileTreeView::contentsDragMoveEvent( QDragMoveEvent *e )
+{
+ if( ! acceptDrag( e ) )
+ {
+ e->ignore();
+ return;
+ }
+ e->acceptAction();
+
+
+ QListViewItem *afterme;
+ QListViewItem *parent;
+
+ findDrop( e->pos(), parent, afterme );
+
+ // "afterme" is 0 when aiming at a directory itself
+ QListViewItem *item = afterme ? afterme : parent;
+
+ if( item && item->isSelectable() )
+ {
+ setSelected( item, true );
+ if( item != m_dropItem ) {
+ m_autoOpenTimer->stop();
+ m_dropItem = item;
+ m_autoOpenTimer->start( KFileView::autoOpenDelay() );
+ }
+ }
+ else
+ {
+ m_autoOpenTimer->stop();
+ m_dropItem = 0;
+ }
+}
+
+void KFileTreeView::contentsDragLeaveEvent( QDragLeaveEvent * )
+{
+ // Restore the current item to what it was before the dragging (#17070)
+ if ( isValidItem(m_currentBeforeDropItem) )
+ {
+ setSelected( m_currentBeforeDropItem, true );
+ ensureItemVisible( m_currentBeforeDropItem );
+ }
+ else if ( isValidItem(m_dropItem) )
+ setSelected( m_dropItem, false ); // no item selected
+ m_currentBeforeDropItem = 0;
+ m_dropItem = 0;
+
+}
+
+void KFileTreeView::contentsDropEvent( QDropEvent *e )
+{
+
+ m_autoOpenTimer->stop();
+ m_dropItem = 0;
+
+ kdDebug(250) << "contentsDropEvent !" << endl;
+ if( ! acceptDrag( e ) ) {
+ e->ignore();
+ return;
+ }
+
+ e->acceptAction();
+ QListViewItem *afterme;
+ QListViewItem *parent;
+ findDrop(e->pos(), parent, afterme);
+
+ //kdDebug(250) << " parent=" << (parent?parent->text(0):QString::null)
+ // << " afterme=" << (afterme?afterme->text(0):QString::null) << endl;
+
+ if (e->source() == viewport() && itemsMovable())
+ movableDropEvent(parent, afterme);
+ else
+ {
+ emit dropped(e, afterme);
+ emit dropped(this, e, afterme);
+ emit dropped(e, parent, afterme);
+ emit dropped(this, e, parent, afterme);
+
+ KURL::List urls;
+ KURLDrag::decode( e, urls );
+ emit dropped( this, e, urls );
+
+ KURL parentURL;
+ if( parent )
+ parentURL = static_cast<KFileTreeViewItem*>(parent)->url();
+ else
+ // can happen when dropping above the root item
+ // Should we choose the first branch in such a case ??
+ return;
+
+ emit dropped( urls, parentURL );
+ emit dropped( this , e, urls, parentURL );
+ }
+}
+
+bool KFileTreeView::acceptDrag(QDropEvent* e ) const
+{
+
+ bool ancestOK= acceptDrops();
+ // kdDebug(250) << "Do accept drops: " << ancestOK << endl;
+ ancestOK = ancestOK && itemsMovable();
+ // kdDebug(250) << "acceptDrag: " << ancestOK << endl;
+ // kdDebug(250) << "canDecode: " << KURLDrag::canDecode(e) << endl;
+ // kdDebug(250) << "action: " << e->action() << endl;
+
+ /* KListView::acceptDrag(e); */
+ /* this is what KListView does:
+ * acceptDrops() && itemsMovable() && (e->source()==viewport());
+ * ask acceptDrops and itemsMovable, but not the third
+ */
+ return ancestOK && KURLDrag::canDecode( e ) &&
+ // Why this test? All DnDs are one of those AFAIK (DF)
+ ( e->action() == QDropEvent::Copy
+ || e->action() == QDropEvent::Move
+ || e->action() == QDropEvent::Link );
+}
+
+
+
+QDragObject * KFileTreeView::dragObject()
+{
+
+ KURL::List urls;
+ const QPtrList<QListViewItem> fileList = selectedItems();
+ QPtrListIterator<QListViewItem> it( fileList );
+ for ( ; it.current(); ++it )
+ {
+ urls.append( static_cast<KFileTreeViewItem*>(it.current())->url() );
+ }
+ QPoint hotspot;
+ QPixmap pixmap;
+ if( urls.count() > 1 ){
+ pixmap = DesktopIcon( "kmultiple", 16 );
+ }
+ if( pixmap.isNull() )
+ pixmap = currentKFileTreeViewItem()->fileItem()->pixmap( 16 );
+ hotspot.setX( pixmap.width() / 2 );
+ hotspot.setY( pixmap.height() / 2 );
+ QDragObject* dragObject = new KURLDrag( urls, this );
+ if( dragObject )
+ dragObject->setPixmap( pixmap, hotspot );
+ return dragObject;
+}
+
+
+
+void KFileTreeView::slotCollapsed( QListViewItem *item )
+{
+ KFileTreeViewItem *kftvi = static_cast<KFileTreeViewItem*>(item);
+ kdDebug(250) << "hit slotCollapsed" << endl;
+ if( kftvi && kftvi->isDir())
+ {
+ item->setPixmap( 0, itemIcon(kftvi));
+ }
+}
+
+void KFileTreeView::slotExpanded( QListViewItem *item )
+{
+ kdDebug(250) << "slotExpanded here !" << endl;
+
+ if( ! item ) return;
+
+ KFileTreeViewItem *it = static_cast<KFileTreeViewItem*>(item);
+ KFileTreeBranch *branch = it->branch();
+
+ /* Start the animation for the branch object */
+ if( it->isDir() && branch && item->childCount() == 0 )
+ {
+ /* check here if the branch really needs to be populated again */
+ kdDebug(250 ) << "starting to open " << it->url().prettyURL() << endl;
+ startAnimation( it );
+ bool branchAnswer = branch->populate( it->url(), it );
+ kdDebug(250) << "Branches answer: " << branchAnswer << endl;
+ if( ! branchAnswer )
+ {
+ kdDebug(250) << "ERR: Could not populate!" << endl;
+ stopAnimation( it );
+ }
+ }
+
+ /* set a pixmap 'open folder' */
+ if( it->isDir() && isOpen( item ) )
+ {
+ kdDebug(250)<< "Setting open Pixmap" << endl;
+ item->setPixmap( 0, itemIcon( it )); // 0, m_openFolderPixmap );
+ }
+}
+
+
+
+void KFileTreeView::slotExecuted( QListViewItem *item )
+{
+ if ( !item )
+ return;
+ /* This opens the dir and causes the Expanded-slot to be called,
+ * which strolls through the children.
+ */
+ if( static_cast<KFileTreeViewItem*>(item)->isDir())
+ {
+ item->setOpen( !item->isOpen() );
+ }
+}
+
+
+void KFileTreeView::slotAutoOpenFolder()
+{
+ m_autoOpenTimer->stop();
+
+ if ( !isValidItem(m_dropItem) || m_dropItem->isOpen() )
+ return;
+
+ m_dropItem->setOpen( true );
+ m_dropItem->repaint();
+}
+
+
+void KFileTreeView::slotSelectionChanged()
+{
+ if ( !m_dropItem ) // don't do this while the dragmove thing
+ {
+ }
+}
+
+
+KFileTreeBranch* KFileTreeView::addBranch( const KURL &path, const QString& name,
+ bool showHidden )
+{
+ const QPixmap& folderPix = KMimeType::mimeType("inode/directory")->pixmap( KIcon::Desktop,KIcon::SizeSmall );
+
+ return addBranch( path, name, folderPix, showHidden);
+}
+
+KFileTreeBranch* KFileTreeView::addBranch( const KURL &path, const QString& name,
+ const QPixmap& pix, bool showHidden )
+{
+ kdDebug(250) << "adding another root " << path.prettyURL() << endl;
+
+ /* Open a new branch */
+ KFileTreeBranch *newBranch = new KFileTreeBranch( this, path, name, pix,
+ showHidden );
+ return addBranch(newBranch);
+}
+
+KFileTreeBranch *KFileTreeView::addBranch(KFileTreeBranch *newBranch)
+{
+ connect( newBranch, SIGNAL(populateFinished( KFileTreeViewItem* )),
+ this, SLOT( slotPopulateFinished( KFileTreeViewItem* )));
+
+ connect( newBranch, SIGNAL( newTreeViewItems( KFileTreeBranch*,
+ const KFileTreeViewItemList& )),
+ this, SLOT( slotNewTreeViewItems( KFileTreeBranch*,
+ const KFileTreeViewItemList& )));
+
+ m_branches.append( newBranch );
+ return( newBranch );
+}
+
+KFileTreeBranch *KFileTreeView::branch( const QString& searchName )
+{
+ KFileTreeBranch *branch = 0;
+ QPtrListIterator<KFileTreeBranch> it( m_branches );
+
+ while ( (branch = it.current()) != 0 ) {
+ ++it;
+ QString bname = branch->name();
+ kdDebug(250) << "This is the branches name: " << bname << endl;
+ if( bname == searchName )
+ {
+ kdDebug(250) << "Found branch " << bname << " and return ptr" << endl;
+ return( branch );
+ }
+ }
+ return ( 0L );
+}
+
+KFileTreeBranchList& KFileTreeView::branches()
+{
+ return( m_branches );
+}
+
+
+bool KFileTreeView::removeBranch( KFileTreeBranch *branch )
+{
+ if(m_branches.contains(branch))
+ {
+ delete (branch->root());
+ m_branches.remove( branch );
+ return true;
+ }
+ else
+ {
+ return false;
+ }
+}
+
+void KFileTreeView::setDirOnlyMode( KFileTreeBranch* branch, bool bom )
+{
+ if( branch )
+ {
+ branch->setDirOnlyMode( bom );
+ }
+}
+
+
+void KFileTreeView::slotPopulateFinished( KFileTreeViewItem *it )
+{
+ if( it && it->isDir())
+ stopAnimation( it );
+}
+
+void KFileTreeView::slotNewTreeViewItems( KFileTreeBranch* branch, const KFileTreeViewItemList& itemList )
+{
+ if( ! branch ) return;
+ kdDebug(250) << "hitting slotNewTreeViewItems" << endl;
+
+ /* Sometimes it happens that new items should become selected, i.e. if the user
+ * creates a new dir, he probably wants it to be selected. This can not be done
+ * right after creating the directory or file, because it takes some time until
+ * the item appears here in the treeview. Thus, the creation code sets the member
+ * m_neUrlToSelect to the required url. If this url appears here, the item becomes
+ * selected and the member nextUrlToSelect will be cleared.
+ */
+ if( ! m_nextUrlToSelect.isEmpty() )
+ {
+ KFileTreeViewItemListIterator it( itemList );
+
+ bool end = false;
+ for( ; !end && it.current(); ++it )
+ {
+ KURL url = (*it)->url();
+
+ if( m_nextUrlToSelect.equals(url, true )) // ignore trailing / on dirs
+ {
+ setCurrentItem( static_cast<QListViewItem*>(*it) );
+ m_nextUrlToSelect = KURL();
+ end = true;
+ }
+ }
+ }
+}
+
+QPixmap KFileTreeView::itemIcon( KFileTreeViewItem *item, int gap ) const
+{
+ QPixmap pix;
+ kdDebug(250) << "Setting icon for column " << gap << endl;
+
+ if( item )
+ {
+ /* Check if it is a branch root */
+ KFileTreeBranch *brnch = item->branch();
+ if( item == brnch->root() )
+ {
+ pix = brnch->pixmap();
+ if( m_wantOpenFolderPixmaps && brnch->root()->isOpen() )
+ {
+ pix = brnch->openPixmap();
+ }
+ }
+ else
+ {
+ // TODO: different modes, user Pixmaps ?
+ pix = item->fileItem()->pixmap( KIcon::SizeSmall ); // , KIcon::DefaultState);
+
+ /* Only if it is a dir and the user wants open dir pixmap and it is open,
+ * change the fileitem's pixmap to the open folder pixmap. */
+ if( item->isDir() && m_wantOpenFolderPixmaps )
+ {
+ if( isOpen( static_cast<QListViewItem*>(item)))
+ pix = m_openFolderPixmap;
+ }
+ }
+ }
+
+ return pix;
+}
+
+
+void KFileTreeView::slotAnimation()
+{
+ MapCurrentOpeningFolders::Iterator it = m_mapCurrentOpeningFolders.begin();
+ MapCurrentOpeningFolders::Iterator end = m_mapCurrentOpeningFolders.end();
+ for (; it != end;)
+ {
+ KFileTreeViewItem *item = it.key();
+ if (!isValidItem(item))
+ {
+ ++it;
+ m_mapCurrentOpeningFolders.remove(item);
+ continue;
+ }
+
+ uint & iconNumber = it.data().iconNumber;
+ QString icon = QString::fromLatin1( it.data().iconBaseName ).append( QString::number( iconNumber ) );
+ // kdDebug(250) << "Loading icon " << icon << endl;
+ item->setPixmap( 0, DesktopIcon( icon,KIcon::SizeSmall,KIcon::ActiveState )); // KFileTreeViewFactory::instance() ) );
+
+ iconNumber++;
+ if ( iconNumber > it.data().iconCount )
+ iconNumber = 1;
+
+ ++it;
+ }
+}
+
+
+void KFileTreeView::startAnimation( KFileTreeViewItem * item, const char * iconBaseName, uint iconCount )
+{
+ /* TODO: allow specific icons */
+ if( ! item )
+ {
+ kdDebug(250) << " startAnimation Got called without valid item !" << endl;
+ return;
+ }
+
+ m_mapCurrentOpeningFolders.insert( item,
+ AnimationInfo( iconBaseName,
+ iconCount,
+ itemIcon(item, 0) ) );
+ if ( !m_animationTimer->isActive() )
+ m_animationTimer->start( 50 );
+}
+
+void KFileTreeView::stopAnimation( KFileTreeViewItem * item )
+{
+ if( ! item ) return;
+
+ kdDebug(250) << "Stoping Animation !" << endl;
+
+ MapCurrentOpeningFolders::Iterator it = m_mapCurrentOpeningFolders.find(item);
+ if ( it != m_mapCurrentOpeningFolders.end() )
+ {
+ if( item->isDir() && isOpen( item) )
+ {
+ kdDebug(250) << "Setting folder open pixmap !" << endl;
+ item->setPixmap( 0, itemIcon( item ));
+ }
+ else
+ {
+ item->setPixmap( 0, it.data().originalPixmap );
+ }
+ m_mapCurrentOpeningFolders.remove( item );
+ }
+ else
+ {
+ if( item )
+ kdDebug(250)<< "StopAnimation - could not find item " << item->url().prettyURL()<< endl;
+ else
+ kdDebug(250)<< "StopAnimation - item is zero !" << endl;
+ }
+ if (m_mapCurrentOpeningFolders.isEmpty())
+ m_animationTimer->stop();
+}
+
+KFileTreeViewItem * KFileTreeView::currentKFileTreeViewItem() const
+{
+ return static_cast<KFileTreeViewItem *>( selectedItem() );
+}
+
+KURL KFileTreeView::currentURL() const
+{
+ KFileTreeViewItem *item = currentKFileTreeViewItem();
+ if ( item )
+ return currentKFileTreeViewItem()->url();
+ else
+ return KURL();
+}
+
+void KFileTreeView::slotOnItem( QListViewItem *item )
+{
+ KFileTreeViewItem *i = static_cast<KFileTreeViewItem *>( item );
+ if( i )
+ {
+ const KURL url = i->url();
+ if ( url.isLocalFile() )
+ emit onItem( url.path() );
+ else
+ emit onItem( url.prettyURL() );
+ }
+}
+
+void KFileTreeView::slotItemRenamed(QListViewItem* item, const QString &name, int col)
+{
+ (void) item;
+ kdDebug(250) << "Do not bother: " << name << col << endl;
+}
+
+KFileTreeViewItem *KFileTreeView::findItem( const QString& branchName, const QString& relUrl )
+{
+ KFileTreeBranch *br = branch( branchName );
+ return( findItem( br, relUrl ));
+}
+
+KFileTreeViewItem *KFileTreeView::findItem( KFileTreeBranch* brnch, const QString& relUrl )
+{
+ KFileTreeViewItem *ret = 0;
+ if( brnch )
+ {
+ KURL url = brnch->rootUrl();
+
+ if( ! relUrl.isEmpty() && QDir::isRelativePath(relUrl) )
+ {
+ QString partUrl( relUrl );
+
+ if( partUrl.endsWith("/"))
+ partUrl.truncate( relUrl.length()-1 );
+
+ url.addPath( partUrl );
+
+ kdDebug(250) << "assembled complete dir string " << url.prettyURL() << endl;
+
+ KFileItem *fi = brnch->findByURL( url );
+ if( fi )
+ {
+ ret = static_cast<KFileTreeViewItem*>( fi->extraData( brnch ));
+ kdDebug(250) << "Found item !" <<ret << endl;
+ }
+ }
+ else
+ {
+ ret = brnch->root();
+ }
+ }
+ return( ret );
+}
+
+///////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////
+
+
+void KFileTreeViewToolTip::maybeTip( const QPoint & )
+{
+#if 0
+ QListViewItem *item = m_view->itemAt( point );
+ if ( item ) {
+ QString text = static_cast<KFileViewItem*>( item )->toolTipText();
+ if ( !text.isEmpty() )
+ tip ( m_view->itemRect( item ), text );
+ }
+#endif
+}
+
+void KFileTreeView::virtual_hook( int id, void* data )
+{ KListView::virtual_hook( id, data ); }
+
+#include "kfiletreeview.moc"