|
|
|
/*
|
|
|
|
* File name: kcleanupcollection.cpp
|
|
|
|
* Summary: Support classes for KDirStat
|
|
|
|
* License: LGPL - See file COPYING.LIB for details.
|
|
|
|
* Author: Stefan Hundhammer <sh@suse.de>
|
|
|
|
*
|
|
|
|
* Updated: 2004-11-23
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
|
|
#include <tdelocale.h>
|
|
|
|
#include "kcleanup.h"
|
|
|
|
#include "kstdcleanup.h"
|
|
|
|
#include "kcleanupcollection.h"
|
|
|
|
|
|
|
|
|
|
|
|
using namespace KDirStat;
|
|
|
|
|
|
|
|
|
|
|
|
KCleanupCollection::KCleanupCollection( TDEActionCollection * actionCollection )
|
|
|
|
: TQObject()
|
|
|
|
, _actionCollection( actionCollection )
|
|
|
|
{
|
|
|
|
/**
|
|
|
|
* All cleanups beloningt to this collection are stored in two separate TQt
|
|
|
|
* collections, a TQList and a TQDict. Make _one_ of them manage the cleanup
|
|
|
|
* objects, i.e. have them clear the KCleanup objects upon deleting. The
|
|
|
|
* TQList is the master collection, the TQDict the slave.
|
|
|
|
**/
|
|
|
|
|
|
|
|
_cleanupList.setAutoDelete( true );
|
|
|
|
_cleanupDict.setAutoDelete( false );
|
|
|
|
|
|
|
|
_nextUserCleanupNo = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
KCleanupCollection::KCleanupCollection( const KCleanupCollection &src )
|
|
|
|
: TQObject()
|
|
|
|
{
|
|
|
|
deepCopy( src );
|
|
|
|
|
|
|
|
// Keep consistent with the KCleanup copy constructor: It explicitly uses a
|
|
|
|
// zero TDEActionCollecton to make sure no duplicates of cleanups get into
|
|
|
|
// the action collection.
|
|
|
|
_actionCollection = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
KCleanupCollection::~KCleanupCollection()
|
|
|
|
{
|
|
|
|
// No need to delete the cleanups: _cleanupList takes care of that
|
|
|
|
// (autoDelete!).
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
KCleanupCollection &
|
|
|
|
KCleanupCollection::operator= ( const KCleanupCollection &src )
|
|
|
|
{
|
|
|
|
if ( size() != src.size() )
|
|
|
|
{
|
|
|
|
/**
|
|
|
|
* If the sizes are different, we really need to make a deep copy -
|
|
|
|
* i.e. discard all the existing cleanups in this collection and create
|
|
|
|
* new ones with the KCleanup copy constructor.
|
|
|
|
**/
|
|
|
|
|
|
|
|
// kdDebug() << k_funcinfo << "Sizes different - deep copy" << endl;
|
|
|
|
|
|
|
|
deepCopy( src );
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
/**
|
|
|
|
* If the sizes are the same, we'd rather just use the KCleanup
|
|
|
|
* assignment operator to individually assign each cleanup in the
|
|
|
|
* source collection to the corresponding one in this collection.
|
|
|
|
*
|
|
|
|
* The background of this seemingly awkward solution are (again) the
|
|
|
|
* limitations of the KCleanup copy constructor: It doesn't make a
|
|
|
|
* truly identical copy of the entire KCleanup object. Rather, it
|
|
|
|
* copies only the KCleanup members and leaves most of the TDEAction
|
|
|
|
* members (the parent class) untouched.
|
|
|
|
*
|
|
|
|
* The behaviour implemented here comes handy in the most common
|
|
|
|
* situation where this assignment operator is used:
|
|
|
|
*
|
|
|
|
* KCleanupCollection tmpCollection( origCollection );
|
|
|
|
* ...
|
|
|
|
* ... // let use change settings in settings dialog
|
|
|
|
* ...
|
|
|
|
* origCollection = tmpCollection;
|
|
|
|
*
|
|
|
|
* 'tmpCollection' here is an incomplete copy of 'origCollection' -
|
|
|
|
* which represents what the user really can see in the menus, i.e. all
|
|
|
|
* the TDEAction stuff in there really needs to work.
|
|
|
|
*
|
|
|
|
* During changing preferences in the 'settings' dialog, the user only
|
|
|
|
* changes 'tmpCollection' - if he chooses to abandon his changes
|
|
|
|
* (e.g., he clicks on the 'cancel' button), no harm is done -
|
|
|
|
* 'tmpCollection' is simply not copied back to
|
|
|
|
* 'origCollection'. Anyway, since 'tmpCollection' is merely a
|
|
|
|
* container for the true KCleanup members, the TDEAction members don't
|
|
|
|
* matter here: There is no representation of 'tmpCollection' in any
|
|
|
|
* menu or tool bar.
|
|
|
|
*
|
|
|
|
* As soon as the user clicks on 'apply' or 'ok' in the 'settings'
|
|
|
|
* dialog, however, 'tmpCollection' is copied back to 'origCollection'
|
|
|
|
* - that is, its KCleanup members. Most of the TDEAction members (other
|
|
|
|
* than 'text()' which is explicitly copied back) remain untouched,
|
|
|
|
* thus maintaining consistency with the user interface is guaranteed.
|
|
|
|
**/
|
|
|
|
|
|
|
|
// kdDebug() << k_funcinfo << "Same sizes - individual assignment" << endl;
|
|
|
|
|
|
|
|
KCleanupList srcList = src.cleanupList();
|
|
|
|
KCleanupListIterator srcIt( srcList );
|
|
|
|
KCleanupListIterator destIt( _cleanupList );
|
|
|
|
|
|
|
|
while ( *srcIt && *destIt )
|
|
|
|
{
|
|
|
|
// kdDebug() << "Assigning " << *srcIt << endl;
|
|
|
|
**destIt = **srcIt;
|
|
|
|
++srcIt;
|
|
|
|
++destIt;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Intentionally leaving '_actionCollection' untouched!
|
|
|
|
|
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void
|
|
|
|
KCleanupCollection::deepCopy( const KCleanupCollection &src )
|
|
|
|
{
|
|
|
|
// Copy simple values
|
|
|
|
_nextUserCleanupNo = src.nextUserCleanupNo();
|
|
|
|
|
|
|
|
// Just to make sure - clear the internal collections
|
|
|
|
_cleanupList.clear();
|
|
|
|
_cleanupDict.clear();
|
|
|
|
|
|
|
|
|
|
|
|
// Make a deep copy of all the cleanups in the source collection
|
|
|
|
|
|
|
|
KCleanupList srcList = src.cleanupList();
|
|
|
|
KCleanupListIterator it( srcList );
|
|
|
|
|
|
|
|
while ( *it )
|
|
|
|
{
|
|
|
|
// kdDebug() << k_funcinfo << "Creating new " << *it << endl;
|
|
|
|
|
|
|
|
add( new KCleanup( **it ) );
|
|
|
|
++it;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void
|
|
|
|
KCleanupCollection::add( KCleanup *newCleanup )
|
|
|
|
{
|
|
|
|
TQ_CHECK_PTR( newCleanup );
|
|
|
|
|
|
|
|
if ( _cleanupDict[ newCleanup->id() ] ) // Already there?
|
|
|
|
{
|
|
|
|
// Delete any old instance in the list.
|
|
|
|
//
|
|
|
|
// The instance in the dict will be deleted automatically by inserting
|
|
|
|
// the new one.
|
|
|
|
|
|
|
|
_cleanupList.first(); // Moves _cleanupList.current() to beginning
|
|
|
|
|
|
|
|
while ( _cleanupList.current() )
|
|
|
|
{
|
|
|
|
if ( _cleanupList.current()->id() == newCleanup->id() )
|
|
|
|
{
|
|
|
|
// Found a cleanup with the same ID -
|
|
|
|
// remove the current list item, delete it (autoDelete!) and
|
|
|
|
// move _cleanupList.current() to the next item.
|
|
|
|
|
|
|
|
_cleanupList.remove();
|
|
|
|
}
|
|
|
|
else
|
|
|
|
_cleanupList.next();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
_cleanupList.append( newCleanup );
|
|
|
|
_cleanupDict.insert( newCleanup->id(), newCleanup );
|
|
|
|
|
|
|
|
connect( this, TQT_SIGNAL( selectionChanged( KFileInfo * ) ),
|
|
|
|
newCleanup, TQT_SLOT ( selectionChanged( KFileInfo * ) ) );
|
|
|
|
|
|
|
|
connect( this, TQT_SIGNAL( readConfig() ),
|
|
|
|
newCleanup, TQT_SLOT ( readConfig() ) );
|
|
|
|
|
|
|
|
connect( this, TQT_SIGNAL( saveConfig() ),
|
|
|
|
newCleanup, TQT_SLOT ( saveConfig() ) );
|
|
|
|
|
|
|
|
connect( newCleanup, TQT_SIGNAL( executed() ),
|
|
|
|
this, TQT_SLOT ( cleanupExecuted() ) );
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void
|
|
|
|
KCleanupCollection::addStdCleanups()
|
|
|
|
{
|
|
|
|
add( KStdCleanup::openInKonqueror ( _actionCollection ) );
|
|
|
|
add( KStdCleanup::openInTerminal ( _actionCollection ) );
|
|
|
|
add( KStdCleanup::compressSubtree ( _actionCollection ) );
|
|
|
|
add( KStdCleanup::makeClean ( _actionCollection ) );
|
|
|
|
add( KStdCleanup::deleteTrash ( _actionCollection ) );
|
|
|
|
add( KStdCleanup::moveToTrashBin ( _actionCollection ) );
|
|
|
|
add( KStdCleanup::hardDelete ( _actionCollection ) );
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void
|
|
|
|
KCleanupCollection::addUserCleanups( int number )
|
|
|
|
{
|
|
|
|
for ( int i=0; i < number; i++ )
|
|
|
|
{
|
|
|
|
TQString id;
|
|
|
|
id.sprintf( "cleanup_user_defined_%d", _nextUserCleanupNo );
|
|
|
|
TQString title;
|
|
|
|
|
|
|
|
if ( _nextUserCleanupNo <= 9 )
|
|
|
|
// Provide a keyboard shortcut for cleanup #0..#9
|
|
|
|
title=i18n( "User Defined Cleanup #&%1" ).arg(_nextUserCleanupNo);
|
|
|
|
else
|
|
|
|
// No keyboard shortcuts for cleanups #10.. - they would be duplicates
|
|
|
|
title=i18n( "User Defined Cleanup #%1" ).arg(_nextUserCleanupNo);
|
|
|
|
|
|
|
|
_nextUserCleanupNo++;
|
|
|
|
|
|
|
|
KCleanup *cleanup = new KCleanup( id, "", title, _actionCollection );
|
|
|
|
TQ_CHECK_PTR( cleanup );
|
|
|
|
cleanup->setEnabled( false );
|
|
|
|
|
|
|
|
if ( i <= 9 )
|
|
|
|
{
|
|
|
|
// Provide an application-wide keyboard accelerator for cleanup #0..#9
|
|
|
|
cleanup->setShortcut( TQt::CTRL + TQt::Key_0 + i );
|
|
|
|
}
|
|
|
|
|
|
|
|
add( cleanup );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
KCleanup *
|
|
|
|
KCleanupCollection::cleanup( const TQString & id )
|
|
|
|
{
|
|
|
|
return _cleanupDict[ id ];
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void
|
|
|
|
KCleanupCollection::clear()
|
|
|
|
{
|
|
|
|
_cleanupList.clear();
|
|
|
|
_cleanupDict.clear();
|
|
|
|
_nextUserCleanupNo = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void
|
|
|
|
KCleanupCollection::slotReadConfig()
|
|
|
|
{
|
|
|
|
emit readConfig();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void
|
|
|
|
KCleanupCollection::cleanupExecuted()
|
|
|
|
{
|
|
|
|
emit userActivity( 10 );
|
|
|
|
}
|
|
|
|
|
|
|
|
#include "kcleanupcollection.moc"
|
|
|
|
// EOF
|