00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021 #include <unistd.h>
00022
00023 #include <qdir.h>
00024 #include <qapplication.h>
00025 #include <qdialog.h>
00026 #include <qlabel.h>
00027 #include <qlayout.h>
00028 #include <qpushbutton.h>
00029 #include <qpopupmenu.h>
00030 #include <qregexp.h>
00031 #include <qtimer.h>
00032 #include <qvbox.h>
00033
00034 #include <kaction.h>
00035 #include <kapplication.h>
00036 #include <kdebug.h>
00037 #include <kdialog.h>
00038 #include <kdialogbase.h>
00039 #include <kdirlister.h>
00040 #include <kinputdialog.h>
00041 #include <klocale.h>
00042 #include <kmessagebox.h>
00043 #include <kpopupmenu.h>
00044 #include <kprogress.h>
00045 #include <kstdaction.h>
00046 #include <kio/job.h>
00047 #include <kio/jobclasses.h>
00048 #include <kio/netaccess.h>
00049 #include <kio/previewjob.h>
00050 #include <kpropertiesdialog.h>
00051 #include <kservicetypefactory.h>
00052 #include <kstdaccel.h>
00053
00054 #include "config-kfile.h"
00055 #include "kcombiview.h"
00056 #include "kdiroperator.h"
00057 #include "kfiledetailview.h"
00058 #include "kfileiconview.h"
00059 #include "kfilepreview.h"
00060 #include "kfileview.h"
00061 #include "kfileitem.h"
00062 #include "kfilemetapreview.h"
00063
00064
00065 template class QPtrStack<KURL>;
00066 template class QDict<KFileItem>;
00067
00068
00069 class KDirOperator::KDirOperatorPrivate
00070 {
00071 public:
00072 KDirOperatorPrivate() {
00073 onlyDoubleClickSelectsFiles = false;
00074 progressDelayTimer = 0L;
00075 dirHighlighting = false;
00076 config = 0L;
00077 dropOptions = 0;
00078 }
00079
00080 ~KDirOperatorPrivate() {
00081 delete progressDelayTimer;
00082 }
00083
00084 bool dirHighlighting;
00085 QString lastURL;
00086 bool onlyDoubleClickSelectsFiles;
00087 QTimer *progressDelayTimer;
00088 KActionSeparator *viewActionSeparator;
00089 int dropOptions;
00090
00091 KConfig *config;
00092 QString configGroup;
00093 };
00094
00095 KDirOperator::KDirOperator(const KURL& _url,
00096 QWidget *parent, const char* _name)
00097 : QWidget(parent, _name),
00098 dir(0),
00099 m_fileView(0),
00100 progress(0)
00101 {
00102 myPreview = 0L;
00103 myMode = KFile::File;
00104 m_viewKind = KFile::Simple;
00105 mySorting = static_cast<QDir::SortSpec>(QDir::Name | QDir::DirsFirst);
00106 d = new KDirOperatorPrivate;
00107
00108 if (_url.isEmpty()) {
00109 QString strPath = QDir::currentDirPath();
00110 strPath.append('/');
00111 currUrl = KURL();
00112 currUrl.setProtocol(QString::fromLatin1("file"));
00113 currUrl.setPath(strPath);
00114 }
00115 else {
00116 currUrl = _url;
00117 if ( currUrl.protocol().isEmpty() )
00118 currUrl.setProtocol(QString::fromLatin1("file"));
00119
00120 currUrl.addPath("/");
00121 }
00122
00123 setDirLister( new KDirLister( true ) );
00124
00125 connect(&myCompletion, SIGNAL(match(const QString&)),
00126 SLOT(slotCompletionMatch(const QString&)));
00127
00128 progress = new KProgress(this, "progress");
00129 progress->adjustSize();
00130 progress->move(2, height() - progress->height() -2);
00131
00132 d->progressDelayTimer = new QTimer( this, "progress delay timer" );
00133 connect( d->progressDelayTimer, SIGNAL( timeout() ),
00134 SLOT( slotShowProgress() ));
00135
00136 myCompleteListDirty = false;
00137
00138 backStack.setAutoDelete( true );
00139 forwardStack.setAutoDelete( true );
00140
00141
00142 setupActions();
00143 setupMenu();
00144
00145 setFocusPolicy(QWidget::WheelFocus);
00146 }
00147
00148 KDirOperator::~KDirOperator()
00149 {
00150 resetCursor();
00151 if ( m_fileView )
00152 {
00153 if ( d->config )
00154 m_fileView->writeConfig( d->config, d->configGroup );
00155
00156 delete m_fileView;
00157 m_fileView = 0L;
00158 }
00159
00160 delete myPreview;
00161 delete dir;
00162 delete d;
00163 }
00164
00165
00166 void KDirOperator::setSorting( QDir::SortSpec spec )
00167 {
00168 if ( m_fileView )
00169 m_fileView->setSorting( spec );
00170 mySorting = spec;
00171 updateSortActions();
00172 }
00173
00174 void KDirOperator::resetCursor()
00175 {
00176 QApplication::restoreOverrideCursor();
00177 progress->hide();
00178 }
00179
00180 void KDirOperator::insertViewDependentActions()
00181 {
00182
00183
00184
00185 if( !m_fileView )
00186 return;
00187
00188 if ( (viewActionMenu->popupMenu()->count() == 0) ||
00189 (viewActionCollection != m_fileView->actionCollection()) )
00190 {
00191 if (viewActionCollection)
00192 {
00193 disconnect( viewActionCollection, SIGNAL( inserted( KAction * )),
00194 this, SLOT( slotViewActionAdded( KAction * )));
00195 disconnect( viewActionCollection, SIGNAL( removed( KAction * )),
00196 this, SLOT( slotViewActionRemoved( KAction * )));
00197 }
00198
00199 viewActionMenu->popupMenu()->clear();
00200
00201
00202
00203 viewActionMenu->insert( myActionCollection->action( "short view" ) );
00204 viewActionMenu->insert( myActionCollection->action( "detailed view" ) );
00205 viewActionMenu->insert( actionSeparator );
00206 viewActionMenu->insert( showHiddenAction );
00207
00208 viewActionMenu->insert( separateDirsAction );
00209
00210
00211
00212 viewActionCollection = m_fileView->actionCollection();
00213 if (!viewActionCollection)
00214 return;
00215
00216 if ( !viewActionCollection->isEmpty() )
00217 {
00218 viewActionMenu->insert( d->viewActionSeparator );
00219
00220
00221 QStringList groups = viewActionCollection->groups();
00222 groups.prepend( QString::null );
00223 QStringList::ConstIterator git = groups.begin();
00224 KActionPtrList list;
00225 KAction *sep = actionCollection()->action("separator");
00226 for ( ; git != groups.end(); ++git )
00227 {
00228 if ( git != groups.begin() )
00229 viewActionMenu->insert( sep );
00230
00231 list = viewActionCollection->actions( *git );
00232 KActionPtrList::ConstIterator it = list.begin();
00233 for ( ; it != list.end(); ++it )
00234 viewActionMenu->insert( *it );
00235 }
00236 }
00237
00238 connect( viewActionCollection, SIGNAL( inserted( KAction * )),
00239 SLOT( slotViewActionAdded( KAction * )));
00240 connect( viewActionCollection, SIGNAL( removed( KAction * )),
00241 SLOT( slotViewActionRemoved( KAction * )));
00242 }
00243 }
00244
00245 void KDirOperator::activatedMenu( const KFileItem *, const QPoint& pos )
00246 {
00247 updateSelectionDependentActions();
00248
00249 actionMenu->popup( pos );
00250 }
00251
00252 void KDirOperator::updateSelectionDependentActions()
00253 {
00254 bool hasSelection = m_fileView && m_fileView->selectedItems() &&
00255 !m_fileView->selectedItems()->isEmpty();
00256 myActionCollection->action( "delete" )->setEnabled( hasSelection );
00257 myActionCollection->action( "properties" )->setEnabled( hasSelection );
00258 }
00259
00260 void KDirOperator::setPreviewWidget(const QWidget *w)
00261 {
00262 if(w != 0L)
00263 m_viewKind = (m_viewKind | KFile::PreviewContents);
00264 else
00265 m_viewKind = (m_viewKind & ~KFile::PreviewContents);
00266
00267 delete myPreview;
00268 myPreview = w;
00269
00270 KToggleAction *preview = static_cast<KToggleAction*>(myActionCollection->action("preview"));
00271 preview->setEnabled( w != 0L );
00272 preview->setChecked( w != 0L );
00273 setView( static_cast<KFile::FileView>(m_viewKind) );
00274 }
00275
00276 int KDirOperator::numDirs() const
00277 {
00278 return m_fileView ? m_fileView->numDirs() : 0;
00279 }
00280
00281 int KDirOperator::numFiles() const
00282 {
00283 return m_fileView ? m_fileView->numFiles() : 0;
00284 }
00285
00286 void KDirOperator::slotDetailedView()
00287 {
00288 KFile::FileView view = static_cast<KFile::FileView>( (m_viewKind & ~KFile::Simple) | KFile::Detail );
00289 setView( view );
00290 }
00291
00292 void KDirOperator::slotSimpleView()
00293 {
00294 KFile::FileView view = static_cast<KFile::FileView>( (m_viewKind & ~KFile::Detail) | KFile::Simple );
00295 setView( view );
00296 }
00297
00298 void KDirOperator::slotToggleHidden( bool show )
00299 {
00300 dir->setShowingDotFiles( show );
00301 updateDir();
00302 if ( m_fileView )
00303 m_fileView->listingCompleted();
00304 }
00305
00306 void KDirOperator::slotSeparateDirs()
00307 {
00308 if (separateDirsAction->isChecked())
00309 {
00310 KFile::FileView view = static_cast<KFile::FileView>( m_viewKind | KFile::SeparateDirs );
00311 setView( view );
00312 }
00313 else
00314 {
00315 KFile::FileView view = static_cast<KFile::FileView>( m_viewKind & ~KFile::SeparateDirs );
00316 setView( view );
00317 }
00318 }
00319
00320 void KDirOperator::slotDefaultPreview()
00321 {
00322 m_viewKind = m_viewKind | KFile::PreviewContents;
00323 if ( !myPreview ) {
00324 myPreview = new KFileMetaPreview( this );
00325 (static_cast<KToggleAction*>( myActionCollection->action("preview") ))->setChecked(true);
00326 }
00327
00328 setView( static_cast<KFile::FileView>(m_viewKind) );
00329 }
00330
00331 void KDirOperator::slotSortByName()
00332 {
00333 int sorting = (m_fileView->sorting()) & ~QDir::SortByMask;
00334 m_fileView->setSorting( static_cast<QDir::SortSpec>( sorting | QDir::Name ));
00335 mySorting = m_fileView->sorting();
00336 caseInsensitiveAction->setEnabled( true );
00337 }
00338
00339 void KDirOperator::slotSortBySize()
00340 {
00341 int sorting = (m_fileView->sorting()) & ~QDir::SortByMask;
00342 m_fileView->setSorting( static_cast<QDir::SortSpec>( sorting | QDir::Size ));
00343 mySorting = m_fileView->sorting();
00344 caseInsensitiveAction->setEnabled( false );
00345 }
00346
00347 void KDirOperator::slotSortByDate()
00348 {
00349 int sorting = (m_fileView->sorting()) & ~QDir::SortByMask;
00350 m_fileView->setSorting( static_cast<QDir::SortSpec>( sorting | QDir::Time ));
00351 mySorting = m_fileView->sorting();
00352 caseInsensitiveAction->setEnabled( false );
00353 }
00354
00355 void KDirOperator::slotSortReversed()
00356 {
00357 if ( m_fileView )
00358 m_fileView->sortReversed();
00359 }
00360
00361 void KDirOperator::slotToggleDirsFirst()
00362 {
00363 QDir::SortSpec sorting = m_fileView->sorting();
00364 if ( !KFile::isSortDirsFirst( sorting ) )
00365 m_fileView->setSorting( static_cast<QDir::SortSpec>( sorting | QDir::DirsFirst ));
00366 else
00367 m_fileView->setSorting( static_cast<QDir::SortSpec>( sorting & ~QDir::DirsFirst));
00368 mySorting = m_fileView->sorting();
00369 }
00370
00371 void KDirOperator::slotToggleIgnoreCase()
00372 {
00373 QDir::SortSpec sorting = m_fileView->sorting();
00374 if ( !KFile::isSortCaseInsensitive( sorting ) )
00375 m_fileView->setSorting( static_cast<QDir::SortSpec>( sorting | QDir::IgnoreCase ));
00376 else
00377 m_fileView->setSorting( static_cast<QDir::SortSpec>( sorting & ~QDir::IgnoreCase));
00378 mySorting = m_fileView->sorting();
00379 }
00380
00381 void KDirOperator::mkdir()
00382 {
00383 bool ok;
00384 QString where = url().isLocalFile() ? url().path(+1) : url().prettyURL();
00385 QString dir = KInputDialog::getText( i18n( "New Folder" ),
00386 i18n( "Create new folder in:\n%1" ).arg( where ),
00387 i18n("New Folder"), &ok, this);
00388 if (ok)
00389 mkdir( dir, true );
00390 }
00391
00392 bool KDirOperator::mkdir( const QString& directory, bool enterDirectory )
00393 {
00394
00395
00396
00397
00398 bool writeOk = false;
00399 bool exists = false;
00400 KURL url( currUrl );
00401
00402 QStringList dirs = QStringList::split( QDir::separator(), directory );
00403 QStringList::ConstIterator it = dirs.begin();
00404
00405 for ( ; it != dirs.end(); ++it )
00406 {
00407 url.addPath( *it );
00408 exists = KIO::NetAccess::exists( url, false, 0 );
00409 writeOk = !exists && KIO::NetAccess::mkdir( url, topLevelWidget() );
00410 }
00411
00412 if ( exists )
00413 {
00414 QString which = url.isLocalFile() ? url.path() : url.prettyURL();
00415 KMessageBox::sorry(viewWidget(), i18n("A file or folder named %1 already exists.").arg(which));
00416 enterDirectory = false;
00417 }
00418 else if ( !writeOk ) {
00419 KMessageBox::sorry(viewWidget(), i18n("You don't have permission to "
00420 "create that folder." ));
00421 }
00422 else if ( enterDirectory ) {
00423 setURL( url, true );
00424 }
00425
00426 return writeOk;
00427 }
00428
00429 KIO::DeleteJob * KDirOperator::del( const KFileItemList& items,
00430 bool ask, bool showProgress )
00431 {
00432 return del( items, this, ask, showProgress );
00433 }
00434
00435 KIO::DeleteJob * KDirOperator::del( const KFileItemList& items,
00436 QWidget *parent,
00437 bool ask, bool showProgress )
00438 {
00439 if ( items.isEmpty() ) {
00440 KMessageBox::information( parent,
00441 i18n("You didn't select a file to delete."),
00442 i18n("Nothing to Delete") );
00443 return 0L;
00444 }
00445
00446 KURL::List urls;
00447 QStringList files;
00448 KFileItemListIterator it( items );
00449
00450 for ( ; it.current(); ++it ) {
00451 KURL url = (*it)->url();
00452 urls.append( url );
00453 if ( url.isLocalFile() )
00454 files.append( url.path() );
00455 else
00456 files.append( url.prettyURL() );
00457 }
00458
00459 bool doIt = !ask;
00460 if ( ask ) {
00461 int ret;
00462 if ( items.count() == 1 ) {
00463 ret = KMessageBox::warningContinueCancel( parent,
00464 i18n( "<qt>Do you really want to delete\n <b>'%1'</b>?</qt>" )
00465 .arg( files.first() ),
00466 i18n("Delete File"),
00467 KGuiItem(i18n("Delete"),"editdelete"), "AskForDelete" );
00468 }
00469 else
00470 ret = KMessageBox::warningContinueCancelList( parent,
00471 i18n("translators: not called for n == 1", "Do you really want to delete these %n items?", items.count() ),
00472 files,
00473 i18n("Delete Files"),
00474 KGuiItem(i18n("Delete"), "editdelete"), "AskForDelete" );
00475 doIt = (ret == KMessageBox::Continue);
00476 }
00477
00478 if ( doIt ) {
00479 KIO::DeleteJob *job = KIO::del( urls, false, showProgress );
00480 job->setWindow (topLevelWidget());
00481 job->setAutoErrorHandlingEnabled( true, parent );
00482 return job;
00483 }
00484
00485 return 0L;
00486 }
00487
00488 void KDirOperator::deleteSelected()
00489 {
00490 if ( !m_fileView )
00491 return;
00492
00493 const KFileItemList *list = m_fileView->selectedItems();
00494 if ( list )
00495 del( *list );
00496 }
00497
00498 void KDirOperator::close()
00499 {
00500 resetCursor();
00501 pendingMimeTypes.clear();
00502 myCompletion.clear();
00503 myDirCompletion.clear();
00504 myCompleteListDirty = true;
00505 dir->stop();
00506 }
00507
00508 void KDirOperator::checkPath(const QString &, bool )
00509 {
00510 #if 0
00511
00512 QString text = _txt;
00513
00514
00515 text = text.stripWhiteSpace();
00516
00517
00518 if (text.find(':') < 0 && text[0] != '/')
00519 text.insert(0, currUrl);
00520
00521
00522
00523 if (!selection.isNull()) {
00524 int position = text.findRev('/');
00525 ASSERT(position >= 0);
00526 QString filename = text.mid(position + 1, text.length());
00527 if (filename != selection)
00528 selection = QString::null;
00529 }
00530
00531 KURL u(text);
00532 bool filenameEntered = false;
00533
00534 if (u.isLocalFile()) {
00535
00536 KFileItem i("", u.path());
00537 if (i.isDir())
00538 setURL(text, true);
00539 else {
00540 if (takeFiles)
00541 if (acceptOnlyExisting && !i.isFile())
00542 warning("you entered an invalid URL");
00543 else
00544 filenameEntered = true;
00545 }
00546 } else
00547 setURL(text, true);
00548
00549 if (filenameEntered) {
00550 filename_ = u.url();
00551 emit fileSelected(filename_);
00552
00553 QApplication::restoreOverrideCursor();
00554
00555 accept();
00556 }
00557 #endif
00558 kdDebug(kfile_area) << "TODO KDirOperator::checkPath()" << endl;
00559 }
00560
00561 void KDirOperator::setURL(const KURL& _newurl, bool clearforward)
00562 {
00563 KURL newurl;
00564
00565 if ( !_newurl.isValid() )
00566 newurl.setPath( QDir::homeDirPath() );
00567 else
00568 newurl = _newurl;
00569
00570 QString pathstr = newurl.path(+1);
00571 newurl.setPath(pathstr);
00572
00573
00574 if ( newurl.equals( currUrl, true ) )
00575 return;
00576
00577 if ( !isReadable( newurl ) ) {
00578
00579 newurl.cd(QString::fromLatin1(".."));
00580 if ( !isReadable( newurl ) ) {
00581 resetCursor();
00582 KMessageBox::error(viewWidget(),
00583 i18n("The specified folder does not exist "
00584 "or was not readable."));
00585 return;
00586 }
00587 }
00588
00589 if (clearforward) {
00590
00591 backStack.push(new KURL(currUrl));
00592 forwardStack.clear();
00593 }
00594
00595 d->lastURL = currUrl.url(-1);
00596 currUrl = newurl;
00597
00598 pathChanged();
00599 emit urlEntered(newurl);
00600
00601
00602 forwardAction->setEnabled( !forwardStack.isEmpty() );
00603 backAction->setEnabled( !backStack.isEmpty() );
00604 upAction->setEnabled( !isRoot() );
00605
00606 dir->openURL( newurl );
00607 }
00608
00609 void KDirOperator::updateDir()
00610 {
00611 dir->emitChanges();
00612 if ( m_fileView )
00613 m_fileView->listingCompleted();
00614 }
00615
00616 void KDirOperator::rereadDir()
00617 {
00618 pathChanged();
00619 dir->openURL( currUrl, false, true );
00620 }
00621
00622
00623 void KDirOperator::pathChanged()
00624 {
00625 if (!m_fileView)
00626 return;
00627
00628 pendingMimeTypes.clear();
00629 m_fileView->clear();
00630 myCompletion.clear();
00631 myDirCompletion.clear();
00632
00633
00634 QApplication::restoreOverrideCursor();
00635
00636
00637 QApplication::setOverrideCursor( waitCursor );
00638
00639 if ( !isReadable( currUrl )) {
00640 KMessageBox::error(viewWidget(),
00641 i18n("The specified folder does not exist "
00642 "or was not readable."));
00643 if (backStack.isEmpty())
00644 home();
00645 else
00646 back();
00647 }
00648 }
00649
00650 void KDirOperator::slotRedirected( const KURL& newURL )
00651 {
00652 currUrl = newURL;
00653 pendingMimeTypes.clear();
00654 myCompletion.clear();
00655 myDirCompletion.clear();
00656 myCompleteListDirty = true;
00657 emit urlEntered( newURL );
00658 }
00659
00660
00661 void KDirOperator::back()
00662 {
00663 if ( backStack.isEmpty() )
00664 return;
00665
00666 forwardStack.push( new KURL(currUrl) );
00667
00668 KURL *s = backStack.pop();
00669
00670 setURL(*s, false);
00671 delete s;
00672 }
00673
00674
00675 void KDirOperator::forward()
00676 {
00677 if ( forwardStack.isEmpty() )
00678 return;
00679
00680 backStack.push(new KURL(currUrl));
00681
00682 KURL *s = forwardStack.pop();
00683 setURL(*s, false);
00684 delete s;
00685 }
00686
00687 KURL KDirOperator::url() const
00688 {
00689 return currUrl;
00690 }
00691
00692 void KDirOperator::cdUp()
00693 {
00694 KURL tmp( currUrl );
00695 tmp.cd(QString::fromLatin1(".."));
00696 setURL(tmp, true);
00697 }
00698
00699 void KDirOperator::home()
00700 {
00701 setURL(QDir::homeDirPath(), true);
00702 }
00703
00704 void KDirOperator::clearFilter()
00705 {
00706 dir->setNameFilter( QString::null );
00707 dir->clearMimeFilter();
00708 checkPreviewSupport();
00709 }
00710
00711 void KDirOperator::setNameFilter(const QString& filter)
00712 {
00713 dir->setNameFilter(filter);
00714 checkPreviewSupport();
00715 }
00716
00717 void KDirOperator::setMimeFilter( const QStringList& mimetypes )
00718 {
00719 dir->setMimeFilter( mimetypes );
00720 checkPreviewSupport();
00721 }
00722
00723 bool KDirOperator::checkPreviewSupport()
00724 {
00725 KToggleAction *previewAction = static_cast<KToggleAction*>( myActionCollection->action( "preview" ));
00726
00727 bool hasPreviewSupport = false;
00728 KConfig *kc = KGlobal::config();
00729 KConfigGroupSaver cs( kc, ConfigGroup );
00730 if ( kc->readBoolEntry( "Show Default Preview", true ) )
00731 hasPreviewSupport = checkPreviewInternal();
00732
00733 previewAction->setEnabled( hasPreviewSupport );
00734 return hasPreviewSupport;
00735 }
00736
00737 bool KDirOperator::checkPreviewInternal() const
00738 {
00739 QStringList supported = KIO::PreviewJob::supportedMimeTypes();
00740
00741 if ( dirOnlyMode() && supported.findIndex( "inode/directory" ) == -1 )
00742 return false;
00743
00744 QStringList mimeTypes = dir->mimeFilters();
00745 QStringList nameFilter = QStringList::split( " ", dir->nameFilter() );
00746
00747 if ( mimeTypes.isEmpty() && nameFilter.isEmpty() && !supported.isEmpty() )
00748 return true;
00749 else {
00750 QRegExp r;
00751 r.setWildcard( true );
00752
00753 if ( !mimeTypes.isEmpty() ) {
00754 QStringList::Iterator it = supported.begin();
00755
00756 for ( ; it != supported.end(); ++it ) {
00757 r.setPattern( *it );
00758
00759 QStringList result = mimeTypes.grep( r );
00760 if ( !result.isEmpty() ) {
00761 return true;
00762 }
00763 }
00764 }
00765
00766 if ( !nameFilter.isEmpty() ) {
00767
00768 KServiceTypeFactory *fac = KServiceTypeFactory::self();
00769 QStringList::Iterator it1 = nameFilter.begin();
00770 for ( ; it1 != nameFilter.end(); ++it1 ) {
00771 if ( (*it1) == "*" ) {
00772 return true;
00773 }
00774
00775 KMimeType *mt = fac->findFromPattern( *it1 );
00776 if ( !mt )
00777 continue;
00778 QString mime = mt->name();
00779 delete mt;
00780
00781
00782
00783 QStringList::Iterator it2 = supported.begin();
00784 for ( ; it2 != supported.end(); ++it2 ) {
00785 r.setPattern( *it2 );
00786 if ( r.search( mime ) != -1 ) {
00787 return true;
00788 }
00789 }
00790 }
00791 }
00792 }
00793
00794 return false;
00795 }
00796
00797 KFileView* KDirOperator::createView( QWidget* parent, KFile::FileView view )
00798 {
00799 KFileView* new_view = 0L;
00800 bool separateDirs = KFile::isSeparateDirs( view );
00801 bool preview = ( KFile::isPreviewInfo(view) || KFile::isPreviewContents( view ) );
00802
00803 if ( separateDirs || preview ) {
00804 KCombiView *combi = 0L;
00805 if (separateDirs)
00806 {
00807 combi = new KCombiView( parent, "combi view" );
00808 combi->setOnlyDoubleClickSelectsFiles(d->onlyDoubleClickSelectsFiles);
00809 }
00810
00811 KFileView* v = 0L;
00812 if ( KFile::isSimpleView( view ) )
00813 v = createView( combi, KFile::Simple );
00814 else
00815 v = createView( combi, KFile::Detail );
00816
00817 v->setOnlyDoubleClickSelectsFiles(d->onlyDoubleClickSelectsFiles);
00818
00819 if (combi)
00820 combi->setRight( v );
00821
00822 if (preview)
00823 {
00824 KFilePreview* pView = new KFilePreview( combi ? combi : v, parent, "preview" );
00825 pView->setOnlyDoubleClickSelectsFiles(d->onlyDoubleClickSelectsFiles);
00826 new_view = pView;
00827 }
00828 else
00829 new_view = combi;
00830 }
00831 else if ( KFile::isDetailView( view ) && !preview ) {
00832 new_view = new KFileDetailView( parent, "detail view");
00833 new_view->setViewName( i18n("Detailed View") );
00834 }
00835 else {
00836 KFileIconView *iconView = new KFileIconView( parent, "simple view");
00837 new_view = iconView;
00838 new_view->setViewName( i18n("Short View") );
00839 }
00840
00841 new_view->widget()->setAcceptDrops(acceptDrops());
00842 return new_view;
00843 }
00844
00845 void KDirOperator::setAcceptDrops(bool b)
00846 {
00847 if (m_fileView)
00848 m_fileView->widget()->setAcceptDrops(b);
00849 QWidget::setAcceptDrops(b);
00850 }
00851
00852 void KDirOperator::setDropOptions(int options)
00853 {
00854 d->dropOptions = options;
00855 if (m_fileView)
00856 m_fileView->setDropOptions(options);
00857 }
00858
00859 void KDirOperator::setView( KFile::FileView view )
00860 {
00861 bool separateDirs = KFile::isSeparateDirs( view );
00862 bool preview=( KFile::isPreviewInfo(view) || KFile::isPreviewContents( view ) );
00863
00864 if (view == KFile::Default) {
00865 if ( KFile::isDetailView( (KFile::FileView) defaultView ) )
00866 view = KFile::Detail;
00867 else
00868 view = KFile::Simple;
00869
00870 separateDirs = KFile::isSeparateDirs( static_cast<KFile::FileView>(defaultView) );
00871 preview = ( KFile::isPreviewInfo( static_cast<KFile::FileView>(defaultView) ) ||
00872 KFile::isPreviewContents( static_cast<KFile::FileView>(defaultView) ) )
00873 && myActionCollection->action("preview")->isEnabled();
00874
00875 if ( preview ) {
00876 m_viewKind = defaultView;
00877 slotDefaultPreview();
00878 return;
00879 }
00880 else if ( !separateDirs )
00881 separateDirsAction->setChecked(true);
00882 }
00883
00884
00885 if ( (mode() & KFile::File) == 0 &&
00886 (mode() & KFile::Files) == 0 ) {
00887 separateDirs = false;
00888 separateDirsAction->setEnabled( false );
00889 }
00890
00891 m_viewKind = static_cast<int>(view) | (separateDirs ? KFile::SeparateDirs : 0);
00892 view = static_cast<KFile::FileView>(m_viewKind);
00893
00894 KFileView *new_view = createView( this, view );
00895 if ( preview ) {
00896
00897
00898 static_cast<KFilePreview*>(new_view)->setPreviewWidget(myPreview, url());
00899 }
00900
00901 setView( new_view );
00902 }
00903
00904
00905 void KDirOperator::connectView(KFileView *view)
00906 {
00907
00908 pendingMimeTypes.clear();
00909 bool listDir = true;
00910
00911 if ( dirOnlyMode() )
00912 view->setViewMode(KFileView::Directories);
00913 else
00914 view->setViewMode(KFileView::All);
00915
00916 if ( myMode & KFile::Files )
00917 view->setSelectionMode( KFile::Extended );
00918 else
00919 view->setSelectionMode( KFile::Single );
00920
00921 if (m_fileView)
00922 {
00923 if ( d->config )
00924 {
00925 m_fileView->writeConfig( d->config, d->configGroup );
00926 view->readConfig( d->config, d->configGroup );
00927 }
00928
00929
00930 view->clear();
00931 view->addItemList( *m_fileView->items() );
00932 listDir = false;
00933
00934 if ( m_fileView->widget()->hasFocus() )
00935 view->widget()->setFocus();
00936
00937 KFileItem *oldCurrentItem = m_fileView->currentFileItem();
00938 if ( oldCurrentItem ) {
00939 view->setCurrentItem( oldCurrentItem );
00940 view->setSelected( oldCurrentItem, false );
00941 view->ensureItemVisible( oldCurrentItem );
00942 }
00943
00944 const KFileItemList *oldSelected = m_fileView->selectedItems();
00945 if ( !oldSelected->isEmpty() ) {
00946 KFileItemListIterator it( *oldSelected );
00947 for ( ; it.current(); ++it )
00948 view->setSelected( it.current(), true );
00949 }
00950
00951 m_fileView->widget()->hide();
00952 delete m_fileView;
00953 }
00954
00955 else
00956 {
00957 if ( d->config )
00958 view->readConfig( d->config, d->configGroup );
00959 }
00960
00961 m_fileView = view;
00962 m_fileView->setDropOptions(d->dropOptions);
00963 viewActionCollection = 0L;
00964 KFileViewSignaler *sig = view->signaler();
00965
00966 connect(sig, SIGNAL( activatedMenu(const KFileItem *, const QPoint& ) ),
00967 this, SLOT( activatedMenu(const KFileItem *, const QPoint& )));
00968 connect(sig, SIGNAL( dirActivated(const KFileItem *) ),
00969 this, SLOT( selectDir(const KFileItem*) ) );
00970 connect(sig, SIGNAL( fileSelected(const KFileItem *) ),
00971 this, SLOT( selectFile(const KFileItem*) ) );
00972 connect(sig, SIGNAL( fileHighlighted(const KFileItem *) ),
00973 this, SLOT( highlightFile(const KFileItem*) ));
00974 connect(sig, SIGNAL( sortingChanged( QDir::SortSpec ) ),
00975 this, SLOT( slotViewSortingChanged( QDir::SortSpec )));
00976 connect(sig, SIGNAL( dropped(const KFileItem *, QDropEvent*, const KURL::List&) ),
00977 this, SIGNAL( dropped(const KFileItem *, QDropEvent*, const KURL::List&)) );
00978
00979 if ( reverseAction->isChecked() != m_fileView->isReversed() )
00980 slotSortReversed();
00981
00982 updateViewActions();
00983 m_fileView->widget()->resize(size());
00984 m_fileView->widget()->show();
00985
00986 if ( listDir ) {
00987 QApplication::setOverrideCursor( waitCursor );
00988 dir->openURL( currUrl );
00989 }
00990 else
00991 view->listingCompleted();
00992 }
00993
00994 KFile::Mode KDirOperator::mode() const
00995 {
00996 return myMode;
00997 }
00998
00999 void KDirOperator::setMode(KFile::Mode m)
01000 {
01001 if (myMode == m)
01002 return;
01003
01004 myMode = m;
01005
01006 dir->setDirOnlyMode( dirOnlyMode() );
01007
01008
01009 setView( static_cast<KFile::FileView>(m_viewKind) );
01010 }
01011
01012 void KDirOperator::setView(KFileView *view)
01013 {
01014 if ( view == m_fileView ) {
01015 return;
01016 }
01017
01018 setFocusProxy(view->widget());
01019 view->setSorting( mySorting );
01020 view->setOnlyDoubleClickSelectsFiles( d->onlyDoubleClickSelectsFiles );
01021 connectView(view);
01022
01023 emit viewChanged( view );
01024 }
01025
01026 void KDirOperator::setDirLister( KDirLister *lister )
01027 {
01028 if ( lister == dir )
01029 return;
01030
01031 delete dir;
01032 dir = lister;
01033
01034 dir->setAutoUpdate( true );
01035
01036 QWidget* mainWidget = topLevelWidget();
01037 dir->setMainWindow (mainWidget);
01038 kdDebug (kfile_area) << "mainWidget=" << mainWidget << endl;
01039
01040 connect( dir, SIGNAL( percent( int )),
01041 SLOT( slotProgress( int ) ));
01042 connect( dir, SIGNAL(started( const KURL& )), SLOT(slotStarted()));
01043 connect( dir, SIGNAL(newItems(const KFileItemList &)),
01044 SLOT(insertNewFiles(const KFileItemList &)));
01045 connect( dir, SIGNAL(completed()), SLOT(slotIOFinished()));
01046 connect( dir, SIGNAL(canceled()), SLOT(slotCanceled()));
01047 connect( dir, SIGNAL(deleteItem(KFileItem *)),
01048 SLOT(itemDeleted(KFileItem *)));
01049 connect( dir, SIGNAL(redirection( const KURL& )),
01050 SLOT( slotRedirected( const KURL& )));
01051 connect( dir, SIGNAL( clear() ), SLOT( slotClearView() ));
01052 connect( dir, SIGNAL( refreshItems( const KFileItemList& ) ),
01053 SLOT( slotRefreshItems( const KFileItemList& ) ) );
01054 }
01055
01056 void KDirOperator::insertNewFiles(const KFileItemList &newone)
01057 {
01058 if ( newone.isEmpty() || !m_fileView )
01059 return;
01060
01061 myCompleteListDirty = true;
01062 m_fileView->addItemList( newone );
01063 emit updateInformation(m_fileView->numDirs(), m_fileView->numFiles());
01064
01065 KFileItem *item;
01066 KFileItemListIterator it( newone );
01067
01068 while ( (item = it.current()) ) {
01069
01070 if ( d->dirHighlighting && item->isDir() &&
01071 item->url().url(-1) == d->lastURL ) {
01072 m_fileView->setCurrentItem( item );
01073 m_fileView->ensureItemVisible( item );
01074 }
01075
01076 ++it;
01077 }
01078
01079 QTimer::singleShot(200, this, SLOT(resetCursor()));
01080 }
01081
01082 void KDirOperator::selectDir(const KFileItem *item)
01083 {
01084 setURL(item->url(), true);
01085 }
01086
01087 void KDirOperator::itemDeleted(KFileItem *item)
01088 {
01089 pendingMimeTypes.removeRef( item );
01090 if ( m_fileView )
01091 {
01092 m_fileView->removeItem( static_cast<KFileItem *>( item ));
01093 emit updateInformation(m_fileView->numDirs(), m_fileView->numFiles());
01094 }
01095 }
01096
01097 void KDirOperator::selectFile(const KFileItem *item)
01098 {
01099 QApplication::restoreOverrideCursor();
01100
01101 emit fileSelected( item );
01102 }
01103
01104 void KDirOperator::setCurrentItem( const QString& filename )
01105 {
01106 if ( m_fileView ) {
01107 const KFileItem *item = 0L;
01108
01109 if ( !filename.isNull() )
01110 item = static_cast<KFileItem *>(dir->findByName( filename ));
01111
01112 m_fileView->clearSelection();
01113 if ( item ) {
01114 m_fileView->setCurrentItem( item );
01115 m_fileView->setSelected( item, true );
01116 m_fileView->ensureItemVisible( item );
01117 }
01118 }
01119 }
01120
01121 QString KDirOperator::makeCompletion(const QString& string)
01122 {
01123 if ( string.isEmpty() ) {
01124 m_fileView->clearSelection();
01125 return QString::null;
01126 }
01127
01128 prepareCompletionObjects();
01129 return myCompletion.makeCompletion( string );
01130 }
01131
01132 QString KDirOperator::makeDirCompletion(const QString& string)
01133 {
01134 if ( string.isEmpty() ) {
01135 m_fileView->clearSelection();
01136 return QString::null;
01137 }
01138
01139 prepareCompletionObjects();
01140 return myDirCompletion.makeCompletion( string );
01141 }
01142
01143 void KDirOperator::prepareCompletionObjects()
01144 {
01145 if ( !m_fileView )
01146 return;
01147
01148 if ( myCompleteListDirty ) {
01149 KFileItemListIterator it( *(m_fileView->items()) );
01150 for( ; it.current(); ++it ) {
01151 KFileItem *item = it.current();
01152
01153 myCompletion.addItem( item->name() );
01154 if ( item->isDir() )
01155 myDirCompletion.addItem( item->name() );
01156 }
01157 myCompleteListDirty = false;
01158 }
01159 }
01160
01161 void KDirOperator::slotCompletionMatch(const QString& match)
01162 {
01163 setCurrentItem( match );
01164 emit completion( match );
01165 }
01166
01167 void KDirOperator::setupActions()
01168 {
01169 myActionCollection = new KActionCollection( this, "KDirOperator::myActionCollection" );
01170 actionMenu = new KActionMenu( i18n("Menu"), myActionCollection, "popupMenu" );
01171 upAction = KStdAction::up( this, SLOT( cdUp() ), myActionCollection, "up" );
01172 upAction->setText( i18n("Parent Folder") );
01173 backAction = KStdAction::back( this, SLOT( back() ), myActionCollection, "back" );
01174 forwardAction = KStdAction::forward( this, SLOT(forward()), myActionCollection, "forward" );
01175 homeAction = KStdAction::home( this, SLOT( home() ), myActionCollection, "home" );
01176 homeAction->setText(i18n("Home Folder"));
01177 reloadAction = KStdAction::redisplay( this, SLOT(rereadDir()), myActionCollection, "reload" );
01178 actionSeparator = new KActionSeparator( myActionCollection, "separator" );
01179 d->viewActionSeparator = new KActionSeparator( myActionCollection,
01180 "viewActionSeparator" );
01181 mkdirAction = new KAction( i18n("New Folder..."), 0,
01182 this, SLOT( mkdir() ), myActionCollection, "mkdir" );
01183 new KAction( i18n( "Delete" ), "editdelete", Key_Delete, this,
01184 SLOT( deleteSelected() ), myActionCollection, "delete" );
01185 mkdirAction->setIcon( QString::fromLatin1("folder_new") );
01186 reloadAction->setText( i18n("Reload") );
01187 reloadAction->setShortcut( KStdAccel::shortcut( KStdAccel::Reload ));
01188
01189
01190
01191 sortActionMenu = new KActionMenu( i18n("Sorting"), myActionCollection, "sorting menu");
01192 byNameAction = new KRadioAction( i18n("By Name"), 0,
01193 this, SLOT( slotSortByName() ),
01194 myActionCollection, "by name" );
01195 byDateAction = new KRadioAction( i18n("By Date"), 0,
01196 this, SLOT( slotSortByDate() ),
01197 myActionCollection, "by date" );
01198 bySizeAction = new KRadioAction( i18n("By Size"), 0,
01199 this, SLOT( slotSortBySize() ),
01200 myActionCollection, "by size" );
01201 reverseAction = new KToggleAction( i18n("Reverse"), 0,
01202 this, SLOT( slotSortReversed() ),
01203 myActionCollection, "reversed" );
01204
01205 QString sortGroup = QString::fromLatin1("sort");
01206 byNameAction->setExclusiveGroup( sortGroup );
01207 byDateAction->setExclusiveGroup( sortGroup );
01208 bySizeAction->setExclusiveGroup( sortGroup );
01209
01210
01211 dirsFirstAction = new KToggleAction( i18n("Folders First"), 0,
01212 myActionCollection, "dirs first");
01213 caseInsensitiveAction = new KToggleAction(i18n("Case Insensitive"), 0,
01214 myActionCollection, "case insensitive" );
01215
01216 connect( dirsFirstAction, SIGNAL( toggled( bool ) ),
01217 SLOT( slotToggleDirsFirst() ));
01218 connect( caseInsensitiveAction, SIGNAL( toggled( bool ) ),
01219 SLOT( slotToggleIgnoreCase() ));
01220
01221
01222
01223
01224 viewActionMenu = new KActionMenu( i18n("&View"), myActionCollection, "view menu" );
01225 connect( viewActionMenu->popupMenu(), SIGNAL( aboutToShow() ),
01226 SLOT( insertViewDependentActions() ));
01227
01228 shortAction = new KRadioAction( i18n("Short View"), "view_multicolumn",
01229 KShortcut(), myActionCollection, "short view" );
01230 detailedAction = new KRadioAction( i18n("Detailed View"), "view_detailed",
01231 KShortcut(), myActionCollection, "detailed view" );
01232
01233 showHiddenAction = new KToggleAction( i18n("Show Hidden Files"), KShortcut(),
01234 myActionCollection, "show hidden" );
01235 separateDirsAction = new KToggleAction( i18n("Separate Folders"), KShortcut(),
01236 this,
01237 SLOT(slotSeparateDirs()),
01238 myActionCollection, "separate dirs" );
01239 KToggleAction *previewAction = new KToggleAction(i18n("Show Preview"),
01240 "thumbnail", KShortcut(),
01241 myActionCollection,
01242 "preview" );
01243 connect( previewAction, SIGNAL( toggled( bool )),
01244 SLOT( togglePreview( bool )));
01245
01246
01247 QString viewGroup = QString::fromLatin1("view");
01248 shortAction->setExclusiveGroup( viewGroup );
01249 detailedAction->setExclusiveGroup( viewGroup );
01250
01251 connect( shortAction, SIGNAL( activated() ),
01252 SLOT( slotSimpleView() ));
01253 connect( detailedAction, SIGNAL( activated() ),
01254 SLOT( slotDetailedView() ));
01255 connect( showHiddenAction, SIGNAL( toggled( bool ) ),
01256 SLOT( slotToggleHidden( bool ) ));
01257
01258 new KAction( i18n("Properties..."), KShortcut(ALT+Key_Return), this,
01259 SLOT(slotProperties()), myActionCollection, "properties" );
01260 }
01261
01262 void KDirOperator::setupMenu()
01263 {
01264 setupMenu(AllActions);
01265 }
01266
01267 void KDirOperator::setupMenu(int whichActions)
01268 {
01269
01270 sortActionMenu->popupMenu()->clear();
01271 sortActionMenu->insert( byNameAction );
01272 sortActionMenu->insert( byDateAction );
01273 sortActionMenu->insert( bySizeAction );
01274 sortActionMenu->insert( actionSeparator );
01275 sortActionMenu->insert( reverseAction );
01276 sortActionMenu->insert( dirsFirstAction );
01277 sortActionMenu->insert( caseInsensitiveAction );
01278
01279
01280 actionMenu->popupMenu()->clear();
01281 if (whichActions & NavActions)
01282 {
01283 actionMenu->insert( upAction );
01284 actionMenu->insert( backAction );
01285 actionMenu->insert( forwardAction );
01286 actionMenu->insert( homeAction );
01287 actionMenu->insert( actionSeparator );
01288 }
01289
01290 if (whichActions & FileActions)
01291 {
01292 actionMenu->insert( mkdirAction );
01293 actionMenu->insert( myActionCollection->action( "delete" ) );
01294 actionMenu->insert( actionSeparator );
01295 }
01296
01297 if (whichActions & SortActions)
01298 {
01299 actionMenu->insert( sortActionMenu );
01300 actionMenu->insert( actionSeparator );
01301 }
01302
01303 if (whichActions & ViewActions)
01304 {
01305 actionMenu->insert( viewActionMenu );
01306 actionMenu->insert( actionSeparator );
01307 }
01308
01309 if (whichActions & FileActions)
01310 {
01311 actionMenu->insert( myActionCollection->action( "properties" ) );
01312 }
01313 }
01314
01315 void KDirOperator::updateSortActions()
01316 {
01317 if ( KFile::isSortByName( mySorting ) )
01318 byNameAction->setChecked( true );
01319 else if ( KFile::isSortByDate( mySorting ) )
01320 byDateAction->setChecked( true );
01321 else if ( KFile::isSortBySize( mySorting ) )
01322 bySizeAction->setChecked( true );
01323
01324 dirsFirstAction->setChecked( KFile::isSortDirsFirst( mySorting ) );
01325 caseInsensitiveAction->setChecked( KFile::isSortCaseInsensitive(mySorting) );
01326 caseInsensitiveAction->setEnabled( KFile::isSortByName( mySorting ) );
01327
01328 if ( m_fileView )
01329 reverseAction->setChecked( m_fileView->isReversed() );
01330 }
01331
01332 void KDirOperator::updateViewActions()
01333 {
01334 KFile::FileView fv = static_cast<KFile::FileView>( m_viewKind );
01335
01336 separateDirsAction->setChecked( KFile::isSeparateDirs( fv ) &&
01337 separateDirsAction->isEnabled() );
01338
01339 shortAction->setChecked( KFile::isSimpleView( fv ));
01340 detailedAction->setChecked( KFile::isDetailView( fv ));
01341 }
01342
01343 void KDirOperator::readConfig( KConfig *kc, const QString& group )
01344 {
01345 if ( !kc )
01346 return;
01347 QString oldGroup = kc->group();
01348 if ( !group.isEmpty() )
01349 kc->setGroup( group );
01350
01351 defaultView = 0;
01352 int sorting = 0;
01353
01354 QString viewStyle = kc->readEntry( QString::fromLatin1("View Style"),
01355 QString::fromLatin1("Simple") );
01356 if ( viewStyle == QString::fromLatin1("Detail") )
01357 defaultView |= KFile::Detail;
01358 else
01359 defaultView |= KFile::Simple;
01360 if ( kc->readBoolEntry( QString::fromLatin1("Separate Directories"),
01361 DefaultMixDirsAndFiles ) )
01362 defaultView |= KFile::SeparateDirs;
01363 if ( kc->readBoolEntry(QString::fromLatin1("Show Preview"), false))
01364 defaultView |= KFile::PreviewContents;
01365
01366 if ( kc->readBoolEntry( QString::fromLatin1("Sort case insensitively"),
01367 DefaultCaseInsensitive ) )
01368 sorting |= QDir::IgnoreCase;
01369 if ( kc->readBoolEntry( QString::fromLatin1("Sort directories first"),
01370 DefaultDirsFirst ) )
01371 sorting |= QDir::DirsFirst;
01372
01373
01374 QString name = QString::fromLatin1("Name");
01375 QString sortBy = kc->readEntry( QString::fromLatin1("Sort by"), name );
01376 if ( sortBy == name )
01377 sorting |= QDir::Name;
01378 else if ( sortBy == QString::fromLatin1("Size") )
01379 sorting |= QDir::Size;
01380 else if ( sortBy == QString::fromLatin1("Date") )
01381 sorting |= QDir::Time;
01382
01383 mySorting = static_cast<QDir::SortSpec>( sorting );
01384 setSorting( mySorting );
01385
01386
01387 if ( kc->readBoolEntry( QString::fromLatin1("Show hidden files"),
01388 DefaultShowHidden ) ) {
01389 showHiddenAction->setChecked( true );
01390 dir->setShowingDotFiles( true );
01391 }
01392 if ( kc->readBoolEntry( QString::fromLatin1("Sort reversed"),
01393 DefaultSortReversed ) )
01394 reverseAction->setChecked( true );
01395
01396 kc->setGroup( oldGroup );
01397 }
01398
01399 void KDirOperator::writeConfig( KConfig *kc, const QString& group )
01400 {
01401 if ( !kc )
01402 return;
01403
01404 const QString oldGroup = kc->group();
01405
01406 if ( !group.isEmpty() )
01407 kc->setGroup( group );
01408
01409 QString sortBy = QString::fromLatin1("Name");
01410 if ( KFile::isSortBySize( mySorting ) )
01411 sortBy = QString::fromLatin1("Size");
01412 else if ( KFile::isSortByDate( mySorting ) )
01413 sortBy = QString::fromLatin1("Date");
01414 kc->writeEntry( QString::fromLatin1("Sort by"), sortBy );
01415
01416 kc->writeEntry( QString::fromLatin1("Sort reversed"),
01417 reverseAction->isChecked() );
01418 kc->writeEntry( QString::fromLatin1("Sort case insensitively"),
01419 caseInsensitiveAction->isChecked() );
01420 kc->writeEntry( QString::fromLatin1("Sort directories first"),
01421 dirsFirstAction->isChecked() );
01422
01423
01424
01425 bool appSpecificPreview = false;
01426 if ( myPreview ) {
01427 QWidget *preview = const_cast<QWidget*>( myPreview );
01428 KFileMetaPreview *tmp = dynamic_cast<KFileMetaPreview*>( preview );
01429 appSpecificPreview = (tmp == 0L);
01430 }
01431
01432 if ( !appSpecificPreview ) {
01433 if ( separateDirsAction->isEnabled() )
01434 kc->writeEntry( QString::fromLatin1("Separate Directories"),
01435 separateDirsAction->isChecked() );
01436
01437 KToggleAction *previewAction = static_cast<KToggleAction*>(myActionCollection->action("preview"));
01438 if ( previewAction->isEnabled() ) {
01439 bool hasPreview = previewAction->isChecked();
01440 kc->writeEntry( QString::fromLatin1("Show Preview"), hasPreview );
01441 }
01442 }
01443
01444 kc->writeEntry( QString::fromLatin1("Show hidden files"),
01445 showHiddenAction->isChecked() );
01446
01447 KFile::FileView fv = static_cast<KFile::FileView>( m_viewKind );
01448 QString style;
01449 if ( KFile::isDetailView( fv ) )
01450 style = QString::fromLatin1("Detail");
01451 else if ( KFile::isSimpleView( fv ) )
01452 style = QString::fromLatin1("Simple");
01453 kc->writeEntry( QString::fromLatin1("View Style"), style );
01454
01455 kc->setGroup( oldGroup );
01456 }
01457
01458
01459 void KDirOperator::resizeEvent( QResizeEvent * )
01460 {
01461 if (m_fileView)
01462 m_fileView->widget()->resize( size() );
01463
01464 if ( progress->parent() == this )
01465 progress->move(2, height() - progress->height() -2);
01466 }
01467
01468 void KDirOperator::setOnlyDoubleClickSelectsFiles( bool enable )
01469 {
01470 d->onlyDoubleClickSelectsFiles = enable;
01471 if ( m_fileView )
01472 m_fileView->setOnlyDoubleClickSelectsFiles( enable );
01473 }
01474
01475 bool KDirOperator::onlyDoubleClickSelectsFiles() const
01476 {
01477 return d->onlyDoubleClickSelectsFiles;
01478 }
01479
01480 void KDirOperator::slotStarted()
01481 {
01482 progress->setProgress( 0 );
01483
01484 d->progressDelayTimer->start( 1000, true );
01485 }
01486
01487 void KDirOperator::slotShowProgress()
01488 {
01489 progress->raise();
01490 progress->show();
01491 QApplication::flushX();
01492 }
01493
01494 void KDirOperator::slotProgress( int percent )
01495 {
01496 progress->setProgress( percent );
01497
01498 if ( progress->isVisible() )
01499 QApplication::flushX();
01500 }
01501
01502
01503 void KDirOperator::slotIOFinished()
01504 {
01505 d->progressDelayTimer->stop();
01506 slotProgress( 100 );
01507 progress->hide();
01508 emit finishedLoading();
01509 resetCursor();
01510
01511 if ( m_fileView )
01512 m_fileView->listingCompleted();
01513 }
01514
01515 void KDirOperator::slotCanceled()
01516 {
01517 emit finishedLoading();
01518 resetCursor();
01519
01520 if ( m_fileView )
01521 m_fileView->listingCompleted();
01522 }
01523
01524 KProgress * KDirOperator::progressBar() const
01525 {
01526 return progress;
01527 }
01528
01529 void KDirOperator::clearHistory()
01530 {
01531 backStack.clear();
01532 backAction->setEnabled( false );
01533 forwardStack.clear();
01534 forwardAction->setEnabled( false );
01535 }
01536
01537 void KDirOperator::slotViewActionAdded( KAction *action )
01538 {
01539 if ( viewActionMenu->popupMenu()->count() == 5 )
01540 viewActionMenu->insert( d->viewActionSeparator );
01541
01542 viewActionMenu->insert( action );
01543 }
01544
01545 void KDirOperator::slotViewActionRemoved( KAction *action )
01546 {
01547 viewActionMenu->remove( action );
01548
01549 if ( viewActionMenu->popupMenu()->count() == 6 )
01550 viewActionMenu->remove( d->viewActionSeparator );
01551 }
01552
01553 void KDirOperator::slotViewSortingChanged( QDir::SortSpec sort )
01554 {
01555 mySorting = sort;
01556 updateSortActions();
01557 }
01558
01559 void KDirOperator::setEnableDirHighlighting( bool enable )
01560 {
01561 d->dirHighlighting = enable;
01562 }
01563
01564 bool KDirOperator::dirHighlighting() const
01565 {
01566 return d->dirHighlighting;
01567 }
01568
01569 void KDirOperator::slotProperties()
01570 {
01571 if ( m_fileView ) {
01572 const KFileItemList *list = m_fileView->selectedItems();
01573 if ( !list->isEmpty() )
01574 (void) new KPropertiesDialog( *list, this, "props dlg", true);
01575 }
01576 }
01577
01578 void KDirOperator::slotClearView()
01579 {
01580 if ( m_fileView )
01581 m_fileView->clearView();
01582 }
01583
01584
01585 #include <dirent.h>
01586 bool KDirOperator::isReadable( const KURL& url )
01587 {
01588 if ( !url.isLocalFile() )
01589 return true;
01590
01591 struct stat buf;
01592 QString ts = url.path(+1);
01593 bool readable = ( ::stat( QFile::encodeName( ts ), &buf) == 0 );
01594 if (readable) {
01595 DIR *test;
01596 test = opendir( QFile::encodeName( ts ));
01597 readable = (test != 0);
01598 if (test)
01599 closedir(test);
01600 }
01601 return readable;
01602 }
01603
01604 void KDirOperator::togglePreview( bool on )
01605 {
01606 if ( on )
01607 slotDefaultPreview();
01608 else
01609 setView( (KFile::FileView) (m_viewKind & ~(KFile::PreviewContents|KFile::PreviewInfo)) );
01610 }
01611
01612 void KDirOperator::slotRefreshItems( const KFileItemList& items )
01613 {
01614 if ( !m_fileView )
01615 return;
01616
01617 KFileItemListIterator it( items );
01618 for ( ; it.current(); ++it )
01619 m_fileView->updateView( it.current() );
01620 }
01621
01622 void KDirOperator::setViewConfig( KConfig *config, const QString& group )
01623 {
01624 d->config = config;
01625 d->configGroup = group;
01626 }
01627
01628 KConfig * KDirOperator::viewConfig()
01629 {
01630 return d->config;
01631 }
01632
01633 QString KDirOperator::viewConfigGroup() const
01634 {
01635 return d->configGroup;
01636 }
01637
01638 void KDirOperator::virtual_hook( int, void* )
01639 { }
01640
01641 #include "kdiroperator.moc"