File indexing completed on 2024-04-21 08:39:56

 /*
     SPDX-FileCopyrightText: 1998-2008 Sebastian Trueg <trueg@k3b.org>
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include "k3bplacesmodel.h"
 #include "k3bdevicemodel.h"
 
 #include "k3bcore.h"
 #include "k3bdevice.h"
 #include "k3bdevicemanager.h"
 #include "k3bmediacache.h"
 #include "k3bmedium.h"
 
 #include <KDirSortFilterProxyModel>
 #include <KFilePlacesModel>
 #include <KDirModel>
 #include <KDirLister>
 #include <Solid/StorageAccess>
 
 #include <QIcon>
 
 typedef QMap<KDirModel*, KDirSortFilterProxyModel*> DirModels;
 
 
 class K3b::PlacesModel::Private
 {
 public:
     K3b::DeviceModel* deviceModel;
     KFilePlacesModel* filePlacesModel;
     DirModels dirModels;
 };
 
 
 
 K3b::PlacesModel::PlacesModel( QObject* parent )
     : K3b::MetaItemModel( parent ),
       d( new Private() )
 {
     d->deviceModel = new K3b::DeviceModel( this );
     d->filePlacesModel = new KFilePlacesModel( this );
     addSubModel( "Devices", QIcon::fromTheme( "media-optical" ), d->deviceModel, true );
     
     // TODO: Currently our place list doesn't follow changes KFilePlacesModel.
     //       This needs to be changed. Adding, removing and editing places would be also nice.
     for( int i = 0; i < d->filePlacesModel->rowCount(); ++i ) {
         QModelIndex place = d->filePlacesModel->index( i, 0 );
         QUrl url = d->filePlacesModel->url( place );
         
         // Let's filter out device-related places
         // and custom protocols (we doesn't support burning from them)
         if( !d->filePlacesModel->isDevice( place ) && url.isLocalFile() ) {
             addPlace(
                 d->filePlacesModel->text( place ),
                 d->filePlacesModel->icon( place ),
                 url );
         }
     }
 
     connect( d->deviceModel, SIGNAL(modelAboutToBeReset()),
              this, SIGNAL(modelAboutToBeReset()) );
     connect( d->deviceModel, SIGNAL(modelReset()),
              this, SIGNAL(modelReset()) );
     connect( k3bcore->deviceManager(), SIGNAL(changed(K3b::Device::DeviceManager*)),
              this, SLOT(slotDevicesChanged(K3b::Device::DeviceManager*)) );
     slotDevicesChanged( k3bcore->deviceManager() );
 }
 
 
 K3b::PlacesModel::~PlacesModel()
 {
     delete d;
 }
 
 
 KFileItem K3b::PlacesModel::itemForIndex( const QModelIndex& index ) const
 {
     // KDirSortFilterProxyModel does not have the Q_OBJECT macro. Thus, we need to use dynamic_cast
     KDirSortFilterProxyModel* proxy = dynamic_cast<KDirSortFilterProxyModel*>( subModelForIndex( index ) );
     if ( proxy ) {
         KDirModel* model = qobject_cast<KDirModel*>( proxy->sourceModel() );
         return model->itemForIndex( proxy->mapToSource( mapToSubModel( index ) ) );
     }
     return KFileItem();
 }
 
 
 K3b::Device::Device* K3b::PlacesModel::deviceForIndex( const QModelIndex& index ) const
 {
     if ( qobject_cast<K3b::DeviceModel*>( subModelForIndex( index ) ) == d->deviceModel ) {
         return d->deviceModel->deviceForIndex( mapToSubModel( index ) );
     }
     return 0;
 }
 
 
 QModelIndex K3b::PlacesModel::indexForDevice( K3b::Device::Device* dev ) const
 {
     return mapFromSubModel( d->deviceModel->indexForDevice( dev ) );
 }
 
 
 void K3b::PlacesModel::expandToUrl( const QUrl& url )
 {
     qDebug() << url;
     
     // Check if url is not device's
     Q_FOREACH( Device::Device* device, d->deviceModel->devices() )
     {
         if( Solid::StorageAccess* solidStorage = device->solidStorage() ) {
             QUrl parent = QUrl::fromLocalFile( solidStorage->filePath() );
             if( parent.isParentOf( url ) ) {
                 qDebug() << url << "will be expanded to device" << device->description();
                 emit expand( mapFromSubModel( d->deviceModel->indexForDevice( device ) ) );
                 return;
             }
         }
         else if( url.scheme() == "audiocd" )
         {
             const Medium& medium = k3bcore->mediaCache()->medium( device );
             if( medium.content() & Medium::ContentAudio )
             {
                 qDebug() << url << "will be expanded to device" << device->description();
                 emit expand( mapFromSubModel( d->deviceModel->indexForDevice( device ) ) );
                 return;
             }
         }
     }
 
     // search for the best suited place that contains this URL
     int maxDepth = 0;
     KDirModel* modelToExpand = 0;
 
     for( DirModels::iterator it = d->dirModels.begin(); it != d->dirModels.end(); ++it ) {
         KDirModel* model = it.key();
         QUrl parent = model->dirLister()->url();
         if ( parent.isParentOf( url ) ) {
             if ( parent.path().length() > maxDepth ) {
                 maxDepth = parent.path().length();
                 modelToExpand = model;
             }
         }
     }
 
     if ( modelToExpand ) {
         qDebug() << modelToExpand->dirLister()->url() << " will be expanded.";
         if( modelToExpand->dirLister()->url().matches( url, QUrl::StripTrailingSlash ) ) {
             emit expand( indexForSubModel( d->dirModels[ modelToExpand ] ) );
         }
         else {
             modelToExpand->expandToUrl( url );
         }
     }
 }
 
 
 void K3b::PlacesModel::addPlace( const QString& name, const QIcon& icon, const QUrl& rootUrl )
 {
     KDirModel* model = new KDirModel( this );
     connect( model, SIGNAL(expand(QModelIndex)), this, SLOT(slotExpand(QModelIndex)) );
     model->dirLister()->setAutoErrorHandlingEnabled( false );
     model->dirLister()->setDirOnlyMode( true );
     model->dirLister()->openUrl( rootUrl, KDirLister::Keep );
 
     KDirSortFilterProxyModel* proxy = new KDirSortFilterProxyModel( model );
     proxy->setSourceModel( model );
     d->dirModels.insert( model, proxy );
     addSubModel( name, icon, proxy );
 }
 
 
 void K3b::PlacesModel::slotExpand( const QModelIndex& index )
 {
     qDebug() << index;
     KDirModel* model = ( KDirModel* )index.model();
     emit expand( mapFromSubModel( d->dirModels[model]->mapFromSource( index ) ) );
 }
 
 
 void K3b::PlacesModel::slotDevicesChanged( K3b::Device::DeviceManager* dm )
 {
     qDebug();
     d->deviceModel->setDevices( dm->allDevices() );
 }
 
 #include "moc_k3bplacesmodel.cpp"